Update tests for 2.13 stdlib changes

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.

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

@@ -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/run/i3518.scala renamed to tests/disabled/run/i3518.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/i1672.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/i2960.scala

@@ -1,11 +1,5 @@
-import collection.generic.CanBuildFrom
-
 class Test[T](f: List[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/i3067.scala

@@ -1,4 +1,4 @@
-package x0.x0 {}
+package x0.x0 {} // error
 object x0 {
     def x0 (implicit  // error
-// error
+// error

tests/neg/i3067b.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/parser-stability-22.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))