Negtests with // error comments

Author: vsalvis

tests/neg/arrayclone-new.scala

@@ -7,7 +7,7 @@ object Test extends dotty.runtime.LegacyApp{
 }
 
 object ObjectArrayClone{
-  val it : Array[String] = Array("1", "0");
+  val it : Array[String] = Array("1", "0");           // error
   val cloned = it.clone();
   assert(cloned.sameElements(it));
   cloned(0) = "0";
@@ -22,7 +22,7 @@ object PolymorphicArrayClone{
     assert(it(0) == one)
   }
 
-  testIt(Array("one", "two"), "one", "two");
+  testIt(Array("one", "two"), "one", "two");          // error
 
   class Mangler[T: ClassTag](ts : T*){
     // this will always be a BoxedAnyArray even after we've unboxed its contents.

tests/neg/assignments.scala

@@ -13,11 +13,11 @@ object assignments {
     x = x + 1
     x *= 2
 
-    x_= = 2  // should give missing arguments + reassignment to val
+    x_= = 2  // error should give missing arguments + // error reassignment to val
   }
 
   var c = new C
-  import c._ // should give: prefix is not stable
+  import c._ // error should give: prefix is not stable
   x = x + 1
   x *= 2
 }

tests/neg/autoTuplingTest.scala

@@ -2,10 +2,10 @@ import dotty.language.noAutoTupling
 
 object autoTuplingNeg {
 
-  val x = Some(1, 2)
+  val x = Some(1, 2)                                  // error
 
   x match {
-    case Some(a, b) => a + b
+    case Some(a, b) => a + b                          // error // error // error
     case None =>
   }
 }

tests/neg/blockescapesNeg.scala

@@ -1,6 +1,6 @@
 object blockescapesNeg {
   def m0 = { object Foo { class Bar { val field = 2 }} ; new Foo.Bar }
-  m0.field
+  m0.field                                            // error
   class A[T]
   def m1 = { val x = 1; new A[x.type]}
 }

tests/neg/boundspropagation.scala

@@ -13,15 +13,15 @@ object test2 {
 
 
   def f(x: Any): Tree[Null] = x match {
-    case y: Tree[_] => y
+    case y: Tree[_] => y                              // error
   }
 }
 object test3 {
   class Tree[+T >: Null]
 
 
   def f(x: Any): Tree[Null] = x match {
-    case y: Tree[_] => y
+    case y: Tree[_] => y                              // error
   }
 }
 
@@ -34,11 +34,11 @@ object test4 {
     class Tree[-S, -T >: Option[S]]
 
     def g(x: Any): Tree[_, _ <: Option[N]] = x match {
-      case y: Tree[_, _] => y
+      case y: Tree[_, _] => y                         // error
     }
   }
 }
 
 class Test5 {
-"": ({ type U = this.type })#U
+"": ({ type U = this.type })#U                        // error // error
 }

tests/neg/companions.scala

@@ -8,7 +8,7 @@ object companionsNeg {
 
     { object C {
       private val p = 1
-      println(new C().q)
+      println(new C().q)   // error
     }}
   }
 

tests/neg/cycles.scala

@@ -1,39 +1,39 @@
-class Foo[T <: U, U <: T]
+class Foo[T <: U, U <: T]                             // error
 
-class Bar[T >: T]
+class Bar[T >: T]                                     // error
 
 class A {
   val x: T = ???
-  type T <: x.type
+  type T <: x.type                                    // error
 }
 
 class B {
-  type T <: x.type
+  type T <: x.type                                    // error
   val x: T = ???
 }
 
 class C {
   val x: D#T = ???
   class D {
-    type T <: x.type
+    type T <: x.type                                  // error
     val z: x.type = ???
   }
 }
 
 class E {
   class F {
     type T <: x.type
-    val z: x.type = ???
+    val z: x.type = ???                               // error
   }
   val x: F#T = ???
 }
 
 class T1 {
-  type X = (U, U) // cycle
+  type X = (U, U) // cycle                            // error
   type U = X & Int
 }
 class T2 {
-  type X = (U, U) // cycle
+  type X = (U, U) // cycle                            // error
   type U = X | Int
 }
 object T12 {

tests/neg/escapingRefs.scala

@@ -3,8 +3,8 @@ object O {
   class B
   def f[T](x: T, y: T): T = y
 
-  val x: A = f(new A { }, new B { })
+  val x: A = f(new A { }, new B { })                  // error
 
   val y = f({ class C { def member: Int = 1 }; new C }, { class C { def member: Int = 1 }; new C })
-  val z = y.member
+  val z = y.member                                    // error
 }

tests/neg/i0091-infpaths.scala

@@ -2,15 +2,15 @@ object infpaths {
 
   object a {
     trait T { t =>
-      type M <: t.b.M
+      type M <: t.b.M                                 // error
       type T <: a.T
       val b: t.T
     }
     val x: a.T = ???
   }
 
   val m1: a.x.M = ???
-  val m2: a.x.b.M = m1
-  val m3: a.x.b.b.M = m2
+  val m2: a.x.b.M = m1                                // error
+  val m3: a.x.b.b.M = m2                              // error
 
 }

tests/neg/i0248-inherit-refined.scala

@@ -1,10 +1,10 @@
 object test {
   class A { type T }
   type X = A { type T = Int }
-  class B extends X
+  class B extends X                                   // error
   type Y = A & B
-  class C extends Y
+  class C extends Y                                   // error
   type Z = A | B
-  class D extends Z
-  abstract class E extends ({ val x: Int })
+  class D extends Z                                   // error
+  abstract class E extends ({ val x: Int })           // error
 }