Adapt/remove tests for the 2.13 stdlib.

For the tests that were originally copied from scalac, I also copied the
updated version if one existed, or removed it if they had removed it.

Unfortunately, I also had to remove a bunch of Dotty tests that relied
on details of the 2.12 stdlib that I couldn't easily port to the 2.13
stdlib.

i3518 has to be disabled because using scala.Unit is marked @compileTimeOnly
and dotty crashes on @compileTimeOnly right now.

Author: smarter

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -110,7 +110,6 @@ class CompilationTests extends ParallelTesting {
       compileFile("tests/pos/erasure.scala", defaultOptions),
       compileFile("tests/pos/Coder.scala", defaultOptions),
       compileFile("tests/pos/blockescapes.scala", defaultOptions),
-      compileFile("tests/pos/collections.scala", defaultOptions),
       compileFile("tests/pos/functions1.scala", defaultOptions),
       compileFile("tests/pos/implicits1.scala", defaultOptions),
       compileFile("tests/pos/inferred.scala", defaultOptions),

tests/run/i3518.check renamed to tests/disabled/run/i3518.check

@@ -119,14 +119,5 @@ object equality {
     s1 == Nil // error
     Nil == s2 // error
     s2 == Nil // error
-
-    import collection.parallel._
-    val p1 = ParSeq(1, 2, 3)
-    val p2 = ParSeq()
-    Nil == p1 // OK
-    p1 == Nil // OK
-    Nil == p2 // OK
-    p2 == Nil // Ok
-
   }
 }

tests/run/i3518.scala renamed to tests/disabled/run/i3518.scala

@@ -1,7 +1,7 @@
 
 class Test {
   implicit def compareComparables[T](x: T)(implicit ord: Ordering[T]) = // error: result type of implicit definition needs to be given explicitly
-    new ord.Ops(x)
+    new ord.OrderingOps(x)
   class Bippy { def compare(y: Bippy) = util Random }
   () < () // error: value `<` is not a member of Unit
 }

tests/neg/parser-stability-22.scala renamed to tests/fuzzy/parser-stability-22.scala

@@ -11,7 +11,7 @@ class Tag(val name: String,
           val children: mutable.Buffer[Node] = mutable.Buffer()) extends Node {
 
     override def mkString(n: Int): String = {
-        Tag.spaces(n) + s"<$name ${attributes.map(_.name + "=" + Tag.unescape(_)).mkString(" ")}>" +
+        Tag.spaces(n) + s"<$name ${attributes.map { case (k,v) => k.name + "=" + Tag.unescape(v) }.mkString(" ")}>" +
             (if(children.isEmpty) "\n"
                 else children.map(_.mkString(n + 4)).mkString("\n", "\n", "\n")) +
         Tag.spaces(n) + s"</$name>"

tests/neg/equality.scala

@@ -1,11 +1,15 @@
-class Test[T](f: List[String] => T)
+class Foo[A] {
+  def map[B](f: A => B)(implicit bf: Int): B = ???
+}
+
+class Test[T](f: Foo[String] => T)
 
 object o {
 
   implicit val x = 3  // error
 
   implicit def y = "abc"   // error
 
-  implicit object a extends Test(_ map identity)  // error
+  implicit object a extends Test(_ map identity)  // error // error: no implicit argument found
   implicit object b extends Test(_ map identity) // error // error: cyclic reference
 }

tests/neg/i1672.scala

@@ -1,11 +1,9 @@
-import collection.generic.CanBuildFrom
+class Foo[A] {
+  def map[B](f: A => B)(implicit bf: Int): B = ???
+}
 
-class Test[T](f: List[String] => T)
+class Test[T](f: Foo[String] => T)
 
 object o {
-
-  implicitly[CanBuildFrom[String, Char, String]]
-
   implicit object b extends Test(_ map identity)  // error: type needs to be given // error: cyclic reference
-
 }

tests/neg/i2960.scala

@@ -4,15 +4,15 @@
   |                           Cannot prove that B#X <:< A#X..
   |                           I found:
   |                           
-  |                               $conforms[Nothing]
+  |                               <:<.refl[Nothing]
   |                           
-  |                           But method $conforms in object Predef does not match type B#X <:< A#X.
+  |                           But method refl in object <:< does not match type B#X <:< A#X.
 -- Error: tests/neg/subtyping.scala:12:27 ------------------------------------------------------------------------------
 12 |    implicitly[a.T <:< a.U] // error: no implicit argument
    |                           ^
    |                           Cannot prove that a.T <:< a.U..
    |                           I found:
    |                           
-   |                               $conforms[Nothing]
+   |                               <:<.refl[Nothing]
    |                           
-   |                           But method $conforms in object Predef does not match type a.T <:< a.U.
+   |                           But method refl in object <:< does not match type a.T <:< a.U.

tests/neg/i3067.scala

@@ -8,7 +8,7 @@ object Test extends App {
   println
 
   val s1 = Stream.cons(1, Stream.empty)
-  println(s1.toArray.deep)
+  println(s1.toArray.toList)
   println(s1.take(1))
   println(s1.take(2))
   println(s1.drop(1))
@@ -22,7 +22,7 @@ object Test extends App {
   println
 
   val s2 = s1.append(Stream.cons(2, Stream.empty))
-  println(s2.toArray.deep)
+  println(s2.toArray.toList)
   println(s2.drop(1))
   println(s2.drop(2))
   println(s2.drop(-1))

tests/neg/i3067b.scala

@@ -17,16 +17,16 @@ object Test extends App {
   def matmul(xss: Array[Array[Double]], yss: Array[Array[Double]]) = {
     val ysst = transpose(yss)
     val ysst1: Array[Array[Double]] = yss.transpose
-    assert(ysst.deep == ysst1.deep)
+    assert(ysst.toList == ysst1.toList)
     for (xs <- xss) yield
       for (yst <- ysst) yield
         scalprod(xs, yst)
   }
 
   val a1 = Array(Array(0, 2, 4), Array(1, 3, 5))
-  println(transpose(a1).deep.mkString("[", ",", "]"))
+  println(transpose(a1).toList.mkString("[", ",", "]"))
 
-  println(matmul(Array(Array(2, 3)), Array(Array(5), Array(7))).deep.mkString("[", ",", "]"))
+  println(matmul(Array(Array(2, 3)), Array(Array(5), Array(7))).toList.mkString("[", ",", "]"))
 
-  println(matmul(Array(Array(4)), Array(Array(6, 8))).deep.mkString("[", ",", "]"))
+  println(matmul(Array(Array(4)), Array(Array(6, 8))).toList.mkString("[", ",", "]"))
 }

tests/neg/subtyping.check

@@ -1,6 +1,6 @@
 object Test {
   def main(args: Array[String]): Unit = {
-    println(args.map(_ => foo _).deep)
+    println(args.map(_ => foo _).toList)
   }
 
   def foo(xs: String*): Unit = {

tests/pending/run/streams.scala

@@ -1,3 +1,3 @@
 (o()_)("") = List()
-(o("a1")_)("") = WrappedArray(a1)
-(o("a1", "a2")_)("") = WrappedArray(a1, a2)
+(o("a1")_)("") = ArraySeq(a1)
+(o("a1", "a2")_)("") = ArraySeq(a1, a2)