Test reorg

Author: odersky

test/dotc/tests.scala

@@ -83,7 +83,7 @@ class tests extends CompilerTest {
   @Test def neg_autoTupling2 = compileFile(negDir, "autoTuplingTest", xerrors = 4)
   @Test def neg_companions = compileFile(negDir, "companions", xerrors = 1)
   @Test def neg_over = compileFile(negDir, "over", xerrors = 1)
-  @Test def neg_overrides = compileFile(negDir, "overrides", xerrors = 7)
+  @Test def neg_overrides = compileFile(negDir, "overrides", xerrors = 8)
   @Test def neg_projections = compileFile(negDir, "projections", xerrors = 1)
   @Test def neg_i39 = compileFile(negDir, "i39", xerrors = 1)
   @Test def neg_i50_volatile = compileFile(negDir, "i50-volatile", xerrors = 4)

tests/pending/pos/t3498-old.scala renamed to tests/disabled/not-representable/pos/t3498-old.scala

@@ -7,7 +7,7 @@ object TestCase {
 
         //if fs was reduced to List (generic type with one parameter) then the code compiles
         //if you inherit from MapOps[T] instead of MapOps[F] then code compiles fine
-        implicit def map2ops[T,F](fs: Map[T,F]): TestCase.MapOps[F]{lazy val m: reflect.runtime.universe.TypeTag[T]; def is(xs: List[T]): List[List[T]]} = new MapOps[F] {
+        implicit def map2ops[T,F](fs: Map[T,F]): TestCase.MapOps[F]{val m: reflect.runtime.universe.TypeTag[T]; def is(xs: List[T]): List[List[T]]} = new MapOps[F] {
           //if you remove this line, then code compiles
       lazy val m: TypeTag[T] = sys.error("just something to make it compile")
       def is(xs: List[T]) = List(xs)

tests/pending/pos/t3175-pos.scala renamed to tests/disabled/structural-type/pos/t3175-pos.scala

@@ -5,7 +5,7 @@ object TestCase {
 
         //if fs was reduced to List (generic type with one parameter) then the code compiles
         //if you inherit from MapOps[T] instead of MapOps[F] then code compiles fine
-        implicit def map2ops[T,F](fs: Map[T,F]): TestCase.MapOps[F]{lazy val m: Manifest[T]; def is(xs: List[T]): List[List[T]]} = new MapOps[F] {
+        implicit def map2ops[T,F](fs: Map[T,F]): TestCase.MapOps[F]{val m: Manifest[T]; def is(xs: List[T]): List[List[T]]} = new MapOps[F] {
           //if you remove this line, then code compiles
 	    lazy val m: Manifest[T] = sys.error("just something to make it compile")
 	    def is(xs: List[T]) = List(xs)

tests/pending/pos/t3363-new.scala renamed to tests/disabled/structural-type/pos/t3363-new.scala

@@ -79,3 +79,24 @@ class Y2 extends X2 {
 class X3 {
   override type T = A1
 }
+
+package p3 {
+
+// Dotty change of rules: Toverrider#f does not
+// override TCommon#f, hence the accidental override rule
+// applies.
+trait TCommon {
+  def f: String
+}
+
+class C1 extends TCommon {
+  def f = "in C1"
+}
+
+trait TOverrider { this: TCommon =>
+  override def f = "in TOverrider"   // The overridden self-type member...
+}
+
+class C2 extends C1 with TOverrider  // ... fails to override, here.
+
+}

tests/pending/pos/t3363-old.scala renamed to tests/disabled/structural-type/pos/t3363-old.scala

@@ -1,4 +1,4 @@
 object Test {
-  val List(_*) = List(1)
+  val List(_: _*) = List(1)
 	val Array( who, what : _* ) = "Eclipse plugin cannot not handle this" split (" ")
 }

tests/neg/overrides.scala

@@ -2,7 +2,7 @@ object This extends App {
   trait A {
     def foo(): Unit
   }
-  class C { self: A =>
+ abstract class C { self: A =>
     def bar() = this.foo()
   }
   class D extends C with A {

tests/pending/pos/self-type-override.scala

@@ -1,32 +1,5 @@
-class A {
-  def test1(): Unit = {
-    implicitly[this.type <:< this.type]
-    implicitly[this.type <:< A]
-  }
-}
 object test {
 
-  def tag1[T](x: T): String & T = ???
-  def tag2[T](x: T): T & String = ???
-
-  val x1: Int & String = tag1(0)
-  val x2: Int & String = tag2(0)
-  val x3: String & Int = tag1(0)
-  val x4: String & Int = tag2(0)
-
-}
-
-object test2 {
-
-  class A
-  class B
-
-  val x: A | B = ???
-  val y: B | A = x
-
-  val a: A & B = ???
-  val b: B & A = a
+  val x: Int = 1
 
 }
-
-

tests/pending/pos/t3278.scala

@@ -14,7 +14,8 @@ object test {
   val a = new  A { type T = String };
   /** val b: B { type T = String } = functor(a) */
   val b: B { type T = String } = {
-    val tmp = new functor() { val arg = a };
+    val tmp = new functor() { val arg: A { type T = String } = a };
+      // Dotty deviaton: arg needs an explicit type here, or else the inherited type `A` would be assumed.
     tmp.res
   }
 

tests/pending/pos/t3480.scala

@@ -0,0 +1,30 @@
+class Foo
+class Test {
+	def update[B](x : B, b : Int): Unit = {}
+	def apply[B](x : B) = 1
+}
+class Test2 {
+  type B = Foo
+	def update(x : B, b : Int): Unit = {}
+	def apply(x : B) = 1
+}
+
+object Test {
+	def main(a : Array[String]): Unit = {
+		val a = new Test
+		val f = new Foo
+		a(f) = 1 //works
+		a(f) = a(f) + 1 //works
+		a(f) += 1 //error: reassignment to val
+	}
+}
+object Test2 {
+	def main(args : Array[String]): Unit = {
+                args(0) += "a"
+		val a = new Test2
+		val f = new Foo
+		a(f) = 1 //works
+		a(f) = a(f) + 1 //works
+		a(f) += 1 //error: reassignment to val
+	}
+}