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.