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 (" ")
 }