Make all remaining deprecations to be errors.

libraries/stdlib/test/collections/MapTest.kt

@@ -26,6 +26,7 @@ class MapTest {
         assertEquals("x", d)
     }
 
+    @Suppress("INVISIBLE_MEMBER")
     @test fun getOrImplicitDefault() {
         val data: MutableMap<String, Int> = hashMapOf("bar" to 1)
         assertTrue(assertFails { data.getOrImplicitDefault("foo") } is NoSuchElementException)
@@ -337,43 +338,6 @@ class MapTest {
     @test fun plusMap() = testPlus { it + mapOf("C" to 3, "B" to 4) }
 
 
-    fun testMinus(doMinus: (Map<String, Int>) -> Map<String, Int>) {
-        val original = mapOf("A" to 1, "B" to 2)
-        val shortened = doMinus(original)
-        assertEquals("A" to 1, shortened.entries.single().toPair())
-    }
-
-    @test fun minus() = testMinus { it - "B" - "C" }
-
-    @test fun minusList() = testMinus { it - listOf("B", "C") }
-
-    @test fun minusArray() = testMinus { it - arrayOf("B", "C") }
-
-    @test fun minusSequence() = testMinus { it - sequenceOf("B", "C") }
-
-    @test fun minusSet() = testMinus { it - setOf("B", "C") }
-
-
-
-    fun testMinusAssign(doMinusAssign: (MutableMap<String, Int>) -> Unit) {
-        val original = hashMapOf("A" to 1, "B" to 2)
-        doMinusAssign(original)
-        assertEquals("A" to 1, original.entries.single().toPair())
-    }
-
-/*
-    @test fun minusAssign() = testMinusAssign {
-        it.keys -= "B"
-        it.keys -= "C"
-    }
-
-    @test fun minusAssignList() = testMinusAssign { it.keys -= listOf("B", "C") }
-
-    @test fun minusAssignArray() = testMinusAssign { it.keys -= arrayOf("B", "C") }
-
-    @test fun minusAssignSequence() = testMinusAssign { it.keys -= sequenceOf("B", "C") }
-*/
-
 
     fun testIdempotent(operation: (Map<String, Int>) -> Map<String, Int>) {
         val original = mapOf("A" to 1, "B" to 2)
@@ -389,16 +353,12 @@ class MapTest {
 
 
     @test fun plusEmptyList() = testIdempotent { it + listOf() }
-//    @test fun minusEmptyList() = testIdempotent { it - listOf() }
 
     @test fun plusEmptySet() = testIdempotent { it + setOf() }
-//    @test fun minusEmptySet() = testIdempotent { it - setOf() }
 
     @test fun plusAssignEmptyList() = testIdempotentAssign { it += listOf() }
-//    @test fun minusAssignEmptyList() = testIdempotentAssign { it -= listOf() }
 
     @test fun plusAssignEmptySet() = testIdempotentAssign { it += setOf() }
-//    @test fun minusAssignEmptySet() = testIdempotentAssign { it -= setOf() }
 
 
 }

libraries/stdlib/test/collections/SequenceJVMTest.kt

@@ -9,18 +9,18 @@ class SequenceJVMTest {
         val src: Sequence<Any> = listOf(1, 2, 3.toDouble(), "abc", "cde").asSequence()
 
         val intValues: Sequence<Int> = src.filterIsInstance<Int>()
-        assertEquals(listOf(1, 2), intValues.toArrayList())
+        assertEquals(listOf(1, 2), intValues.toList())
 
         val doubleValues: Sequence<Double> = src.filterIsInstance<Double>()
-        assertEquals(listOf(3.0), doubleValues.toArrayList())
+        assertEquals(listOf(3.0), doubleValues.toList())
 
         val stringValues: Sequence<String> = src.filterIsInstance<String>()
-        assertEquals(listOf("abc", "cde"), stringValues.toArrayList())
+        assertEquals(listOf("abc", "cde"), stringValues.toList())
 
         val anyValues: Sequence<Any> = src.filterIsInstance<Any>()
-        assertEquals(src.toList(), anyValues.toArrayList())
+        assertEquals(src.toList(), anyValues.toList())
 
         val charValues: Sequence<Char> = src.filterIsInstance<Char>()
-        assertEquals(0, charValues.toArrayList().size)
+        assertEquals(0, charValues.toList().size)
     }
 }

libraries/stdlib/test/io/ReadWrite.kt

@@ -155,17 +155,17 @@ class LineIteratorTest {
     @test fun useLines() {
         // TODO we should maybe zap the useLines approach as it encourages
         // use of iterators which don't close the underlying stream
-        val list1 = sample().useLines { it.toArrayList() }
-        val list2 = sample().useLines<ArrayList<String>>{ it.toArrayList() }
+        val list1 = sample().useLines { it.toList() }
+        val list2 = sample().useLines<ArrayList<String>>{ it.toCollection(arrayListOf()) }
 
-        assertEquals(arrayListOf("Hello", "World"), list1)
-        assertEquals(arrayListOf("Hello", "World"), list2)
+        assertEquals(listOf("Hello", "World"), list1)
+        assertEquals(listOf("Hello", "World"), list2)
     }
 
     @test fun manualClose() {
         val reader = sample().buffered()
         try {
-            val list = reader.lineSequence().toArrayList()
+            val list = reader.lineSequence().toList()
             assertEquals(arrayListOf("Hello", "World"), list)
         } finally {
             reader.close()
@@ -174,19 +174,19 @@ class LineIteratorTest {
 
     @test fun boundaryConditions() {
         var reader = StringReader("").buffered()
-        assertEquals(ArrayList<String>(), reader.lineSequence().toArrayList())
+        assertEquals(emptyList(), reader.lineSequence().toList())
         reader.close()
 
         reader = StringReader(" ").buffered()
-        assertEquals(arrayListOf(" "), reader.lineSequence().toArrayList())
+        assertEquals(listOf(" "), reader.lineSequence().toList())
         reader.close()
 
         reader = StringReader(" \n").buffered()
-        assertEquals(arrayListOf(" "), reader.lineSequence().toArrayList())
+        assertEquals(listOf(" "), reader.lineSequence().toList())
         reader.close()
 
         reader = StringReader(" \n ").buffered()
-        assertEquals(arrayListOf(" ", " "), reader.lineSequence().toArrayList())
+        assertEquals(listOf(" ", " "), reader.lineSequence().toList())
         reader.close()
     }
 }