run srewrite version 88d3cd4126d135617a8189f0a855757d7e2ab806 on tests/untried/pos

35 files changed, 118 insertions, 57 deletions

diff --git a/tests/untried/pos/builders.scala b/tests/untried/pos/builders.scala
index fb0fdf0d0..5b863b7f0 100644
--- a/tests/untried/pos/builders.scala
+++ b/tests/untried/pos/builders.scala
@@ -1,18 +1,18 @@
 object builders {
 
   trait Builder[-From, +To, -Elem] {
-    def += (elem: Elem)
+    def += (elem: Elem): Unit
     def result: To
   }
 
-  implicit def iterableBuilder[A, B] = new Builder[Iterable[A], Iterable[B], B] {
+  implicit def iterableBuilder[A, B]: builders.Builder[Iterable[A],Iterable[B],B] = new Builder[Iterable[A], Iterable[B], B] {
     println("new iterable builder")
     private val buf = new scala.collection.mutable.ListBuffer[B]
     def += (elem: B): Unit = { buf += elem }
     def result: Iterable[B] = buf.toList
   }
 
-  implicit def listBuilder[A, B] = new Builder[List[A], List[B], B] {
+  implicit def listBuilder[A, B]: builders.Builder[List[A],List[B],B] = new Builder[List[A], List[B], B] {
     println("new list builder")
     private val buf = new scala.collection.mutable.ListBuffer[B]
     def += (elem: B): Unit = { buf += elem }
diff --git a/tests/untried/pos/exbound.scala b/tests/untried/pos/exbound.scala
index 243d5832c..be78abc26 100644
--- a/tests/untried/pos/exbound.scala
+++ b/tests/untried/pos/exbound.scala
@@ -3,5 +3,5 @@ class A[T <: A[T]] {
 }
 
 object Test {
-  val x: A[X] forSome { type X } = null
+  val x: A[_] = null
 }
diff --git a/tests/untried/pos/generic-sigs.scala b/tests/untried/pos/generic-sigs.scala
index 98c50b8e8..b751e215e 100644
--- a/tests/untried/pos/generic-sigs.scala
+++ b/tests/untried/pos/generic-sigs.scala
@@ -11,7 +11,7 @@ object A {
   def f6(x: Int) = new Bippy[t forSome { type t <: Int }]
   def f7(x: T forSome { type T <: Float }) = x
   def f8(x: T forSome { type T <: Unit }) = x
-  def f9(x: T forSome { type T <: runtime.BoxedUnit }) = x
+  def f9(x: T forSome { type T <: scala.runtime.BoxedUnit }) = x
   def f10(x: Int) = new Bippy[t forSome { type t <: Unit }]
   def f11(x: Int) = new Bippy[t forSome { type t >: Null }]
 
diff --git a/tests/untried/pos/hk-infer.scala b/tests/untried/pos/hk-infer.scala
index 30e347640..c23a9d151 100644
--- a/tests/untried/pos/hk-infer.scala
+++ b/tests/untried/pos/hk-infer.scala
@@ -20,7 +20,7 @@ object ShouldWorkHK {
     def underlying = xs
     def BOOP(ys: Seq[M[_]]) = new Booper(xs ++ ys)
   }
-  implicit def mkBoop[M[_]](xs: Seq[M[_]]) = new Booper(xs)
+  implicit def mkBoop[M[_]](xs: Seq[M[_]]): ShouldWorkHK.Booper[M] = new Booper(xs)
 
   def f1 = x BOOP y BOOP x1 BOOP x2
 }
@@ -30,7 +30,7 @@ object DoesWorkHK {
     def underlying = xs
     def BOOP(ys: Seq[M[_]]) = new Booper[M](xs ++ ys)
   }
-  implicit def mkBoop[M[_]](xs: Seq[M[_]]) = new Booper[M](xs)
+  implicit def mkBoop[M[_]](xs: Seq[M[_]]): DoesWorkHK.Booper[M] = new Booper[M](xs)
 
   def f1 = x BOOP y BOOP x1 BOOP x2
 }
diff --git a/tests/untried/pos/needstypeearly.scala b/tests/untried/pos/needstypeearly.scala
index a90c2575f..904b30cf8 100644
--- a/tests/untried/pos/needstypeearly.scala
+++ b/tests/untried/pos/needstypeearly.scala
@@ -1,4 +1,9 @@
 abstract class NeedsXEarly {
   val x: Int
 }
-class Foo extends { val x = 1 } with NeedsXEarly
+class Foo extends NeedsXEarly {
+// TODO NEEDS MANUAL CHANGE (early initializers)
+// BEGIN copied early initializers
+val x = 1
+// END copied early initializers
+}
diff --git a/tests/untried/pos/overloaded_extractor_and_regular_def.scala b/tests/untried/pos/overloaded_extractor_and_regular_def.scala
index c34dee8fa..72b9f65d8 100644
--- a/tests/untried/pos/overloaded_extractor_and_regular_def.scala
+++ b/tests/untried/pos/overloaded_extractor_and_regular_def.scala
@@ -12,7 +12,7 @@ trait TreesBase {
 }
 
 trait TreesApi extends TreesBase {
-  def Apply(x: String)
+  def Apply(x: String): Unit
 }
 
 class Universe extends TreesApi {
diff --git a/tests/untried/pos/pos-bug1241.scala b/tests/untried/pos/pos-bug1241.scala
index be8615d32..1038dc304 100644
--- a/tests/untried/pos/pos-bug1241.scala
+++ b/tests/untried/pos/pos-bug1241.scala
@@ -1,6 +1,6 @@
 object test extends App {
   // more..
-  type T = { def hello() }
+  type T = { def hello(): Unit }
   //val x4 = new AnyRef { def hello() { println("4") } } // ok!
   val x4: T = new { def hello(): Unit = { println("4") } }        // error!
   x4.hello()
diff --git a/tests/untried/pos/presuperContext.scala b/tests/untried/pos/presuperContext.scala
index 437765598..ae677c08e 100644
--- a/tests/untried/pos/presuperContext.scala
+++ b/tests/untried/pos/presuperContext.scala
@@ -1,5 +1,10 @@
 class A {
-  class C extends { val x: A = this } with AnyRef
+  class C extends AnyRef {
+// TODO NEEDS MANUAL CHANGE (early initializers)
+// BEGIN copied early initializers
+val x: A = this
+// END copied early initializers
+}
 }
 
 class B(x: Int)
diff --git a/tests/untried/pos/spec-arrays.scala b/tests/untried/pos/spec-arrays.scala
index 8c039764f..10daaba18 100644
--- a/tests/untried/pos/spec-arrays.scala
+++ b/tests/untried/pos/spec-arrays.scala
@@ -1,6 +1,6 @@
 abstract class AbsArray[T] {
   def apply(idx: Int): T
-  def update(idx: Int, elem: T)
+  def update(idx: Int, elem: T): Unit
   def length: Int
   def applyByte(idx: Int): Byte = apply(idx).asInstanceOf[Byte]
   def updateByte(idx: Int, elem: Byte) = update(idx, elem.asInstanceOf[T])
@@ -44,7 +44,7 @@ class SpecArray[@specialized T](arr: Array[T]) extends AbsArray[T] {
 
 abstract class Test {
   def sum(): Int
-  def modify(i: Int)
+  def modify(i: Int): Unit
   def run(): Unit = {
     var s = 0
     for (i <- 1 to 1000000) {
diff --git a/tests/untried/pos/t1614/foo.scala b/tests/untried/pos/t1614/foo.scala
index de225b9e5..6a45fb76d 100644
--- a/tests/untried/pos/t1614/foo.scala
+++ b/tests/untried/pos/t1614/foo.scala
@@ -1,6 +1,6 @@
 // foo.scala
 trait Foo {
-  def foo(arg: List[_])
+  def foo(arg: List[_]): Unit
 }
 trait FooImpl extends Foo {
     def foo(arg: List[_]): Unit = {}
diff --git a/tests/untried/pos/t3363-new.scala b/tests/untried/pos/t3363-new.scala
index d4d431984..f935cfe1a 100644
--- a/tests/untried/pos/t3363-new.scala
+++ b/tests/untried/pos/t3363-new.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]) = new MapOps[F] {
+        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] {
           //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)
diff --git a/tests/untried/pos/t3363-old.scala b/tests/untried/pos/t3363-old.scala
index 36d4cd933..8e54d4b4a 100644
--- a/tests/untried/pos/t3363-old.scala
+++ b/tests/untried/pos/t3363-old.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]) = new MapOps[F] {
+        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] {
           //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)
diff --git a/tests/untried/pos/t3480.scala b/tests/untried/pos/t3480.scala
index 830365170..d9a092e8a 100644
--- a/tests/untried/pos/t3480.scala
+++ b/tests/untried/pos/t3480.scala
@@ -1,4 +1,4 @@
 object Test {
   val List(_*) = List(1)
-	val Array( who, what @ _* ) = "Eclipse plugin cannot not handle this" split (" ")
+	val Array( who, what : _* ) = "Eclipse plugin cannot not handle this" split (" ")
 }
diff --git a/tests/untried/pos/t3577.scala b/tests/untried/pos/t3577.scala
index 80a280f67..1ac1786c1 100644
--- a/tests/untried/pos/t3577.scala
+++ b/tests/untried/pos/t3577.scala
@@ -4,7 +4,7 @@ case class C2(checks: Check[_]*);
 
 object C {
   def m(x : C2): Any = (null: Any) match {
-    case C2(_, rest @ _*) => {
+    case C2(_, rest : _*) => {
       rest.map(_.value)
     }
   }
diff --git a/tests/untried/pos/t3856.scala b/tests/untried/pos/t3856.scala
index 132c95c5e..6b38edc52 100644
--- a/tests/untried/pos/t3856.scala
+++ b/tests/untried/pos/t3856.scala
@@ -4,6 +4,6 @@ case class CS(xs: C[_]*)
 
 // t3856
 object Test {
-  val x = CS(C(5), C("abc")) match { case CS(C(5), xs @ _*) => xs }
+  val x = CS(C(5), C("abc")) match { case CS(C(5), xs : _*) => xs }
   println(x)
 }
diff --git a/tests/untried/pos/t3864/tuples_1.scala b/tests/untried/pos/t3864/tuples_1.scala
index 5e97f8452..a9c86af6a 100644
--- a/tests/untried/pos/t3864/tuples_1.scala
+++ b/tests/untried/pos/t3864/tuples_1.scala
@@ -11,7 +11,12 @@ trait Tuple15W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] extends EnrichedType
   def mapElements[AA, BB, CC, DD, EE, FF, GG, HH, II, JJ, KK, LL, MM, NN, OO](_1: (A => AA) = identity[A] _, _2: (B => BB) = identity[B] _, _3: (C => CC) = identity[C] _, _4: (D => DD) = identity[D] _, _5: (E => EE) = identity[E] _, _6: (F => FF) = identity[F] _, _7: (G => GG) = identity[G] _, _8: (H => HH) = identity[H] _, _9: (I => II) = identity[I] _, _10: (J => JJ) = identity[J] _, _11: (K => KK) = identity[K] _, _12: (L => LL) = identity[L] _, _13: (M => MM) = identity[M] _, _14: (N => NN) = identity[N] _, _15: (O => OO) = identity[O] _): (AA, BB, CC, DD, EE, FF, GG, HH, II, JJ, KK, LL, MM, NN, OO) = (_1(value._1), _2(value._2), _3(value._3), _4(value._4), _5(value._5), _6(value._6), _7(value._7), _8(value._8), _9(value._9), _10(value._10), _11(value._11), _12(value._12), _13(value._13), _14(value._14), _15(value._15))
 }
 
-implicit def ToTuple15W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)): Tuple15W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] = new { val value = t } with Tuple15W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O]
+implicit def ToTuple15W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)): Tuple15W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] = new Tuple15W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O] {
+// TODO NEEDS MANUAL CHANGE (early initializers)
+// BEGIN copied early initializers
+val value = t
+// END copied early initializers
+}
 
 
 trait Tuple16W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends EnrichedType[Tuple16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]] {
@@ -20,7 +25,12 @@ trait Tuple16W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] extends EnrichedT
   def mapElements[AA, BB, CC, DD, EE, FF, GG, HH, II, JJ, KK, LL, MM, NN, OO, PP](_1: (A => AA) = identity[A] _, _2: (B => BB) = identity[B] _, _3: (C => CC) = identity[C] _, _4: (D => DD) = identity[D] _, _5: (E => EE) = identity[E] _, _6: (F => FF) = identity[F] _, _7: (G => GG) = identity[G] _, _8: (H => HH) = identity[H] _, _9: (I => II) = identity[I] _, _10: (J => JJ) = identity[J] _, _11: (K => KK) = identity[K] _, _12: (L => LL) = identity[L] _, _13: (M => MM) = identity[M] _, _14: (N => NN) = identity[N] _, _15: (O => OO) = identity[O] _, _16: (P => PP) = identity[P] _): (AA, BB, CC, DD, EE, FF, GG, HH, II, JJ, KK, LL, MM, NN, OO, PP) = (_1(value._1), _2(value._2), _3(value._3), _4(value._4), _5(value._5), _6(value._6), _7(value._7), _8(value._8), _9(value._9), _10(value._10), _11(value._11), _12(value._12), _13(value._13), _14(value._14), _15(value._15), _16(value._16))
 }
 
-implicit def ToTuple16W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)): Tuple16W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] = new { val value = t } with Tuple16W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
+implicit def ToTuple16W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)): Tuple16W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] = new Tuple16W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P] {
+// TODO NEEDS MANUAL CHANGE (early initializers)
+// BEGIN copied early initializers
+val value = t
+// END copied early initializers
+}
 
 
 trait Tuple17W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends EnrichedType[Tuple17[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q]] {
@@ -29,7 +39,12 @@ trait Tuple17W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] extends Enrich
   def mapElements[AA, BB, CC, DD, EE, FF, GG, HH, II, JJ, KK, LL, MM, NN, OO, PP, QQ](_1: (A => AA) = identity[A] _, _2: (B => BB) = identity[B] _, _3: (C => CC) = identity[C] _, _4: (D => DD) = identity[D] _, _5: (E => EE) = identity[E] _, _6: (F => FF) = identity[F] _, _7: (G => GG) = identity[G] _, _8: (H => HH) = identity[H] _, _9: (I => II) = identity[I] _, _10: (J => JJ) = identity[J] _, _11: (K => KK) = identity[K] _, _12: (L => LL) = identity[L] _, _13: (M => MM) = identity[M] _, _14: (N => NN) = identity[N] _, _15: (O => OO) = identity[O] _, _16: (P => PP) = identity[P] _, _17: (Q => QQ) = identity[Q] _): (AA, BB, CC, DD, EE, FF, GG, HH, II, JJ, KK, LL, MM, NN, OO, PP, QQ) = (_1(value._1), _2(value._2), _3(value._3), _4(value._4), _5(value._5), _6(value._6), _7(value._7), _8(value._8), _9(value._9), _10(value._10), _11(value._11), _12(value._12), _13(value._13), _14(value._14), _15(value._15), _16(value._16), _17(value._17))
 }
 
-implicit def ToTuple17W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)): Tuple17W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] = new { val value = t } with Tuple17W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q]
+implicit def ToTuple17W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)): Tuple17W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] = new Tuple17W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q] {
+// TODO NEEDS MANUAL CHANGE (early initializers)
+// BEGIN copied early initializers
+val value = t
+// END copied early initializers
+}
 
 
 trait Tuple18W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends EnrichedType[Tuple18[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R]] {
@@ -38,7 +53,12 @@ trait Tuple18W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] extends Enr
   def mapElements[AA, BB, CC, DD, EE, FF, GG, HH, II, JJ, KK, LL, MM, NN, OO, PP, QQ, RR](_1: (A => AA) = identity[A] _, _2: (B => BB) = identity[B] _, _3: (C => CC) = identity[C] _, _4: (D => DD) = identity[D] _, _5: (E => EE) = identity[E] _, _6: (F => FF) = identity[F] _, _7: (G => GG) = identity[G] _, _8: (H => HH) = identity[H] _, _9: (I => II) = identity[I] _, _10: (J => JJ) = identity[J] _, _11: (K => KK) = identity[K] _, _12: (L => LL) = identity[L] _, _13: (M => MM) = identity[M] _, _14: (N => NN) = identity[N] _, _15: (O => OO) = identity[O] _, _16: (P => PP) = identity[P] _, _17: (Q => QQ) = identity[Q] _, _18: (R => RR) = identity[R] _): (AA, BB, CC, DD, EE, FF, GG, HH, II, JJ, KK, LL, MM, NN, OO, PP, QQ, RR) = (_1(value._1), _2(value._2), _3(value._3), _4(value._4), _5(value._5), _6(value._6), _7(value._7), _8(value._8), _9(value._9), _10(value._10), _11(value._11), _12(value._12), _13(value._13), _14(value._14), _15(value._15), _16(value._16), _17(value._17), _18(value._18))
 }
 
-implicit def ToTuple18W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)): Tuple18W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] = new { val value = t } with Tuple18W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R]
+implicit def ToTuple18W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)): Tuple18W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] = new Tuple18W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R] {
+// TODO NEEDS MANUAL CHANGE (early initializers)
+// BEGIN copied early initializers
+val value = t
+// END copied early initializers
+}
 
 
 trait Tuple19W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends EnrichedType[Tuple19[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]] {
@@ -47,7 +67,12 @@ trait Tuple19W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] extends
   def mapElements[AA, BB, CC, DD, EE, FF, GG, HH, II, JJ, KK, LL, MM, NN, OO, PP, QQ, RR, SS](_1: (A => AA) = identity[A] _, _2: (B => BB) = identity[B] _, _3: (C => CC) = identity[C] _, _4: (D => DD) = identity[D] _, _5: (E => EE) = identity[E] _, _6: (F => FF) = identity[F] _, _7: (G => GG) = identity[G] _, _8: (H => HH) = identity[H] _, _9: (I => II) = identity[I] _, _10: (J => JJ) = identity[J] _, _11: (K => KK) = identity[K] _, _12: (L => LL) = identity[L] _, _13: (M => MM) = identity[M] _, _14: (N => NN) = identity[N] _, _15: (O => OO) = identity[O] _, _16: (P => PP) = identity[P] _, _17: (Q => QQ) = identity[Q] _, _18: (R => RR) = identity[R] _, _19: (S => SS) = identity[S] _): (AA, BB, CC, DD, EE, FF, GG, HH, II, JJ, KK, LL, MM, NN, OO, PP, QQ, RR, SS) = (_1(value._1), _2(value._2), _3(value._3), _4(value._4), _5(value._5), _6(value._6), _7(value._7), _8(value._8), _9(value._9), _10(value._10), _11(value._11), _12(value._12), _13(value._13), _14(value._14), _15(value._15), _16(value._16), _17(value._17), _18(value._18), _19(value._19))
 }
 
-implicit def ToTuple19W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)): Tuple19W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] = new { val value = t } with Tuple19W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S]
+implicit def ToTuple19W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)): Tuple19W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] = new Tuple19W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S] {
+// TODO NEEDS MANUAL CHANGE (early initializers)
+// BEGIN copied early initializers
+val value = t
+// END copied early initializers
+}
 
 
 trait Tuple20W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] extends EnrichedType[Tuple20[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T]] {
@@ -56,7 +81,12 @@ trait Tuple20W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] exten
   def mapElements[AA, BB, CC, DD, EE, FF, GG, HH, II, JJ, KK, LL, MM, NN, OO, PP, QQ, RR, SS, TT](_1: (A => AA) = identity[A] _, _2: (B => BB) = identity[B] _, _3: (C => CC) = identity[C] _, _4: (D => DD) = identity[D] _, _5: (E => EE) = identity[E] _, _6: (F => FF) = identity[F] _, _7: (G => GG) = identity[G] _, _8: (H => HH) = identity[H] _, _9: (I => II) = identity[I] _, _10: (J => JJ) = identity[J] _, _11: (K => KK) = identity[K] _, _12: (L => LL) = identity[L] _, _13: (M => MM) = identity[M] _, _14: (N => NN) = identity[N] _, _15: (O => OO) = identity[O] _, _16: (P => PP) = identity[P] _, _17: (Q => QQ) = identity[Q] _, _18: (R => RR) = identity[R] _, _19: (S => SS) = identity[S] _, _20: (T => TT) = identity[T] _): (AA, BB, CC, DD, EE, FF, GG, HH, II, JJ, KK, LL, MM, NN, OO, PP, QQ, RR, SS, TT) = (_1(value._1), _2(value._2), _3(value._3), _4(value._4), _5(value._5), _6(value._6), _7(value._7), _8(value._8), _9(value._9), _10(value._10), _11(value._11), _12(value._12), _13(value._13), _14(value._14), _15(value._15), _16(value._16), _17(value._17), _18(value._18), _19(value._19), _20(value._20))
 }
 
-implicit def ToTuple20W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)): Tuple20W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] = new { val value = t } with Tuple20W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T]
+implicit def ToTuple20W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)): Tuple20W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] = new Tuple20W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T] {
+// TODO NEEDS MANUAL CHANGE (early initializers)
+// BEGIN copied early initializers
+val value = t
+// END copied early initializers
+}
 
 
 trait Tuple21W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] extends EnrichedType[Tuple21[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U]] {
@@ -65,7 +95,12 @@ trait Tuple21W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] ex
   def mapElements[AA, BB, CC, DD, EE, FF, GG, HH, II, JJ, KK, LL, MM, NN, OO, PP, QQ, RR, SS, TT, UU](_1: (A => AA) = identity[A] _, _2: (B => BB) = identity[B] _, _3: (C => CC) = identity[C] _, _4: (D => DD) = identity[D] _, _5: (E => EE) = identity[E] _, _6: (F => FF) = identity[F] _, _7: (G => GG) = identity[G] _, _8: (H => HH) = identity[H] _, _9: (I => II) = identity[I] _, _10: (J => JJ) = identity[J] _, _11: (K => KK) = identity[K] _, _12: (L => LL) = identity[L] _, _13: (M => MM) = identity[M] _, _14: (N => NN) = identity[N] _, _15: (O => OO) = identity[O] _, _16: (P => PP) = identity[P] _, _17: (Q => QQ) = identity[Q] _, _18: (R => RR) = identity[R] _, _19: (S => SS) = identity[S] _, _20: (T => TT) = identity[T] _, _21: (U => UU) = identity[U] _): (AA, BB, CC, DD, EE, FF, GG, HH, II, JJ, KK, LL, MM, NN, OO, PP, QQ, RR, SS, TT, UU) = (_1(value._1), _2(value._2), _3(value._3), _4(value._4), _5(value._5), _6(value._6), _7(value._7), _8(value._8), _9(value._9), _10(value._10), _11(value._11), _12(value._12), _13(value._13), _14(value._14), _15(value._15), _16(value._16), _17(value._17), _18(value._18), _19(value._19), _20(value._20), _21(value._21))
 }
 
-implicit def ToTuple21W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)): Tuple21W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] = new { val value = t } with Tuple21W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U]
+implicit def ToTuple21W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)): Tuple21W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] = new Tuple21W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U] {
+// TODO NEEDS MANUAL CHANGE (early initializers)
+// BEGIN copied early initializers
+val value = t
+// END copied early initializers
+}
 
 
 trait Tuple22W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] extends EnrichedType[Tuple22[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V]] {
@@ -74,5 +109,10 @@ trait Tuple22W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V]
   def mapElements[AA, BB, CC, DD, EE, FF, GG, HH, II, JJ, KK, LL, MM, NN, OO, PP, QQ, RR, SS, TT, UU, VV](_1: (A => AA) = identity[A] _, _2: (B => BB) = identity[B] _, _3: (C => CC) = identity[C] _, _4: (D => DD) = identity[D] _, _5: (E => EE) = identity[E] _, _6: (F => FF) = identity[F] _, _7: (G => GG) = identity[G] _, _8: (H => HH) = identity[H] _, _9: (I => II) = identity[I] _, _10: (J => JJ) = identity[J] _, _11: (K => KK) = identity[K] _, _12: (L => LL) = identity[L] _, _13: (M => MM) = identity[M] _, _14: (N => NN) = identity[N] _, _15: (O => OO) = identity[O] _, _16: (P => PP) = identity[P] _, _17: (Q => QQ) = identity[Q] _, _18: (R => RR) = identity[R] _, _19: (S => SS) = identity[S] _, _20: (T => TT) = identity[T] _, _21: (U => UU) = identity[U] _, _22: (V => VV) = identity[V] _): (AA, BB, CC, DD, EE, FF, GG, HH, II, JJ, KK, LL, MM, NN, OO, PP, QQ, RR, SS, TT, UU, VV) = (_1(value._1), _2(value._2), _3(value._3), _4(value._4), _5(value._5), _6(value._6), _7(value._7), _8(value._8), _9(value._9), _10(value._10), _11(value._11), _12(value._12), _13(value._13), _14(value._14), _15(value._15), _16(value._16), _17(value._17), _18(value._18), _19(value._19), _20(value._20), _21(value._21), _22(value._22))
 }
 
-implicit def ToTuple22W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)): Tuple22W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] = new { val value = t } with Tuple22W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V]
+implicit def ToTuple22W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](t: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)): Tuple22W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] = new Tuple22W[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V] {
+// TODO NEEDS MANUAL CHANGE (early initializers)
+// BEGIN copied early initializers
+val value = t
+// END copied early initializers
+}
 }
diff --git a/tests/untried/pos/t3866.scala b/tests/untried/pos/t3866.scala
index 140732499..f1f64edb9 100644
--- a/tests/untried/pos/t3866.scala
+++ b/tests/untried/pos/t3866.scala
@@ -2,8 +2,8 @@ abstract class ImplicitRepeated {
   trait T[+A, +B]
   trait X
 
-  def f[N, R <: List[_]](elems: T[N, R]*)                // alternative a)
-  def f[N, R <: List[_]](props: String, elems: T[N, R]*) // alternative b)
+  def f[N, R <: List[_]](elems: T[N, R]*): Unit                // alternative a)
+  def f[N, R <: List[_]](props: String, elems: T[N, R]*): Unit // alternative b)
 
   // the following implicit causes "cannot be applied" errors
   implicit def xToRight(r: X): T[Nothing, X] = null
diff --git a/tests/untried/pos/t3972.scala b/tests/untried/pos/t3972.scala
index f1a977f26..65ef43f84 100644
--- a/tests/untried/pos/t3972.scala
+++ b/tests/untried/pos/t3972.scala
@@ -1,7 +1,7 @@
 object CompilerCrash {
   def main(args: Array[String]): Unit = {
     args match {
-      case Array("a", a @ _*) => { } // The code compiles fine if this line is commented out or "@ _*" is deleted or this line is swapped for the next line
+      case Array("a", a : _*) => { } // The code compiles fine if this line is commented out or "@ _*" is deleted or this line is swapped for the next line
       case Array("b") => { } // The code compiles fine if this line is commented out
       case Array("c", c) => {
         0 // The code compiles fine if this line is commented out
diff --git a/tests/untried/pos/t3986.scala b/tests/untried/pos/t3986.scala
index 635b00b1c..ea6c64fde 100644
--- a/tests/untried/pos/t3986.scala
+++ b/tests/untried/pos/t3986.scala
@@ -1,5 +1,10 @@
 object Test {
   def main(args: Array[String]): Unit = {
-    new { val x = "abc" } with AnyRef { }
+    new AnyRef {
+// TODO NEEDS MANUAL CHANGE (early initializers)
+// BEGIN copied early initializers
+val x = "abc"
+// END copied early initializers
+ }
   }
 }
diff --git a/tests/untried/pos/t4553.scala b/tests/untried/pos/t4553.scala
index 4eefe57b2..e9bef4099 100755
--- a/tests/untried/pos/t4553.scala
+++ b/tests/untried/pos/t4553.scala
@@ -1,5 +1,5 @@
 trait VectorLike[+T, +V[A] <: Vector[A]] {
-  def +[S, VResult[S] >: V[S]](v: VResult[S])
+  def +[S, VResult[S] >: V[S]](v: VResult[S]): Unit
 }
 
 trait Vector[+T] extends VectorLike[T, Vector]
diff --git a/tests/untried/pos/t4812.scala b/tests/untried/pos/t4812.scala
index 2a807ab05..da2236770 100644
--- a/tests/untried/pos/t4812.scala
+++ b/tests/untried/pos/t4812.scala
@@ -1,4 +1,4 @@
 trait Test1 {
-  def m1(sym: Symbol = 'TestSym)
-  def m2(s: String = "TestString")
+  def m1(sym: Symbol = 'TestSym): Unit
+  def m2(s: String = "TestString"): Unit
 }
diff --git a/tests/untried/pos/t5330.scala b/tests/untried/pos/t5330.scala
index 813acd4b8..24aab7733 100644
--- a/tests/untried/pos/t5330.scala
+++ b/tests/untried/pos/t5330.scala
@@ -1,9 +1,9 @@
 trait FM[A] {
-  def map(f: A => Any)
+  def map(f: A => Any): Unit
 }
 
 trait M[A] extends FM[A] {
-  def map(f: A => Any)
+  def map(f: A => Any): Unit
 }
 
 trait N[A] extends FM[A]
diff --git a/tests/untried/pos/t5606.scala b/tests/untried/pos/t5606.scala
index 2545271e3..e3483f150 100644
--- a/tests/untried/pos/t5606.scala
+++ b/tests/untried/pos/t5606.scala
@@ -6,4 +6,4 @@
 
 
 
-case class CaseTest[_](someData:String)
+case class CaseTest[X_271044897](someData:String)
diff --git a/tests/untried/pos/t6595.scala b/tests/untried/pos/t6595.scala
index 437c0bcf0..82cca01c7 100644
--- a/tests/untried/pos/t6595.scala
+++ b/tests/untried/pos/t6595.scala
@@ -1,8 +1,11 @@
 import scala.annotation.switch
 
-class Foo extends {
-  final val b0 = 5
-} with AnyRef {
+class Foo extends AnyRef {
+// TODO NEEDS MANUAL CHANGE (early initializers)
+// BEGIN copied early initializers
+final val b0 = 5
+// END copied early initializers
+
   final val b1 = 10
 
   // Using the @switch annotation as a means of testing that the
diff --git a/tests/untried/pos/t6846.scala b/tests/untried/pos/t6846.scala
index 009566493..2536e725c 100644
--- a/tests/untried/pos/t6846.scala
+++ b/tests/untried/pos/t6846.scala
@@ -1,5 +1,5 @@
 object Test {
-  class Arb[_]
+  class Arb[X_909538798]
   implicit def foo[M[_], A]: Arb[M[A]] = null
   foo: Arb[List[Int]]
   type ListInt = List[Int]
@@ -9,7 +9,7 @@ object Test {
 object Test2 {
   import scala.collection.immutable.List
 
-  class Carb[_]
+  class Carb[X_1647473379]
   implicit def narrow[N, M[_], A](x: Carb[M[A]])(implicit ev: N <:< M[A]): Carb[N] = null
   implicit def bar[M[_], A]: Carb[M[A]] = null
 
diff --git a/tests/untried/pos/t7226.scala b/tests/untried/pos/t7226.scala
index 06f0c95dc..1b7e2549c 100644
--- a/tests/untried/pos/t7226.scala
+++ b/tests/untried/pos/t7226.scala
@@ -2,11 +2,11 @@ trait HK {
   type Rep[X]
 
   // okay
-  def unzip2[A, B](ps: Rep[List[(A, B)]])
+  def unzip2[A, B](ps: Rep[List[(A, B)]]): Unit
   unzip2(null.asInstanceOf[Rep[List[(Int, String)]]])
 
   // okay
-  def unzipHK[A, B, C[_]](ps: Rep[C[(A, B)]])
+  def unzipHK[A, B, C[_]](ps: Rep[C[(A, B)]]): Unit
   unzipHK(null.asInstanceOf[Rep[List[(Int, String)]]])
 
   def unzipHKRet0[A, C[_]](ps: C[A]): C[Int]
diff --git a/tests/untried/pos/t7591/Demo.scala b/tests/untried/pos/t7591/Demo.scala
index 696d53585..dd127b881 100644
--- a/tests/untried/pos/t7591/Demo.scala
+++ b/tests/untried/pos/t7591/Demo.scala
@@ -51,9 +51,12 @@ object DemoSpec extends DemoSpec with Property {
     }
 }
 
-class Demo(args: List[String]) extends {
-  val parsed = DemoSpec(args: _*)
-} with DemoSpec with Instance {
+class Demo(args: List[String]) extends DemoSpec with Instance {
+// TODO NEEDS MANUAL CHANGE (early initializers)
+// BEGIN copied early initializers
+val parsed = DemoSpec(args: _*)
+// END copied early initializers
+
   import java.lang.reflect._
 
   def helpMsg = DemoSpec.helpMsg
diff --git a/tests/untried/pos/t7782.scala b/tests/untried/pos/t7782.scala
index 037bdad67..9b98f6ac6 100644
--- a/tests/untried/pos/t7782.scala
+++ b/tests/untried/pos/t7782.scala
@@ -15,7 +15,7 @@ object O {
 }
 
 abstract class C[E] {
-  def foo[BB](f: BB)
+  def foo[BB](f: BB): Unit
   def test[B](f: B): Any = foo(f)
   // error: no type parameters for method foo: (<param> f: BB)scala.this.Unit exist so that it can be applied to arguments (B&1)
   // --- because ---
diff --git a/tests/untried/pos/t7782b.scala b/tests/untried/pos/t7782b.scala
index 09da4a5c5..5b1979ec1 100644
--- a/tests/untried/pos/t7782b.scala
+++ b/tests/untried/pos/t7782b.scala
@@ -15,7 +15,7 @@ object O {
 }
 
 abstract class C[E] {
-  def foo[BB](f: BB)
+  def foo[BB](f: BB): Unit
   def test[B](f: B): Any = foo(f)
   // error: no type parameters for method foo: (<param> f: BB)scala.this.Unit exist so that it can be applied to arguments (B&1)
   // --- because ---
diff --git a/tests/untried/pos/t8146b.scala b/tests/untried/pos/t8146b.scala
index dd031f66c..1a65ed518 100644
--- a/tests/untried/pos/t8146b.scala
+++ b/tests/untried/pos/t8146b.scala
@@ -47,9 +47,9 @@ class HListBench {
   implicit def columnShape[T, Level <: ShapeLevel]: Shape[Level, Column[T], T, Column[T]] = ???
   implicit def provenShape[T, P](implicit shape: Shape[_ <: FlatShapeLevel, T, _, P]): Shape[FlatShapeLevel, ProvenShape[T], T, P] = ???
   final class HListShape[Level <: ShapeLevel, M <: HList, U <: HList, P <: HList](val shapes: Seq[Shape[_ <: ShapeLevel, _, _, _]]) extends Shape[Level, M, U, P]
-  implicit def hnilShape[Level <: ShapeLevel] = new HListShape[Level, HNil.type, HNil.type, HNil.type](Nil)
+  implicit def hnilShape[Level <: ShapeLevel]: HListBench.this.HListShape[Level,HNil.type,HNil.type,HNil.type] = new HListShape[Level, HNil.type, HNil.type, HNil.type](Nil)
   implicit def hconsShape[Level <: ShapeLevel, M1, M2 <: HList, U1, U2 <: HList, P1, P2 <: HList]
-    (implicit s1: Shape[_ <: Level, M1, U1, P1], s2: HListShape[_ <: Level, M2, U2, P2]) =
+    (implicit s1: Shape[_ <: Level, M1, U1, P1], s2: HListShape[_ <: Level, M2, U2, P2]): HListBench.this.HListShape[Level,syntax.::[M1,M2],syntax.::[U1,U2],syntax.::[P1,P2]] =
     new HListShape[Level, M1 :: M2, U1 :: U2, P1 :: P2](s1 +: s2.shapes)
 
   trait A[T] {
diff --git a/tests/untried/pos/tcpoly_infer_explicit_tuple_wrapper.scala b/tests/untried/pos/tcpoly_infer_explicit_tuple_wrapper.scala
index f719972a1..30228fbd2 100644
--- a/tests/untried/pos/tcpoly_infer_explicit_tuple_wrapper.scala
+++ b/tests/untried/pos/tcpoly_infer_explicit_tuple_wrapper.scala
@@ -8,7 +8,7 @@ class IterableOps[CC[+B] <: Iterable[B] with GenericTraversableTemplate[B, CC],
 object Test {
 
   implicit def tupleOfIterableWrapper[CC[+B] <: Iterable[B] with GenericTraversableTemplate[B, CC], A1, A2](tuple: (CC[A1], Iterable[A2]))
-      = new IterableOps[CC, A1, A2](tuple)
+     : IterableOps[CC,A1,A2] = new IterableOps[CC, A1, A2](tuple)
 
   val t = (List(1, 2, 3), List(6, 5, 4))
 
diff --git a/tests/untried/pos/tcpoly_infer_implicit_tuple_wrapper.scala b/tests/untried/pos/tcpoly_infer_implicit_tuple_wrapper.scala
index 19243505b..82213719f 100644
--- a/tests/untried/pos/tcpoly_infer_implicit_tuple_wrapper.scala
+++ b/tests/untried/pos/tcpoly_infer_implicit_tuple_wrapper.scala
@@ -8,7 +8,7 @@ class IterableOps[CC[+B] <: Iterable[B] with GenericTraversableTemplate[B, CC],
 object Test {
 
   implicit def tupleOfIterableWrapper[CC[+B] <: Iterable[B] with GenericTraversableTemplate[B, CC], A1, A2](tuple: (CC[A1], Iterable[A2]))
-      = new IterableOps[CC, A1, A2](tuple)
+     : IterableOps[CC,A1,A2] = new IterableOps[CC, A1, A2](tuple)
 
   val t = (List(1, 2, 3), List(6, 5, 4))
 
diff --git a/tests/untried/pos/tcpoly_infer_ticket474.scala b/tests/untried/pos/tcpoly_infer_ticket474.scala
index 80459a6ad..9012deb2b 100644
--- a/tests/untried/pos/tcpoly_infer_ticket474.scala
+++ b/tests/untried/pos/tcpoly_infer_ticket474.scala
@@ -1,5 +1,5 @@
 trait Builder[C[_], T] {
-  def +=(x: T)
+  def +=(x: T): Unit
   def finalise: C[T]
 }
 
diff --git a/tests/untried/pos/tcpoly_infer_ticket716.scala b/tests/untried/pos/tcpoly_infer_ticket716.scala
index 24e8f663b..8268cdad9 100644
--- a/tests/untried/pos/tcpoly_infer_ticket716.scala
+++ b/tests/untried/pos/tcpoly_infer_ticket716.scala
@@ -12,7 +12,7 @@ object Functor{
   }
 
   //breaks if uncommented
-  implicit def lifttoOO[F[_],A](arg:F[A])(implicit ftr: Functor[F]) = new OOFunctor[F,A](arg)(ftr)
+  implicit def lifttoOO[F[_],A](arg:F[A])(implicit ftr: Functor[F]): OOFunctor[F,A] = new OOFunctor[F,A](arg)(ftr)
 
   //works if uncommented
   //implicit def liftListtoOO[A](arg:List[A]):OOFunctor[List,A] = new OOFunctor[List,A](arg)
@@ -21,6 +21,6 @@ object Functor{
 object GeneralLiftingDemo extends App {
   import Functor._
   val l = List(1,2,3)
-  val res = l fmap( 1+) // TODO: should not need explicit call to lifttoOO
+  val res = l fmap( 1+_) // TODO: should not need explicit call to lifttoOO
   println("OO : " + res )
 }
diff --git a/tests/untried/pos/ticket2251.scala b/tests/untried/pos/ticket2251.scala
index c220e8535..006407247 100644
--- a/tests/untried/pos/ticket2251.scala
+++ b/tests/untried/pos/ticket2251.scala
@@ -25,7 +25,7 @@ lub of List(D, C) is B[_2] forSome { type _2 >: D with C{} <: B[_1] forSome { ty
 
   val data2 = List(new C, new D)
 
-  val data3: List[B[X] forSome { type X <: B[_ <: A] }] = List(new C, new D)
+  val data3: List[B[_ <: B[_ <: A]]] = List(new C, new D)
 
   // Not yet --
   // val data4: List[B[X] forSome { type X <: B[X] }] = List(new C, new D)