Merge pull request #4272 from retronym/merge/2.11.x-to-2.12.x-20150129

Merge 2.11.x to 2.12.x

280 files changed, 3904 insertions, 816 deletions

diff --git a/test/files/jvm/innerClassAttribute/Test.scala b/test/files/jvm/innerClassAttribute/Test.scala
index 882edbcdd7..3820048cb4 100644
--- a/test/files/jvm/innerClassAttribute/Test.scala
+++ b/test/files/jvm/innerClassAttribute/Test.scala
@@ -84,17 +84,15 @@ object Test extends BytecodeTest {
   }
 
   def testA3() = {
-    def t(c: String) = {
-      val List(b1, b2) = innerClassNodes(c)
-      // the outer class for classes nested inside top-level modules is not the module class, but the mirror class.
-      // this is a hack for java interop, handled in the backend. see BTypes.scala, comment on "Java Compatibility".
-      assertMember(b1, "A3", "B1", flags = publicStatic)
-      assertMember(b2, "A3", "B2$", flags = publicStatic)
-    }
-    t("A3$")
-    // the mirror class has the same inner class attributes as the module
-    // class (added when the mirror is created in the backend)
-    t("A3")
+    // the inner class entries for top-level object members are in the companion class, so nothing in the module class
+    val List() = innerClassNodes("A3$")
+
+    // inner class entries in the companion class (a backend-generated mirror class in this case)
+    val List(b1, b2) = innerClassNodes("A3")
+    // the outer class for classes nested inside top-level modules is not the module class, but the mirror class.
+    // this is a hack for java interop, handled in the backend. see BTypes.scala, comment on "Java Compatibility".
+    assertMember(b1, "A3", "B1", flags = publicStatic)
+    assertMember(b2, "A3", "B2$", flags = publicStatic)
   }
 
   def testA4() = {
@@ -164,7 +162,10 @@ object Test extends BytecodeTest {
   }
 
   def testA15() = {
-    val List(b) = innerClassNodes("A15")
+    // no member classes, only anonymous / local. these are nested in the module class, not the companion.
+    val List() = innerClassNodes("A15")
+
+    val List(b) = innerClassNodes("A15$")
     assertLocal(b, "A15$B$3", "B$3")
 
     val List(_, c) = innerClassNodes("A15$B$3")
@@ -256,9 +257,9 @@ object Test extends BytecodeTest {
     printInnerClassNodes("A20")
 
     val fun1 = lambdaClass("A20$$anonfun$4", "A20$lambda$1")
-    val fun2 = lambdaClass("A20$$anonfun$4$$anonfun$apply$1", "A20$lambda$$$anonfun$5$1")
-    val fun3 = lambdaClass("A20$$anonfun$4$$anonfun$apply$3", "A20$lambda$$$anonfun$5$2")
-    val fun4 = lambdaClass("A20$$anonfun$4$$anonfun$apply$3$$anonfun$apply$2", "A20$lambda$$$anonfun$7$1")
+    val fun2 = lambdaClass("A20$$anonfun$4$$anonfun$apply$1", "A20$lambda$$$nestedInAnonfun$5$1")
+    val fun3 = lambdaClass("A20$$anonfun$4$$anonfun$apply$3", "A20$lambda$$$nestedInAnonfun$5$2")
+    val fun4 = lambdaClass("A20$$anonfun$4$$anonfun$apply$3$$anonfun$apply$2", "A20$lambda$$$nestedInAnonfun$7$1")
 
     println("fun1: attribute for itself and the two child closures `() => ()` and `() => () => 1`")
     printInnerClassNodes(fun1)
@@ -283,9 +284,7 @@ object Test extends BytecodeTest {
     assertMember(i3c, "A21", "I3$", flags = publicStatic)
     assertLocal(j1, "A21$J1$1", "J1$1")
 
-    val List(i2m, i3m, j3, j4, j5) = innerClassNodes("A21$")
-    assertMember(i2m, "A21", "I2", flags = publicStatic)
-    assertMember(i3m, "A21", "I3$", flags = publicStatic)
+    val List(j3, j4, j5) = innerClassNodes("A21$")
     assertLocal(j3, "A21$J3$1", "J3$1")
     assertLocal(j4, "A21$J4$1", "J4$1")
     assertLocal(j5, "A21$J5$1", "J5$1") // non-static!
diff --git a/test/files/jvm/javaReflection.check b/test/files/jvm/javaReflection.check
index aeb894f741..d40599507d 100644
--- a/test/files/jvm/javaReflection.check
+++ b/test/files/jvm/javaReflection.check
@@ -44,11 +44,11 @@ A$D$lambda$1 / A$D$lambda$1 (canon) / A$D$lambda$1 (simple)
 - declared cls: List()
 - enclosing   : null (declaring cls) / null (cls) / null (constr) / null (meth)
 - properties  : false (local) / false (member)
-A$lambda$$$anonfun$7$1 / A$lambda$$$anonfun$7$1 (canon) / A$lambda$$$anonfun$7$1 (simple)
+A$lambda$$$lessinit$greater$1 / A$lambda$$$lessinit$greater$1 (canon) / A$lambda$$$lessinit$greater$1 (simple)
 - declared cls: List()
 - enclosing   : null (declaring cls) / null (cls) / null (constr) / null (meth)
 - properties  : false (local) / false (member)
-A$lambda$$$lessinit$greater$1 / A$lambda$$$lessinit$greater$1 (canon) / A$lambda$$$lessinit$greater$1 (simple)
+A$lambda$$$nestedInAnonfun$7$1 / A$lambda$$$nestedInAnonfun$7$1 (canon) / A$lambda$$$nestedInAnonfun$7$1 (simple)
 - declared cls: List()
 - enclosing   : null (declaring cls) / null (cls) / null (constr) / null (meth)
 - properties  : false (local) / false (member)
diff --git a/test/files/jvm/t8582.check b/test/files/jvm/t8582.check
index 1d19f1d6a8..0e4da90398 100644
--- a/test/files/jvm/t8582.check
+++ b/test/files/jvm/t8582.check
@@ -17,10 +17,10 @@ Reflection can find direct nested classes (A2-B2-C2)
  A2$B2: List(class A2$B2$C2)
  A2$B2$C2: List()
 
-Mirror classes have the same InnerClass attributes as the corresponding module class:
- className[p1/p2/Singleton$Singleton$] outerClassName[p1/p2/Singleton] innerName[Singleton$] access[9]
-Module class
+The InnerClass attribute of a mirror class contains the members of the module class:
  className[p1/p2/Singleton$Singleton$] outerClassName[p1/p2/Singleton] innerName[Singleton$] access[9]
+The module members are not in the InnerClass table of the module class (unless referenced):
+ 
 
 An outer class has a InnerClass attribute for direct nested classes
  className[A1$B1] outerClassName[A1] innerName[B1] access[1]
diff --git a/test/files/jvm/t8582.scala b/test/files/jvm/t8582.scala
index 8a57ef7952..e9a01f9016 100644
--- a/test/files/jvm/t8582.scala
+++ b/test/files/jvm/t8582.scala
@@ -55,9 +55,9 @@ object Test extends BytecodeTest {
     println(nested(classOf[A2#B2]))
     println(nested(classOf[A2#B2#C2]))
 
-    nprintln("Mirror classes have the same InnerClass attributes as the corresponding module class:")
+    nprintln("The InnerClass attribute of a mirror class contains the members of the module class:")
     printInner("p1.p2.Singleton") // mirror class
-    println("Module class")
+    println("The module members are not in the InnerClass table of the module class (unless referenced):")
     printInner("p1.p2.Singleton$")
 
     nprintln("An outer class has a InnerClass attribute for direct nested classes")
diff --git a/test/files/jvm/t9044.scala b/test/files/jvm/t9044.scala
new file mode 100644
index 0000000000..b1073325e8
--- /dev/null
+++ b/test/files/jvm/t9044.scala
@@ -0,0 +1,6 @@
+trait A
+trait B
+object Test extends A with B with App {
+  val is = Test.getClass.getInterfaces.mkString(", ")
+  assert(is == "interface A, interface B, interface scala.App", is)
+}
diff --git a/test/files/neg/literals.check b/test/files/neg/literals.check
new file mode 100644
index 0000000000..148a9346c5
--- /dev/null
+++ b/test/files/neg/literals.check
@@ -0,0 +1,40 @@
+literals.scala:6: error: missing integer number
+  def missingHex: Int    = { 0x }        // line 4: was: not reported, taken as zero
+                             ^
+literals.scala:8: error: Decimal integer literals may not have a leading zero. (Octal syntax is obsolete.)
+  def leadingZeros: Int  = { 01 }        // line 6: no leading zero
+                             ^
+literals.scala:10: error: Decimal integer literals may not have a leading zero. (Octal syntax is obsolete.)
+  def tooManyZeros: Int  = { 00 }        // line 8: no leading zero
+                             ^
+literals.scala:12: error: Decimal integer literals may not have a leading zero. (Octal syntax is obsolete.)
+  def zeroOfNine: Int    = { 09 }        // line 10: no leading zero
+                             ^
+literals.scala:16: error: Decimal integer literals may not have a leading zero. (Octal syntax is obsolete.)
+  def zeroOfNineDot: Int = { 09. }       // line 14: malformed integer, ident expected
+                             ^
+literals.scala:23: error: missing integer number
+  def missingHex: Int    = 0x            // line 22: was: not reported, taken as zero
+                           ^
+literals.scala:27: error: Decimal integer literals may not have a leading zero. (Octal syntax is obsolete.)
+  def tooManyZeros: Int  = 00            // line 26: no leading zero
+                           ^
+literals.scala:14: error: identifier expected but '}' found.
+  def orphanDot: Int     = { 9. }        // line 12: ident expected
+                                ^
+literals.scala:16: error: identifier expected but '}' found.
+  def zeroOfNineDot: Int = { 09. }       // line 14: malformed integer, ident expected
+                                 ^
+literals.scala:18: error: ';' expected but double literal found.
+  def noHexFloat: Double = { 0x1.2 }     // line 16: ';' expected but double literal found.
+                                ^
+literals.scala:25: error: ';' expected but 'def' found.
+  def leadingZeros: Int  = 01            // line 24: no leading zero
+  ^
+literals.scala:29: error: ';' expected but 'def' found.
+  def zeroOfNine: Int    = 09            // line 28: no leading zero
+  ^
+literals.scala:33: error: identifier expected but 'def' found.
+  def zeroOfNineDot: Int = 09.           // line 32: malformed integer, ident expected
+  ^
+13 errors found
diff --git a/test/files/neg/literals.scala b/test/files/neg/literals.scala
new file mode 100644
index 0000000000..3df7f0b408
--- /dev/null
+++ b/test/files/neg/literals.scala
@@ -0,0 +1,36 @@
+
+/* This took me literally all day.
+*/
+trait RejectedLiterals {
+
+  def missingHex: Int    = { 0x }        // line 4: was: not reported, taken as zero
+
+  def leadingZeros: Int  = { 01 }        // line 6: no leading zero
+
+  def tooManyZeros: Int  = { 00 }        // line 8: no leading zero
+
+  def zeroOfNine: Int    = { 09 }        // line 10: no leading zero
+
+  def orphanDot: Int     = { 9. }        // line 12: ident expected
+
+  def zeroOfNineDot: Int = { 09. }       // line 14: malformed integer, ident expected
+
+  def noHexFloat: Double = { 0x1.2 }     // line 16: ';' expected but double literal found.
+}
+
+trait Braceless {
+
+  def missingHex: Int    = 0x            // line 22: was: not reported, taken as zero
+
+  def leadingZeros: Int  = 01            // line 24: no leading zero
+
+  def tooManyZeros: Int  = 00            // line 26: no leading zero
+
+  def zeroOfNine: Int    = 09            // line 28: no leading zero
+
+  def orphanDot: Int     = 9.            // line 30: ident expected
+
+  def zeroOfNineDot: Int = 09.           // line 32: malformed integer, ident expected
+
+  def noHexFloat: Double = 0x1.2         // line 34: ';' expected but double literal found.
+}
diff --git a/test/files/neg/literate_existentials.scala b/test/files/neg/literate_existentials.scala
index 8580347bf9..5537c50b3a 100644
--- a/test/files/neg/literate_existentials.scala
+++ b/test/files/neg/literate_existentials.scala
@@ -187,7 +187,7 @@ object LiterateExistentials {
 //
 
   implicitly[Int <:< (M forSome { type M >: Nothing <: String })] // fails
-// The preceeding line causes the compiler to generate an error message.
+// The preceding line causes the compiler to generate an error message.
 
 
 
diff --git a/test/files/neg/patmatexhaust.check b/test/files/neg/patmatexhaust.check
index 2dad608451..bbf5e9b528 100644
--- a/test/files/neg/patmatexhaust.check
+++ b/test/files/neg/patmatexhaust.check
@@ -12,7 +12,7 @@ It would fail on the following inputs: (Kult(_), Kult(_)), (Qult(), Qult())
                       ^
 patmatexhaust.scala:49: warning: match may not be exhaustive.
 It would fail on the following inputs: Gp(), Gu
-    def ma4(x:Deep) = x match { // missing cases: Gu, Gp
+    def ma4(x:Deep) = x match { // missing cases: Gu, Gp which is not abstract so must be included
                       ^
 patmatexhaust.scala:55: warning: unreachable code
       case _ if 1 == 0 =>
diff --git a/test/files/neg/patmatexhaust.flags b/test/files/neg/patmatexhaust.flags
index 85d8eb2ba2..3b01ca062c 100644
--- a/test/files/neg/patmatexhaust.flags
+++ b/test/files/neg/patmatexhaust.flags
@@ -1 +1 @@
--Xfatal-warnings
+-Xfatal-warnings -Ypatmat-exhaust-depth off
\ No newline at end of file
diff --git a/test/files/neg/patmatexhaust.scala b/test/files/neg/patmatexhaust.scala
index f937197829..26f0c12a91 100644
--- a/test/files/neg/patmatexhaust.scala
+++ b/test/files/neg/patmatexhaust.scala
@@ -46,7 +46,7 @@ class TestSealedExhaustive { // compile only
       case _ =>
     }
 
-    def ma4(x:Deep) = x match { // missing cases: Gu, Gp
+    def ma4(x:Deep) = x match { // missing cases: Gu, Gp which is not abstract so must be included
       case Ga =>
     }
 
diff --git a/test/files/neg/sammy_error_exist_no_crash.check b/test/files/neg/sammy_error_exist_no_crash.check
new file mode 100644
index 0000000000..a0d2237ce0
--- /dev/null
+++ b/test/files/neg/sammy_error_exist_no_crash.check
@@ -0,0 +1,6 @@
+sammy_error_exist_no_crash.scala:5: error: Could not derive subclass of F[? >: String]
+ (with SAM `def method apply(s: String)Int`)
+ based on: ((x$1: String) => x$1.<parseInt: error>).
+  bar(_.parseInt)
+        ^
+one error found
diff --git a/test/files/neg/sammy_error_exist_no_crash.flags b/test/files/neg/sammy_error_exist_no_crash.flags
new file mode 100644
index 0000000000..e1b37447c9
--- /dev/null
+++ b/test/files/neg/sammy_error_exist_no_crash.flags
@@ -0,0 +1 @@
+-Xexperimental
\ No newline at end of file
diff --git a/test/files/neg/sammy_error_exist_no_crash.scala b/test/files/neg/sammy_error_exist_no_crash.scala
new file mode 100644
index 0000000000..da7e47206f
--- /dev/null
+++ b/test/files/neg/sammy_error_exist_no_crash.scala
@@ -0,0 +1,6 @@
+abstract class F[T] { def apply(s: T): Int }
+
+object NeedsNiceError {
+  def bar(x: F[_ >: String]) = ???
+  bar(_.parseInt)
+}
\ No newline at end of file
diff --git a/test/files/neg/sammy_restrictions.scala b/test/files/neg/sammy_restrictions.scala
index 5f1a04cd20..d003cfaf36 100644
--- a/test/files/neg/sammy_restrictions.scala
+++ b/test/files/neg/sammy_restrictions.scala
@@ -1,28 +1,28 @@
-class NoAbstract
+abstract class NoAbstract
 
-class TwoAbstract { def ap(a: Int): Int; def pa(a: Int): Int }
+abstract class TwoAbstract { def ap(a: Int): Int; def pa(a: Int): Int }
 
-class Base // check that the super class constructor isn't considered.
-class NoEmptyConstructor(a: Int) extends Base { def this(a: String) = this(0); def ap(a: Int): Int }
+abstract class Base // check that the super class constructor isn't considered.
+abstract class NoEmptyConstructor(a: Int) extends Base { def this(a: String) = this(0); def ap(a: Int): Int }
 
-class OneEmptyConstructor() { def this(a: Int) = this(); def ap(a: Int): Int }
+abstract class OneEmptyConstructor() { def this(a: Int) = this(); def ap(a: Int): Int }
 
-class OneEmptySecondaryConstructor(a: Int) { def this() = this(0); def ap(a: Int): Int }
+abstract class OneEmptySecondaryConstructor(a: Int) { def this() = this(0); def ap(a: Int): Int }
 
-class MultipleConstructorLists()() { def ap(a: Int): Int }
+abstract class MultipleConstructorLists()() { def ap(a: Int): Int }
 
-class MultipleMethodLists()() { def ap(a: Int)(): Int }
+abstract class MultipleMethodLists()() { def ap(a: Int)(): Int }
 
-class ImplicitConstructorParam()(implicit a: String) { def ap(a: Int): Int }
+abstract class ImplicitConstructorParam()(implicit a: String) { def ap(a: Int): Int }
 
-class ImplicitMethodParam() { def ap(a: Int)(implicit b: String): Int }
+abstract class ImplicitMethodParam() { def ap(a: Int)(implicit b: String): Int }
 
-class PolyClass[T] { def ap(a: T): T }
+abstract class PolyClass[T] { def ap(a: T): T }
 
-class PolyMethod { def ap[T](a: T): T }
+abstract class PolyMethod { def ap[T](a: T): T }
 
-class OneAbstract { def ap(a: Any): Any }
-class DerivedOneAbstract extends OneAbstract
+abstract class OneAbstract { def ap(a: Int): Any }
+abstract class DerivedOneAbstract extends OneAbstract
 
 object Test {
   implicit val s: String = ""
diff --git a/test/files/neg/structural.scala b/test/files/neg/structural.scala
index d783399317..00459676a9 100644
--- a/test/files/neg/structural.scala
+++ b/test/files/neg/structural.scala
@@ -11,13 +11,13 @@ object Test extends App {
     def f2[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: B): Object; val x: B }) = x.m[Tata](x.x) //fail
     def f3[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: C): Object; val x: C }) = x.m[Tata](x.x) //fail
     def f4[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: D): Object; val x: D }) = x.m[Tata](x.x) //fail
-    def f5[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: E): Object; val x: Tata }) = x.m[Tata](x.x) //suceed
+    def f5[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: E): Object; val x: Tata }) = x.m[Tata](x.x) //succeeds
 
-    def f6[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: Object): A }) = x.m[Tata](null) //suceed
-    def f7[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: Object): B }) = x.m[Tata](null) //suceed
-    def f8[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: Object): C }) = x.m[Tata](null) //suceed
+    def f6[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: Object): A }) = x.m[Tata](null) //succeeds
+    def f7[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: Object): B }) = x.m[Tata](null) //succeeds
+    def f8[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: Object): C }) = x.m[Tata](null) //succeeds
     def f9[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: Object): D }) = x.m[Tata](null) //fail
-    def f0[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: Object): E }) = x.m[Tata](null) //suceed
+    def f0[C <: Object](x: Object{ type D <: Object; def m[E >: Null <: Object](x: Object): E }) = x.m[Tata](null) //succeeds
 
   }
 
diff --git a/test/files/neg/t2866.check b/test/files/neg/t2866.check
new file mode 100644
index 0000000000..340fb8da22
--- /dev/null
+++ b/test/files/neg/t2866.check
@@ -0,0 +1,17 @@
+t2866.scala:30: warning: imported `one' is permanently hidden by definition of value one
+    import A.one // warning: imported `one' is permanently hidden by definition of value one.
+             ^
+t2866.scala:42: error: ambiguous implicit values:
+ both value two of type Int
+ and value one in object A of type => Int
+ match expected type Int
+    assert(implicitly[Int] == 2) // !!! Not ambiguous in 2.8.0. Ambigous in 2.7.6
+                     ^
+t2866.scala:50: error: ambiguous implicit values:
+ both value two of type Int
+ and value one in object A of type => Int
+ match expected type Int
+    assert(implicitly[Int] == 2) // !!! Not ambiguous in 2.8.0. Ambiguous in 2.7.6
+                     ^
+one warning found
+two errors found
diff --git a/test/files/neg/t2866.scala b/test/files/neg/t2866.scala
new file mode 100644
index 0000000000..55ebff9710
--- /dev/null
+++ b/test/files/neg/t2866.scala
@@ -0,0 +1,59 @@
+// for 2.7.x compatibility
+
+object A {
+  implicit val one = 1
+}
+
+object Test {
+
+  locally {
+    import A._
+    locally {
+      // assert(implicitly[Int] == 1) // error: could not find implicit value for parameter e: Int.
+                                     // !!! Why one A.one?
+      // (I assume you mean: why _not_ A.one? A.one is shadowed by local one.
+      // but the local one cannot be used yet because it does not have an explicit type.
+      implicit val one = 2
+      assert(implicitly[Int] == 2)
+      assert(one == 2)
+    }
+  }
+
+  locally {
+    import A._
+    implicit val one: Int = 2
+    assert(implicitly[Int] == 2)
+    assert(one == 2)
+  }
+
+  locally {
+    import A.one // warning: imported `one' is permanently hidden by definition of value one.
+                 // !!! Really?
+    //assert(implicitly[Int] == 1)
+    implicit val one = 2
+    assert(implicitly[Int] == 2) // !!! why not 2?
+    assert(one == 2)
+  }
+
+  locally {
+    import A.one
+    assert(implicitly[Int] == 1)
+    implicit val two = 2
+    assert(implicitly[Int] == 2) // !!! Not ambiguous in 2.8.0. Ambigous in 2.7.6
+  }
+
+  locally {
+    import A._
+    assert(implicitly[Int] == 1)
+    implicit val two = 2
+    import A.{one => _}
+    assert(implicitly[Int] == 2) // !!! Not ambiguous in 2.8.0. Ambiguous in 2.7.6
+  }
+
+  locally {
+    import A.{one => _, _}
+    implicit val two = 2
+    assert(implicitly[Int] == 2) // not ambiguous in 2.8.0 nor im ambiguous in 2.7.6
+  }
+
+}
diff --git a/test/files/neg/t3240.check b/test/files/neg/t3240.check
deleted file mode 100644
index efae682c66..0000000000
--- a/test/files/neg/t3240.check
+++ /dev/null
@@ -1,4 +0,0 @@
-t3240.scala:3: error: only classes can have declared but undefined members
-  type t
-       ^
-one error found
diff --git a/test/files/neg/t5091.check b/test/files/neg/t5091.check
new file mode 100644
index 0000000000..abd24e3145
--- /dev/null
+++ b/test/files/neg/t5091.check
@@ -0,0 +1,9 @@
+t5091.scala:8: error: recursive value xxx needs type
+    val param = bar(xxx)
+                    ^
+t5091.scala:7: warning: type-checking the invocation of method foo checks if the named argument expression 'param = ...' is a valid assignment
+in the current scope. The resulting type inference error (see above) can be fixed by providing an explicit type in the local definition for param.
+    val xxx = foo(param = null)
+                        ^
+one warning found
+one error found
diff --git a/test/files/neg/t5091.scala b/test/files/neg/t5091.scala
new file mode 100644
index 0000000000..217e83f66d
--- /dev/null
+++ b/test/files/neg/t5091.scala
@@ -0,0 +1,11 @@
+object RecursiveValueNeedsType {
+
+  def foo(param: String) = 42
+  def bar(n: Int) = 42
+
+  {
+    val xxx = foo(param = null)
+    val param = bar(xxx)
+  }
+  
+}
diff --git a/test/files/neg/t5148.check b/test/files/neg/t5148.check
index 0de4fe2d4c..286ed9e04a 100644
--- a/test/files/neg/t5148.check
+++ b/test/files/neg/t5148.check
@@ -1,6 +1,11 @@
 error: missing or invalid dependency detected while loading class file 'Imports.class'.
+Could not access type Wrapper in class scala.tools.nsc.interpreter.IMain.Request,
+because it (or its dependencies) are missing. Check your build definition for
+missing or conflicting dependencies. (Re-run with `-Ylog-classpath` to see the problematic classpath.)
+A full rebuild may help if 'Imports.class' was compiled against an incompatible version of scala.tools.nsc.interpreter.IMain.Request.
+error: missing or invalid dependency detected while loading class file 'Imports.class'.
 Could not access type Request in class scala.tools.nsc.interpreter.IMain,
 because it (or its dependencies) are missing. Check your build definition for
 missing or conflicting dependencies. (Re-run with `-Ylog-classpath` to see the problematic classpath.)
 A full rebuild may help if 'Imports.class' was compiled against an incompatible version of scala.tools.nsc.interpreter.IMain.
-one error found
+two errors found
diff --git a/test/files/neg/t5639b.check b/test/files/neg/t5639b.check
new file mode 100644
index 0000000000..faa1766660
--- /dev/null
+++ b/test/files/neg/t5639b.check
@@ -0,0 +1,4 @@
+A_2.scala:6: error: could not find implicit value for parameter e: Int
+  implicitly[Int]
+            ^
+one error found
diff --git a/test/files/neg/t5639b/A_1.scala b/test/files/neg/t5639b/A_1.scala
new file mode 100644
index 0000000000..c5da10eae4
--- /dev/null
+++ b/test/files/neg/t5639b/A_1.scala
@@ -0,0 +1,17 @@
+import Implicits._
+
+class Baz
+
+object Test {
+  implicitly[Int]
+}
+
+object Implicits  {
+  implicit val Baz: Int = 0
+  // This implicit was being ignored by `isQualifyingImplicit`
+  // if the classpath contained a class file for `class Baz`.
+  // This is because the package scope contains a speculative
+  // symbol for `object Baz` which is entered by `SymbolLoaders`
+  // before looking inside the class file. (A Java originated
+  // classfile results in the class/module symbol pair.)
+}
diff --git a/test/files/neg/t5639b/A_2.scala b/test/files/neg/t5639b/A_2.scala
new file mode 100644
index 0000000000..2bb36273e0
--- /dev/null
+++ b/test/files/neg/t5639b/A_2.scala
@@ -0,0 +1,11 @@
+import Implicits._
+
+class Baz
+
+object Test {
+  implicitly[Int]
+}
+
+object Implicits  {
+  implicit val Baz: Int = 0
+}
diff --git a/test/files/neg/t6582_exhaust_big.check b/test/files/neg/t6582_exhaust_big.check
new file mode 100644
index 0000000000..9e2be038b5
--- /dev/null
+++ b/test/files/neg/t6582_exhaust_big.check
@@ -0,0 +1,7 @@
+t6582_exhaust_big.scala:27: warning: match may not be exhaustive.
+It would fail on the following input: Z11()
+  def foo(z: Z) = z match {
+                  ^
+error: No warnings can be incurred under -Xfatal-warnings.
+one warning found
+one error found
diff --git a/test/files/neg/t6582_exhaust_big.flags b/test/files/neg/t6582_exhaust_big.flags
new file mode 100644
index 0000000000..b5a8748652
--- /dev/null
+++ b/test/files/neg/t6582_exhaust_big.flags
@@ -0,0 +1 @@
+-Xfatal-warnings -unchecked
diff --git a/test/files/neg/t6582_exhaust_big.scala b/test/files/neg/t6582_exhaust_big.scala
new file mode 100644
index 0000000000..dd639eb56e
--- /dev/null
+++ b/test/files/neg/t6582_exhaust_big.scala
@@ -0,0 +1,32 @@
+sealed abstract class Z
+object Z {
+   object     Z0    extends Z
+   case class Z1()  extends Z
+   object     Z2    extends Z
+   case class Z3()  extends Z
+   object     Z4    extends Z
+   case class Z5()  extends Z
+   object     Z6    extends Z
+   case class Z7()  extends Z
+   object     Z8    extends Z
+   case class Z9()  extends Z
+   object     Z10   extends Z
+   case class Z11() extends Z
+   object     Z12   extends Z
+   case class Z13() extends Z
+   object     Z14   extends Z
+   case class Z15() extends Z
+   object     Z16   extends Z
+   case class Z17() extends Z
+   object     Z18   extends Z
+   case class Z19() extends Z
+}
+
+object Test {
+  import Z._
+  def foo(z: Z) = z match {
+    case Z0  | Z1()  | Z2  | Z3()  | Z4  | Z5()  | Z6  | Z7()  | Z8  | Z9() |
+         Z10 | Z12 | Z13() | Z14 | Z15() | Z16 | Z17() | Z18 | Z19()
+         =>
+  }
+}
diff --git a/test/files/neg/t6902.scala b/test/files/neg/t6902.scala
index ce5ff8b6fb..627c324279 100644
--- a/test/files/neg/t6902.scala
+++ b/test/files/neg/t6902.scala
@@ -16,7 +16,7 @@ object Test {
   // at scala.reflect.internal.SymbolTable.abort(SymbolTable.scala:50)
   // at scala.tools.nsc.Global.abort(Global.scala:249)
   // at scala.tools.nsc.backend.jvm.GenASM$JPlainBuilder$jcode$.emitSWITCH(GenASM.scala:1850)
-  ((1: Byte): @unchecked @annotation.switch) match {
+  ((1: Byte): @unchecked) match {
     case 1 => 2
     case 1 => 3 // crash
   }
diff --git a/test/files/neg/t7602.check b/test/files/neg/t7602.check
new file mode 100644
index 0000000000..5bb1450d7d
--- /dev/null
+++ b/test/files/neg/t7602.check
@@ -0,0 +1,5 @@
+t7602.scala:16: error: method foo is defined twice
+  conflicting symbols both originated in file 't7602.scala'
+  def foo : Device
+      ^
+one error found
diff --git a/test/files/neg/t7602.scala b/test/files/neg/t7602.scala
new file mode 100644
index 0000000000..5a9444a1ab
--- /dev/null
+++ b/test/files/neg/t7602.scala
@@ -0,0 +1,26 @@
+trait Table[T]{
+  def foo : T
+}
+trait Computer
+trait Device
+ 
+object schema{
+  def lub[T]( a:T, b:T ) = ???
+  lub(null:Computers,null:Devices)
+}
+trait Computers extends Table[Computer]{
+  def foo : Computer
+}
+trait Devices extends Table[Device]{
+  def foo : Device
+  def foo : Device
+}
+/* Was:
+Exception in thread "main" java.lang.AssertionError: assertion failed: List(method foo, method foo)
+        at scala.Predef$.assert(Predef.scala:165)
+        at scala.reflect.internal.Symbols$Symbol.suchThat(Symbols.scala:1916)
+        at scala.reflect.internal.tpe.GlbLubs$$anonfun$23.apply(GlbLubs.scala:350)
+        at scala.reflect.internal.tpe.GlbLubs$$anonfun$23.apply(GlbLubs.scala:349)
+        at scala.collection.immutable.List.map(List.scala:272)
+        at scala.reflect.internal.tpe.GlbLubs$class.lubsym$1(GlbLubs.scala:349)
+*/
\ No newline at end of file
diff --git a/test/files/neg/t7636.check b/test/files/neg/t7636.check
index f70d50bee3..12391cccc8 100644
--- a/test/files/neg/t7636.check
+++ b/test/files/neg/t7636.check
@@ -4,7 +4,7 @@ t7636.scala:3: error: illegal inheritance;
                   ^
 t7636.scala:3: error: type mismatch;
  found   : Either[_$2,_$3(in constructor C)] where type _$3(in constructor C), type _$2
- required: Either[_, _$3(in object Main)] where type _$3(in object Main)
+ required: Either[_, _$3(in value <local Main>)] where type _$3(in value <local Main>)
   class C extends ResultTable(Left(5):Either[_,_])(5)
                                      ^
 two errors found
diff --git a/test/files/neg/t8217-local-alias-requires-rhs.check b/test/files/neg/t8217-local-alias-requires-rhs.check
new file mode 100644
index 0000000000..0d4f0864ba
--- /dev/null
+++ b/test/files/neg/t8217-local-alias-requires-rhs.check
@@ -0,0 +1,10 @@
+t8217-local-alias-requires-rhs.scala:6: error: only classes can have declared but undefined members
+    type B
+         ^
+t8217-local-alias-requires-rhs.scala:3: error: only classes can have declared but undefined members
+    type A
+         ^
+t8217-local-alias-requires-rhs.scala:14: error: only classes can have declared but undefined members
+  def this(a: Any) = { this(); type C }
+                                    ^
+three errors found
diff --git a/test/files/neg/t8217-local-alias-requires-rhs.scala b/test/files/neg/t8217-local-alias-requires-rhs.scala
new file mode 100644
index 0000000000..12b7976835
--- /dev/null
+++ b/test/files/neg/t8217-local-alias-requires-rhs.scala
@@ -0,0 +1,15 @@
+trait Alias {
+  def foo = {
+    type A
+  }
+  val bar = {
+    type B
+    object O {
+      type OK
+    }
+  }
+}
+
+class C {
+  def this(a: Any) = { this(); type C }
+}
diff --git a/test/files/neg/t8291.check b/test/files/neg/t8291.check
new file mode 100644
index 0000000000..c9972e5575
--- /dev/null
+++ b/test/files/neg/t8291.check
@@ -0,0 +1,7 @@
+t8291.scala:5: error: Could not find implicit for Int or String
+  implicitly[X[Int, String]]
+            ^
+t8291.scala:6: error: Could not find implicit for Int or String
+  implicitly[Z[String]]
+            ^
+two errors found
diff --git a/test/files/neg/t8291.scala b/test/files/neg/t8291.scala
new file mode 100644
index 0000000000..b344586a56
--- /dev/null
+++ b/test/files/neg/t8291.scala
@@ -0,0 +1,7 @@
+@scala.annotation.implicitNotFound("Could not find implicit for ${T} or ${U}") trait X[T, U]
+
+object Test {
+  type Z[U] = X[Int, U]
+  implicitly[X[Int, String]]
+  implicitly[Z[String]]
+}
diff --git a/test/files/neg/t8430.check b/test/files/neg/t8430.check
index 7c6a73ce53..dbc0c70bba 100644
--- a/test/files/neg/t8430.check
+++ b/test/files/neg/t8430.check
@@ -1,25 +1,25 @@
 t8430.scala:15: warning: match may not be exhaustive.
-It would fail on the following inputs: ??, LetC, LetF, LetL(IntLit), LetP
+It would fail on the following inputs: LetC, LetF, LetL(BooleanLit), LetL(IntLit), LetL(UnitLit), LetP
   (tree: Tree) => tree match {case LetL(CharLit) => ??? }
                   ^
 t8430.scala:16: warning: match may not be exhaustive.
-It would fail on the following inputs: ??, LetC, LetF, LetL(IntLit), LetP
+It would fail on the following inputs: LetC, LetF, LetL(BooleanLit), LetL(IntLit), LetL(UnitLit), LetP
   (tree: Tree) => tree match {case LetL(CharLit) => ??? }
                   ^
 t8430.scala:17: warning: match may not be exhaustive.
-It would fail on the following inputs: ??, LetC, LetF, LetL(IntLit), LetP
+It would fail on the following inputs: LetC, LetF, LetL(BooleanLit), LetL(IntLit), LetL(UnitLit), LetP
   (tree: Tree) => tree match {case LetL(CharLit) => ??? }
                   ^
 t8430.scala:18: warning: match may not be exhaustive.
-It would fail on the following inputs: ??, LetC, LetF, LetL(IntLit), LetP
+It would fail on the following inputs: LetC, LetF, LetL(BooleanLit), LetL(IntLit), LetL(UnitLit), LetP
   (tree: Tree) => tree match {case LetL(CharLit) => ??? }
                   ^
 t8430.scala:19: warning: match may not be exhaustive.
-It would fail on the following inputs: ??, LetC, LetF, LetL(IntLit), LetP
+It would fail on the following inputs: LetC, LetF, LetL(BooleanLit), LetL(IntLit), LetL(UnitLit), LetP
   (tree: Tree) => tree match {case LetL(CharLit) => ??? }
                   ^
 t8430.scala:20: warning: match may not be exhaustive.
-It would fail on the following inputs: ??, LetC, LetF, LetL(IntLit), LetP
+It would fail on the following inputs: LetC, LetF, LetL(BooleanLit), LetL(IntLit), LetL(UnitLit), LetP
   (tree: Tree) => tree match {case LetL(CharLit) => ??? }
                   ^
 error: No warnings can be incurred under -Xfatal-warnings.
diff --git a/test/files/neg/t8430.flags b/test/files/neg/t8430.flags
index 85d8eb2ba2..6f60189a8d 100644
--- a/test/files/neg/t8430.flags
+++ b/test/files/neg/t8430.flags
@@ -1 +1 @@
--Xfatal-warnings
+-Xfatal-warnings -Ypatmat-exhaust-depth off
diff --git a/test/files/neg/t845.check b/test/files/neg/t845.check
deleted file mode 100644
index 07ed7e417b..0000000000
--- a/test/files/neg/t845.check
+++ /dev/null
@@ -1,4 +0,0 @@
-t845.scala:4: error: only classes can have declared but undefined members
-  type Bar;
-       ^
-one error found
diff --git a/test/files/neg/t8534.check b/test/files/neg/t8534.check
new file mode 100644
index 0000000000..297e7c1beb
--- /dev/null
+++ b/test/files/neg/t8534.check
@@ -0,0 +1,4 @@
+t8534.scala:6: error: MyTrait is not an enclosing class
+  class BugTest {def isTheBugHere(in: MyTrait.this.type#SomeData) = false}
+                                      ^
+one error found
diff --git a/test/files/neg/t8534.scala b/test/files/neg/t8534.scala
new file mode 100644
index 0000000000..f118d22b82
--- /dev/null
+++ b/test/files/neg/t8534.scala
@@ -0,0 +1,7 @@
+object line1 {
+  trait MyTrait
+}
+object line2 {
+  import line2._
+  class BugTest {def isTheBugHere(in: MyTrait.this.type#SomeData) = false}
+}
diff --git a/test/files/neg/t8534b.check b/test/files/neg/t8534b.check
new file mode 100644
index 0000000000..39ffa41194
--- /dev/null
+++ b/test/files/neg/t8534b.check
@@ -0,0 +1,4 @@
+t8534b.scala:3: error: stable identifier required, but foo.type found.
+  type T = foo.type#Foo
+              ^
+one error found
diff --git a/test/files/neg/t8534b.scala b/test/files/neg/t8534b.scala
new file mode 100644
index 0000000000..73b6703a9c
--- /dev/null
+++ b/test/files/neg/t8534b.scala
@@ -0,0 +1,4 @@
+object Test {
+  def foo = ""
+  type T = foo.type#Foo
+}
diff --git a/test/files/neg/t8597.check b/test/files/neg/t8597.check
new file mode 100644
index 0000000000..bc945f9191
--- /dev/null
+++ b/test/files/neg/t8597.check
@@ -0,0 +1,21 @@
+t8597.scala:2: warning: abstract type T in type pattern Some[T] is unchecked since it is eliminated by erasure
+  def nowarn[T] = (null: Any) match { case _: Some[T]      => } // warn (did not warn due to SI-8597)
+                                              ^
+t8597.scala:5: warning: abstract type pattern T is unchecked since it is eliminated by erasure
+  def warn1[T]  = (null: Any) match { case _: T            => } // warn
+                                              ^
+t8597.scala:6: warning: non-variable type argument String in type pattern Some[String] is unchecked since it is eliminated by erasure
+  def warn2     = (null: Any) match { case _: Some[String] => } // warn
+                                              ^
+t8597.scala:7: warning: non-variable type argument Unchecked.this.C in type pattern Some[Unchecked.this.C] is unchecked since it is eliminated by erasure
+                  (null: Any) match { case _: Some[C]      => } // warn
+                                              ^
+t8597.scala:18: warning: abstract type T in type pattern Array[T] is unchecked since it is eliminated by erasure
+  def warnArray[T] = (null: Any) match { case _: Array[T] => } // warn (did not warn due to SI-8597)
+                                                 ^
+t8597.scala:26: warning: non-variable type argument String in type pattern Array[Array[List[String]]] is unchecked since it is eliminated by erasure
+  def warnArrayErasure2   = (null: Any) match {case Some(_: Array[Array[List[String]]]) => } // warn
+                                                            ^
+error: No warnings can be incurred under -Xfatal-warnings.
+6 warnings found
+one error found
diff --git a/test/files/pos/switch-small.flags b/test/files/neg/t8597.flags
index 85d8eb2ba2..85d8eb2ba2 100644
--- a/test/files/pos/switch-small.flags
+++ b/test/files/neg/t8597.flags
diff --git a/test/files/neg/t8597.scala b/test/files/neg/t8597.scala
new file mode 100644
index 0000000000..068e87d91a
--- /dev/null
+++ b/test/files/neg/t8597.scala
@@ -0,0 +1,27 @@
+class Unchecked[C] {
+  def nowarn[T] = (null: Any) match { case _: Some[T]      => } // warn (did not warn due to SI-8597)
+
+  // These warned before.
+  def warn1[T]  = (null: Any) match { case _: T            => } // warn
+  def warn2     = (null: Any) match { case _: Some[String] => } // warn
+                  (null: Any) match { case _: Some[C]      => } // warn
+
+  // These must remain without warnings. These are excerpts from
+  // related tests that are more exhauative.
+  class C; class D extends C
+  def okay      = (List(new D) : Seq[D]) match { case _: List[C] => case _ => } // nowarn
+  class B2[A, B]
+  class A2[X] extends B2[X, String]
+  def okay2(x: A2[Int]) = x match { case _: B2[Int, _] => true } // nowarn
+  def okay3(x: A2[Int]) = x match { case _: B2[Int, typeVar] => true } // nowarn
+
+  def warnArray[T] = (null: Any) match { case _: Array[T] => } // warn (did not warn due to SI-8597)
+  def nowarnArrayC   = (null: Any) match { case _: Array[C] => } // nowarn
+
+  def nowarnArrayTypeVar[T] = (null: Any) match { case _: Array[t] => } // nowarn
+
+  def noWarnArrayErasure1 = (null: Any) match {case Some(_: Array[String]) => } // nowarn
+  def noWarnArrayErasure2 = (null: Any) match {case Some(_: Array[List[_]]) => } // nowarn
+  def noWarnArrayErasure3 = (null: Any) match {case Some(_: Array[Array[List[_]]]) => } // nowarn
+  def warnArrayErasure2   = (null: Any) match {case Some(_: Array[Array[List[String]]]) => } // warn
+}
diff --git a/test/files/neg/t8597b.check b/test/files/neg/t8597b.check
new file mode 100644
index 0000000000..3c45a31337
--- /dev/null
+++ b/test/files/neg/t8597b.check
@@ -0,0 +1,6 @@
+t8597b.scala:18: warning: non-variable type argument T in type pattern Some[T] is unchecked since it is eliminated by erasure
+        case _: Some[T] => // warn
+                ^
+error: No warnings can be incurred under -Xfatal-warnings.
+one warning found
+one error found
diff --git a/test/files/neg/t8597b.flags b/test/files/neg/t8597b.flags
new file mode 100644
index 0000000000..85d8eb2ba2
--- /dev/null
+++ b/test/files/neg/t8597b.flags
@@ -0,0 +1 @@
+-Xfatal-warnings
diff --git a/test/files/neg/t8597b.scala b/test/files/neg/t8597b.scala
new file mode 100644
index 0000000000..b29d591cb1
--- /dev/null
+++ b/test/files/neg/t8597b.scala
@@ -0,0 +1,21 @@
+object Unchecked {
+  (null: Any) match {
+    case _: Some[t] =>
+
+      // t is a fresh pattern type variable, despite our attempts to
+      // backtick our way to the enclosing `t`. Under this interpretation,
+      // the absense of an unchecked warning is expected.
+      (null: Any) match {
+        case _: Some[t] => // no warn
+      }
+      (null: Any) match {
+        case _: Some[`t`] => // no warn
+      }
+
+      // here we correctly issue an unchecked warning
+      type T = t
+      (null: Any) match {
+        case _: Some[T] => // warn
+      }
+  }
+}
diff --git a/test/files/neg/t8731.check b/test/files/neg/t8731.check
new file mode 100644
index 0000000000..2a9af475fc
--- /dev/null
+++ b/test/files/neg/t8731.check
@@ -0,0 +1,9 @@
+t8731.scala:5: warning: matches with two cases or fewer are emitted using if-then-else instead of switch
+  def f(x: Int) = (x: @annotation.switch) match {
+                       ^
+t8731.scala:10: warning: could not emit switch for @switch annotated match
+  def g(x: Int) = (x: @annotation.switch) match {
+                       ^
+error: No warnings can be incurred under -Xfatal-warnings.
+two warnings found
+one error found
diff --git a/test/files/neg/t8731.flags b/test/files/neg/t8731.flags
new file mode 100644
index 0000000000..e8fb65d50c
--- /dev/null
+++ b/test/files/neg/t8731.flags
@@ -0,0 +1 @@
+-Xfatal-warnings
\ No newline at end of file
diff --git a/test/files/neg/t8731.scala b/test/files/neg/t8731.scala
new file mode 100644
index 0000000000..d93fe706ad
--- /dev/null
+++ b/test/files/neg/t8731.scala
@@ -0,0 +1,15 @@
+class C {
+  // not a compile-time constant due to return type
+  final val K: Int = 20
+
+  def f(x: Int) = (x: @annotation.switch) match {
+    case K => 0
+    case 2 => 1
+  }
+
+  def g(x: Int) = (x: @annotation.switch) match {
+    case K => 0
+    case 2 => 1
+    case 3 => 2
+  }
+}
diff --git a/test/files/neg/t8869.check b/test/files/neg/t8869.check
new file mode 100644
index 0000000000..40b8570f9f
--- /dev/null
+++ b/test/files/neg/t8869.check
@@ -0,0 +1,7 @@
+t8869.scala:5: error: class Option takes type parameters
+  def value: TC[({type l1[x] = Option})#l1] = ??? // error not reported!
+                               ^
+t8869.scala:7: error: class Option takes type parameters
+  type l2[x] = Option // error correctly reported
+               ^
+two errors found
diff --git a/test/files/neg/t8869.scala b/test/files/neg/t8869.scala
new file mode 100644
index 0000000000..0c7f0c9451
--- /dev/null
+++ b/test/files/neg/t8869.scala
@@ -0,0 +1,10 @@
+class TC[T[_]] {
+  def identity[A](a: T[A]): T[A] = a
+}
+object Test {
+  def value: TC[({type l1[x] = Option})#l1] = ??? // error not reported!
+
+  type l2[x] = Option // error correctly reported
+  def value1: TC[l2] = ???
+}
+
diff --git a/test/files/neg/t8890.check b/test/files/neg/t8890.check
new file mode 100644
index 0000000000..1b69d6cf30
--- /dev/null
+++ b/test/files/neg/t8890.check
@@ -0,0 +1,4 @@
+t8890.scala:6: error: not found: type Str
+  def bar(x: Str): Unit = ???
+             ^
+one error found
diff --git a/test/files/neg/t8890.scala b/test/files/neg/t8890.scala
new file mode 100644
index 0000000000..cbdeb11d43
--- /dev/null
+++ b/test/files/neg/t8890.scala
@@ -0,0 +1,11 @@
+package foo
+
+class A {
+  /** The other */
+  def bar(x: Int): Unit = ???
+  def bar(x: Str): Unit = ???
+}
+
+class B {
+  (new A).bar(0)
+}
\ No newline at end of file
diff --git a/test/files/neg/t9008.check b/test/files/neg/t9008.check
new file mode 100644
index 0000000000..c32bc41baf
--- /dev/null
+++ b/test/files/neg/t9008.check
@@ -0,0 +1,4 @@
+t9008.scala:2: error: type M takes type parameters
+  def x: List[M forSome { type M[_] }] = ???
+              ^
+one error found
diff --git a/test/files/neg/t9008.scala b/test/files/neg/t9008.scala
new file mode 100644
index 0000000000..c6a5389e42
--- /dev/null
+++ b/test/files/neg/t9008.scala
@@ -0,0 +1,3 @@
+object Test {
+  def x: List[M forSome { type M[_] }] = ???
+}
diff --git a/test/files/neg/t9008b.check b/test/files/neg/t9008b.check
new file mode 100644
index 0000000000..5e911fc138
--- /dev/null
+++ b/test/files/neg/t9008b.check
@@ -0,0 +1,4 @@
+t9008b.scala:2: error: type M takes type parameters
+  type T = M forSome { type M[_] }
+           ^
+one error found
diff --git a/test/files/neg/t9008b.scala b/test/files/neg/t9008b.scala
new file mode 100644
index 0000000000..58f9d0e8de
--- /dev/null
+++ b/test/files/neg/t9008b.scala
@@ -0,0 +1,3 @@
+object Test {
+  type T = M forSome { type M[_] }
+}
diff --git a/test/files/neg/t963.check b/test/files/neg/t963.check
index 4dc202c7bd..483e53c77d 100644
--- a/test/files/neg/t963.check
+++ b/test/files/neg/t963.check
@@ -1,9 +1,9 @@
-t963.scala:14: error: stable identifier required, but Test.this.y3.x found.
+t963.scala:14: error: stable identifier required, but y3.x.type found.
   val w3 : y3.x.type = y3.x
-              ^
-t963.scala:17: error: stable identifier required, but Test.this.y4.x found.
+               ^
+t963.scala:17: error: stable identifier required, but y4.x.type found.
   val w4 : y4.x.type = y4.x
-              ^
+               ^
 t963.scala:10: error: type mismatch;
  found   : AnyRef{def x: Integer}
  required: AnyRef{val x: Integer}
diff --git a/test/files/neg/unchecked-abstract.check b/test/files/neg/unchecked-abstract.check
index 72019082ac..703929dca8 100644
--- a/test/files/neg/unchecked-abstract.check
+++ b/test/files/neg/unchecked-abstract.check
@@ -4,6 +4,9 @@ unchecked-abstract.scala:16: warning: abstract type H in type Contravariant[M.th
 unchecked-abstract.scala:21: warning: abstract type H in type Contravariant[M.this.H] is unchecked since it is eliminated by erasure
     /*   warn */ println(x.isInstanceOf[Contravariant[H]])
                                        ^
+unchecked-abstract.scala:22: warning: abstract type T in type Contravariant[M.this.T] is unchecked since it is eliminated by erasure
+    /*   warn */ println(x.isInstanceOf[Contravariant[T]])
+                                       ^
 unchecked-abstract.scala:27: warning: abstract type T in type Invariant[M.this.T] is unchecked since it is eliminated by erasure
     /*   warn */ println(x.isInstanceOf[Invariant[T]])
                                        ^
@@ -22,6 +25,15 @@ unchecked-abstract.scala:36: warning: abstract type H in type Invariant[M.this.H
 unchecked-abstract.scala:37: warning: abstract type T in type Invariant[M.this.T] is unchecked since it is eliminated by erasure
     /*   warn */ println(x.isInstanceOf[Invariant[T]])
                                        ^
+unchecked-abstract.scala:42: warning: abstract type T in type Covariant[M.this.T] is unchecked since it is eliminated by erasure
+    /*   warn */ println(x.isInstanceOf[Covariant[T]])
+                                       ^
+unchecked-abstract.scala:43: warning: abstract type L in type Covariant[M.this.L] is unchecked since it is eliminated by erasure
+    /*   warn */ println(x.isInstanceOf[Covariant[L]])
+                                       ^
+unchecked-abstract.scala:48: warning: abstract type L in type Covariant[M.this.L] is unchecked since it is eliminated by erasure
+    /*   warn */ println(x.isInstanceOf[Covariant[L]])
+                                       ^
 error: No warnings can be incurred under -Xfatal-warnings.
-8 warnings found
+12 warnings found
 one error found
diff --git a/test/files/pos/patmat-suppress.flags b/test/files/pos/patmat-suppress.flags
new file mode 100644
index 0000000000..a988a5b807
--- /dev/null
+++ b/test/files/pos/patmat-suppress.flags
@@ -0,0 +1 @@
+-Xfatal-warnings -Xno-patmat-analysis
\ No newline at end of file
diff --git a/test/files/pos/patmat-suppress.scala b/test/files/pos/patmat-suppress.scala
new file mode 100644
index 0000000000..7c8aded690
--- /dev/null
+++ b/test/files/pos/patmat-suppress.scala
@@ -0,0 +1,159 @@
+// test that none of these warn due to -Xno-patmat-analysis
+// tests taken from test/files/neg/patmatexhaust.scala, test/files/neg/pat_unreachable.scala
+class TestSealedExhaustive { // compile only
+    sealed abstract class Foo
+
+    case class Bar(x:Int) extends Foo
+    case object Baz extends Foo
+
+    def ma1(x:Foo) = x match {
+      case Bar(_) => // not exhaustive
+    }
+
+    def ma2(x:Foo) = x match {
+      case Baz    => // not exhaustive
+    }
+
+    sealed abstract class Mult
+    case class Kult(s:Mult) extends Mult
+    case class Qult() extends Mult
+
+    def ma33(x:Kult) = x match { // exhaustive
+      case Kult(_) => // exhaustive
+    }
+
+    def ma3(x:Mult) = (x,x) match { // not exhaustive
+      case (Kult(_), Qult())    => // Kult missing
+      //case (Kult(_), Kult(_))    =>
+      case (Qult(), Kult(_))    => // Qult missing
+      //case (Qult(), Qult())    =>
+    }
+
+    def ma3u(x:Mult) = ((x,x) : @unchecked) match { // not exhaustive, but not checked!
+      case (Kult(_), Qult())    =>
+      case (Qult(), Kult(_))    =>
+    }
+
+    sealed abstract class Deep
+
+    case object Ga extends Deep
+    sealed class Gp extends Deep
+    case object Gu extends Gp
+
+    def zma3(x:Deep) = x match { // exhaustive!
+      case _ =>
+    }
+    def zma4(x:Deep) = x match { // exhaustive!
+      case Ga =>
+      case _ =>
+    }
+
+    def ma4(x:Deep) = x match { // missing cases: Gu, Gp which is not abstract so must be included
+      case Ga =>
+    }
+
+    def ma5(x:Deep) = x match {
+      case Gu =>
+      case _ if 1 == 0 =>
+      case Ga =>
+    }
+
+  def ma6()  = List(1,2) match { // give up
+    case List(1,2) =>
+    case x :: xs =>
+  }
+
+  def ma7() = List(1,2) match { //exhaustive
+    case 1::2::Nil =>
+      case _ =>
+  }
+
+  sealed class B
+  case class B1() extends B
+  case object B2 extends B
+  def ma8(x: B) = x match {
+    case _: B => true
+  }
+  def ma9(x: B) = x match {
+    case B1() => true       // missing B, which is not abstract so must be included
+    case B2   => true
+  }
+
+  object ob1 {
+    sealed abstract class C
+    sealed abstract class C1 extends C
+    object C2 extends C
+    case class C3() extends C
+    case object C4 extends C
+
+    def ma10(x: C) = x match {  // exhaustive: abstract sealed C1 is dead end.
+      case C3()     => true
+      case C2 | C4  => true
+    }
+  }
+
+  object ob2 {
+    sealed abstract class C
+    abstract class C1 extends C
+    object C2 extends C
+    case class C3() extends C
+    case object C4 extends C
+
+    def ma10(x: C) = x match { // not exhaustive: C1 is not sealed.
+      case C3()     => true
+      case C2 | C4  => true
+    }
+  }
+  object ob3 {
+    sealed abstract class C
+    sealed abstract class C1 extends C
+    object D1 extends C1
+    case class D2() extends C1
+    object C2 extends C
+    case class C3() extends C
+    case object C4 extends C
+
+    def ma10(x: C) = x match {  // not exhaustive: C1 has subclasses.
+      case C3()     => true
+      case C2 | C4  => true
+    }
+  }
+  object ob4 {
+    sealed abstract class C
+    sealed class C1 extends C
+    object C2 extends C
+    case class C3() extends C
+    case object C4 extends C
+
+    def ma10(x: C) = x match { // not exhaustive: C1 is not abstract.
+      case C3()     => true
+      case C2 | C4  => true
+    }
+  }
+}
+
+object TestUnreachable extends App {
+  def unreachable1(xs:Seq[Char]) = xs match {
+    case Seq(x, y, _*) => x::y::Nil
+    case Seq(x, y, z, w) => List(z,w) // redundant!
+  }
+  def unreachable2(xs:Seq[Char]) = xs match {
+    case Seq(x, y, _*) => x::y::Nil
+    case Seq(x, y) => List(x, y)
+  }
+
+  def not_unreachable(xs:Seq[Char]) = xs match {
+    case Seq(x, y, _*) => x::y::Nil
+    case Seq(x) => List(x)
+  }
+  def not_unreachable2(xs:Seq[Char]) = xs match {
+    case Seq(x, y) => x::y::Nil
+    case Seq(x, y, z, _*) => List(x,y)
+  }
+
+  def contrivedExample[A, B, C](a: A, b: B, c: C): Unit = a match {
+    case b => println("matched b")
+    case c => println("matched c")
+    case _ => println("matched neither")
+  }
+}
diff --git a/test/files/pos/sammy_exist.flags b/test/files/pos/sammy_exist.flags
new file mode 100644
index 0000000000..48fd867160
--- /dev/null
+++ b/test/files/pos/sammy_exist.flags
@@ -0,0 +1 @@
+-Xexperimental
diff --git a/test/files/pos/sammy_exist.scala b/test/files/pos/sammy_exist.scala
new file mode 100644
index 0000000000..f05ae20463
--- /dev/null
+++ b/test/files/pos/sammy_exist.scala
@@ -0,0 +1,17 @@
+// scala> typeOf[java.util.stream.Stream[_]].nonPrivateMember(TermName("map")).info
+// [R](x$1: java.util.function.Function[_ >: T, _ <: R])java.util.stream.Stream[R]
+
+// java.util.function.Function
+trait Fun[A, B] { def apply(x: A): B }
+
+// java.util.stream.Stream
+class S[T](x: T) { def map[R](f: Fun[_ >: T, _ <: R]): R = f(x) }
+
+class Bla { def foo: Bla = this }
+
+// NOTE: inferred types show unmoored skolems, should pack them to display properly as bounded wildcards
+object T {
+  val aBlaSAM = (new S(new Bla)).map(_.foo)
+  val fun: Fun[Bla, Bla] = (x: Bla) => x
+  val aBlaSAMX = (new S(new Bla)).map(fun)
+}
diff --git a/test/files/pos/sammy_overload.flags b/test/files/pos/sammy_overload.flags
new file mode 100644
index 0000000000..48fd867160
--- /dev/null
+++ b/test/files/pos/sammy_overload.flags
@@ -0,0 +1 @@
+-Xexperimental
diff --git a/test/files/pos/sammy_overload.scala b/test/files/pos/sammy_overload.scala
new file mode 100644
index 0000000000..5472248f4d
--- /dev/null
+++ b/test/files/pos/sammy_overload.scala
@@ -0,0 +1,9 @@
+trait Consumer[T] {
+  def consume(x: T): Unit
+}
+
+object Test {
+  def foo(x: String): Unit = ???
+  def foo(): Unit = ???
+  val f: Consumer[_ >: String] = foo
+}
\ No newline at end of file
diff --git a/test/files/pos/sammy_override.flags b/test/files/pos/sammy_override.flags
new file mode 100644
index 0000000000..48fd867160
--- /dev/null
+++ b/test/files/pos/sammy_override.flags
@@ -0,0 +1 @@
+-Xexperimental
diff --git a/test/files/pos/sammy_override.scala b/test/files/pos/sammy_override.scala
new file mode 100644
index 0000000000..a1d0651c39
--- /dev/null
+++ b/test/files/pos/sammy_override.scala
@@ -0,0 +1,8 @@
+trait IntConsumer {
+  def consume(x: Int): Unit
+}
+
+object Test {
+  def anyConsumer(x: Any): Unit = ???
+  val f: IntConsumer = anyConsumer
+}
\ No newline at end of file
diff --git a/test/files/pos/switch-small.scala b/test/files/pos/switch-small.scala
deleted file mode 100644
index 9de9ca028e..0000000000
--- a/test/files/pos/switch-small.scala
+++ /dev/null
@@ -1,8 +0,0 @@
-import annotation._
-
-object Test {
-  def f(x: Int) = (x: @switch) match {
-    case 1 => 1
-    case _ => 2
-  }
-}
diff --git a/test/files/neg/t3240.scala b/test/files/pos/t3240.scala
index cf197a406d..cf197a406d 100644
--- a/test/files/neg/t3240.scala
+++ b/test/files/pos/t3240.scala
diff --git a/test/files/pos/t3439.scala b/test/files/pos/t3439.scala
new file mode 100644
index 0000000000..ccc75cc4cf
--- /dev/null
+++ b/test/files/pos/t3439.scala
@@ -0,0 +1,26 @@
+class Base[M](i: Int)
+ 
+// was "implicit modifier not allowed on top level objects"
+class D1()(implicit i: Int) extends Base({println(i); 0})
+
+// what "no implicit value of type Int found"
+class D2()(implicit i: Int) extends Base(implicitly[Int])
+
+
+abstract class ParametricMessage[M: Manifest](msg: M) { def message = msg }
+case class ParametricMessage1[M: Manifest](msg: M, p1: Class[_]) extends ParametricMessage(msg)
+
+
+class Wrap {
+  class Base[M](i: Int)
+   
+  // was "implicit modifier not allowed on top level objects"
+  class D1()(implicit i: Int) extends Base({println(i); 0})
+
+  // what "no implicit value of type Int found"
+  class D2()(implicit i: Int) extends Base(implicitly[Int])
+
+
+  abstract class ParametricMessage[M: Manifest](msg: M) { def message = msg }
+  case class ParametricMessage1[M: Manifest](msg: M, p1: Class[_]) extends ParametricMessage(msg)
+}
diff --git a/test/files/pos/t4070.scala b/test/files/pos/t4070.scala
index a9777f02ed..11af67a529 100644
--- a/test/files/pos/t4070.scala
+++ b/test/files/pos/t4070.scala
@@ -20,7 +20,7 @@ package b {
 
 
 /*
-// With crash below the clasess:
+// With crash below the classes:
 % scalac -Dscalac.debug.tvar ./a.scala
 [    create] ?_$1                     ( In Foo#crash )
 [   setInst] tv[Int]                  ( In Foo#crash, _$1=tv[Int] )
diff --git a/test/files/pos/t5154.scala b/test/files/pos/t5154.scala
new file mode 100644
index 0000000000..2629308f00
--- /dev/null
+++ b/test/files/pos/t5154.scala
@@ -0,0 +1,9 @@
+
+trait Z {
+  // extra space made the pattern OK
+  def f = <z> {{3}}</z> match { case <z> {{3}}</z> => }
+
+  // lack of space: error: illegal start of simple pattern
+  def g = <z>{{3}}</z> match { case <z>{{3}}</z> => }
+}
+
diff --git a/test/files/pos/t5217.scala b/test/files/pos/t5217.scala
new file mode 100644
index 0000000000..1fe3f5696f
--- /dev/null
+++ b/test/files/pos/t5217.scala
@@ -0,0 +1,17 @@
+// private types and terms of companion module are
+// available in scope of ctor params.
+// before 2.10.1, class B in object A cannot be accessed in object A
+object A {
+  private class B
+  private val b: B = new B
+  private type C = Int
+  def apply(): A = new A()
+}
+// if not private, then default arg results in:
+// private class B escapes its defining scope as part of type A.B
+class A private (b: A.B = A.b, c: A.C = 42)
+
+object C {
+  private class B
+}
+class C(b: C.B)
diff --git a/test/files/pos/t5413.scala b/test/files/pos/t5413.scala
new file mode 100644
index 0000000000..47af514a14
--- /dev/null
+++ b/test/files/pos/t5413.scala
@@ -0,0 +1,9 @@
+object Fail {
+  def nom (guard : => Boolean) (something : => Unit) { }
+  def main(args: Array[String]) {
+    nom {
+      val i = 0
+      (i != 3)
+    }()
+  }
+}
diff --git a/test/files/pos/t5454.scala b/test/files/pos/t5454.scala
new file mode 100644
index 0000000000..4045f3b57b
--- /dev/null
+++ b/test/files/pos/t5454.scala
@@ -0,0 +1,10 @@
+object IllegalInheritance {
+  trait A
+  implicit def a = new A {}            // def => val
+  //val r = implicitly[A]              // uncomment
+ 
+  class B[T](t : T)(implicit a : A)    // remove implicit param block
+ 
+  class C extends B/*[Int]*/(23)       // uncomment
+  val c = new C                        // comment
+}
diff --git a/test/files/pos/t5639.flags b/test/files/pos/t5639.flags
new file mode 100644
index 0000000000..0acce1e7ce
--- /dev/null
+++ b/test/files/pos/t5639.flags
@@ -0,0 +1 @@
+-Xsource:2.12
diff --git a/test/files/pos/t5639/A_1.scala b/test/files/pos/t5639/A_1.scala
new file mode 100644
index 0000000000..c5da10eae4
--- /dev/null
+++ b/test/files/pos/t5639/A_1.scala
@@ -0,0 +1,17 @@
+import Implicits._
+
+class Baz
+
+object Test {
+  implicitly[Int]
+}
+
+object Implicits  {
+  implicit val Baz: Int = 0
+  // This implicit was being ignored by `isQualifyingImplicit`
+  // if the classpath contained a class file for `class Baz`.
+  // This is because the package scope contains a speculative
+  // symbol for `object Baz` which is entered by `SymbolLoaders`
+  // before looking inside the class file. (A Java originated
+  // classfile results in the class/module symbol pair.)
+}
diff --git a/test/files/pos/t5639/A_2.scala b/test/files/pos/t5639/A_2.scala
new file mode 100644
index 0000000000..2bb36273e0
--- /dev/null
+++ b/test/files/pos/t5639/A_2.scala
@@ -0,0 +1,11 @@
+import Implicits._
+
+class Baz
+
+object Test {
+  implicitly[Int]
+}
+
+object Implicits  {
+  implicit val Baz: Int = 0
+}
diff --git a/test/files/pos/t5639/Bar.scala b/test/files/pos/t5639/Bar.scala
deleted file mode 100644
index f577500acd..0000000000
--- a/test/files/pos/t5639/Bar.scala
+++ /dev/null
@@ -1,7 +0,0 @@
-package pack.age
-
-import pack.age.Implicits._
-
-object Quux {
-  def baz : Baz   = 1
-}
diff --git a/test/files/pos/t5639/Foo.scala b/test/files/pos/t5639/Foo.scala
deleted file mode 100644
index 1a07734a8e..0000000000
--- a/test/files/pos/t5639/Foo.scala
+++ /dev/null
@@ -1,7 +0,0 @@
-package pack.age
-
-class Baz
-
-object Implicits  {
-  implicit def Baz(n: Int): Baz = new Baz
-}
diff --git a/test/files/pos/t6051.scala b/test/files/pos/t6051.scala
new file mode 100644
index 0000000000..854524feb9
--- /dev/null
+++ b/test/files/pos/t6051.scala
@@ -0,0 +1,19 @@
+object Foo1 {
+  def foo(x: Int, y: Int = 10) = x*y
+  lazy val y = foo(x = 20)
+}
+
+object Foo2 {
+  def foo(x: Int, y: Int = 10) = x*y
+  val y = foo(x = 20)
+}
+
+object Foo3 {
+  def foo(x: Int, y: Int = 10) = x*y
+  def y = foo(x = 20)
+}
+
+object Foo4 {
+  def foo(x: Int, y: Int = 10) = x*y
+  var y = foo(x = 20)
+}
diff --git a/test/files/pos/t6582_exhaust_big.scala b/test/files/pos/t6582_exhaust_big.scala
new file mode 100644
index 0000000000..7bb8879805
--- /dev/null
+++ b/test/files/pos/t6582_exhaust_big.scala
@@ -0,0 +1,33 @@
+sealed abstract class Z
+object Z {
+   object     Z0    extends Z
+   case class Z1()  extends Z
+   object     Z2    extends Z
+   case class Z3()  extends Z
+   object     Z4    extends Z
+   case class Z5()  extends Z
+   object     Z6    extends Z
+   case class Z7()  extends Z
+   object     Z8    extends Z
+   case class Z9()  extends Z
+   object     Z10   extends Z
+   case class Z11() extends Z
+   object     Z12   extends Z
+   case class Z13() extends Z
+   object     Z14   extends Z
+   case class Z15() extends Z
+   object     Z16   extends Z
+   case class Z17() extends Z
+   object     Z18   extends Z
+   case class Z19() extends Z
+}
+
+// drop any case and it will report an error
+object Test {
+  import Z._
+  def foo(z: Z) = z match {
+    case Z0  | Z1()  | Z2  | Z3()  | Z4  | Z5()  | Z6  | Z7()  | Z8  | Z9() |
+         Z10 | Z11() | Z12 | Z13() | Z14 | Z15() | Z16 | Z17() | Z18 | Z19()
+         =>
+  }
+}
diff --git a/test/files/pos/t7459a.scala b/test/files/pos/t7459a.scala
new file mode 100644
index 0000000000..5107715e06
--- /dev/null
+++ b/test/files/pos/t7459a.scala
@@ -0,0 +1,18 @@
+trait SpecialException extends Throwable
+
+object Test {
+  def run() {
+    try {
+      ???
+    } catch {
+      case e: SpecialException => e.isInstanceOf[SpecialException]
+      case e =>
+    }
+
+    // OKAY
+    // (null: Throwable) match {
+    //   case e: SpecialException => e.isInstanceOf[SpecialException]
+    //   case e =>
+    // }
+  }
+}
\ No newline at end of file
diff --git a/test/files/pos/t7459b.scala b/test/files/pos/t7459b.scala
new file mode 100644
index 0000000000..a4b4fd07a9
--- /dev/null
+++ b/test/files/pos/t7459b.scala
@@ -0,0 +1,12 @@
+import scala.concurrent._
+import scala.util._
+
+
+class Test {
+  (null: Any) match {
+    case s @ Some(_) => ???
+    case f @ _ => 
+      () => f
+      ???
+  }
+}
\ No newline at end of file
diff --git a/test/files/pos/t7459c.scala b/test/files/pos/t7459c.scala
new file mode 100644
index 0000000000..dc2605abe6
--- /dev/null
+++ b/test/files/pos/t7459c.scala
@@ -0,0 +1,18 @@
+object Test {
+  trait Universe {
+    type Type
+    type TypeTag[A] >: Null <: TypeTagApi[A]
+    trait TypeTagApi[A] { def tpe: Type }
+  }
+  trait JavaUniverse extends Universe
+
+  trait Mirror[U <: Universe] {
+    def universe: U
+  }
+  (null: Mirror[_]).universe match {
+    case ju: JavaUniverse => 
+      val ju1 = ju
+      val f = {() => (null: ju.TypeTag[Nothing]).tpe }
+  }
+  trait M[A]
+}
diff --git a/test/files/pos/t7459d.scala b/test/files/pos/t7459d.scala
new file mode 100644
index 0000000000..7843156885
--- /dev/null
+++ b/test/files/pos/t7459d.scala
@@ -0,0 +1,8 @@
+class Test {
+  (null: Any) match {
+    case s @ Some(_) => ???
+    case f @ _ => 
+      () => f
+      ???
+  }
+}
diff --git a/test/files/pos/t7596/A_1.scala b/test/files/pos/t7596/A_1.scala
new file mode 100644
index 0000000000..6303c6d132
--- /dev/null
+++ b/test/files/pos/t7596/A_1.scala
@@ -0,0 +1,10 @@
+trait Driver {
+  abstract class Table
+}
+
+object Config {
+  val driver : Driver = ???
+  def driver(a: Any) = ???
+}
+
+object Sites extends Config.driver.Table
diff --git a/test/files/pos/t7596/B_2.scala b/test/files/pos/t7596/B_2.scala
new file mode 100644
index 0000000000..977e5c8bd1
--- /dev/null
+++ b/test/files/pos/t7596/B_2.scala
@@ -0,0 +1,19 @@
+object Test {
+  locally {
+    Sites: Config.driver.Table
+  }
+}
+
+// Under separate compilation, the pickler is foiled by the 
+// overloaded term `Config.driver`, and results in:
+
+// qbin/scalac test/files/pos/t7596/A_1.scala && qbin/scalac -explaintypes test/files/pos/t7596/B_2.scala
+// test/files/pos/t7596/B_2.scala:3: error: type mismatch;
+//  found   : Sites.type
+//  required: Config.driver.Table
+//     Sites: Config.driver.Table
+//     ^
+// Sites.type <: Config.driver.Table?
+//   Driver.this.type = Config.driver.type?
+//   false
+// false
\ No newline at end of file
diff --git a/test/files/pos/t7596b/A.scala b/test/files/pos/t7596b/A.scala
new file mode 100644
index 0000000000..65c1bc56ef
--- /dev/null
+++ b/test/files/pos/t7596b/A.scala
@@ -0,0 +1,10 @@
+trait H2Driver{
+    abstract class Table[T]
+}
+
+object Config {
+  val driver : H2Driver = ???
+  def driver(app: Any): H2Driver = ???
+}
+
+class Sites extends Config.driver.Table[String]
diff --git a/test/files/pos/t7596b/B.scala b/test/files/pos/t7596b/B.scala
new file mode 100644
index 0000000000..cbcf149c23
--- /dev/null
+++ b/test/files/pos/t7596b/B.scala
@@ -0,0 +1,6 @@
+class DAOBase[E]{
+  type TableType <: Config.driver.Table[E]
+}
+class SitesDAO extends DAOBase[String]{
+  type TableType = Sites
+}
diff --git a/test/files/pos/t7596c/A_1.scala b/test/files/pos/t7596c/A_1.scala
new file mode 100644
index 0000000000..3e366df477
--- /dev/null
+++ b/test/files/pos/t7596c/A_1.scala
@@ -0,0 +1,11 @@
+trait Driver {
+  abstract class Table
+}
+
+object Config {
+  val driver : Driver = ???
+  val driverUniqueName: driver.type = driver
+  def driver(a: Any) = ???
+}
+
+object Sites extends Config.driver.Table
diff --git a/test/files/pos/t7596c/B_2.scala b/test/files/pos/t7596c/B_2.scala
new file mode 100644
index 0000000000..33da68c1ff
--- /dev/null
+++ b/test/files/pos/t7596c/B_2.scala
@@ -0,0 +1,9 @@
+object Test {
+  locally {
+    Sites: Config.driver.Table
+  }
+}
+
+// This variation worked by avoiding referring to the
+// overloaded term `Config.driver` in the parent type of
+// Sites
\ No newline at end of file
diff --git a/test/files/pos/t7683-stop-after-parser/ThePlugin.scala b/test/files/pos/t7683-stop-after-parser/ThePlugin.scala
new file mode 100644
index 0000000000..cd800781dc
--- /dev/null
+++ b/test/files/pos/t7683-stop-after-parser/ThePlugin.scala
@@ -0,0 +1,31 @@
+package scala.test.plugins
+
+import scala.tools.nsc
+import nsc.Global
+import nsc.Phase
+import nsc.plugins.Plugin
+import nsc.plugins.PluginComponent
+
+class ThePlugin(val global: Global) extends Plugin {
+  import global._
+
+  val name = "timebomb"
+  val description = "Explodes if run. Maybe I haven't implemented it yet."
+  val components = List[PluginComponent](thePhase1)
+
+  private object thePhase1 extends PluginComponent {
+    val global = ThePlugin.this.global
+
+    val runsAfter = List[String]("parser")
+    override val runsBefore = List[String]("namer")
+    val phaseName = ThePlugin.this.name
+
+    def newPhase(prev: Phase) = new ThePhase(prev)
+  }
+
+  private class ThePhase(prev: Phase) extends Phase(prev) {
+    override def name = ThePlugin.this.name
+    override def run  = ???
+  }
+}
+
diff --git a/test/files/pos/t7683-stop-after-parser/sample_2.flags b/test/files/pos/t7683-stop-after-parser/sample_2.flags
new file mode 100644
index 0000000000..99672cdfd3
--- /dev/null
+++ b/test/files/pos/t7683-stop-after-parser/sample_2.flags
@@ -0,0 +1 @@
+-Xplugin:. -Xplugin-require:timebomb -Ystop-after:parser
diff --git a/test/files/pos/t7683-stop-after-parser/sample_2.scala b/test/files/pos/t7683-stop-after-parser/sample_2.scala
new file mode 100644
index 0000000000..7eb11b8204
--- /dev/null
+++ b/test/files/pos/t7683-stop-after-parser/sample_2.scala
@@ -0,0 +1,6 @@
+
+package sample
+
+// just a sample that is compiled with the explosive plugin disabled
+object Sample extends App {
+}
diff --git a/test/files/pos/t7683-stop-after-parser/scalac-plugin.xml b/test/files/pos/t7683-stop-after-parser/scalac-plugin.xml
new file mode 100644
index 0000000000..2558d6fd03
--- /dev/null
+++ b/test/files/pos/t7683-stop-after-parser/scalac-plugin.xml
@@ -0,0 +1,5 @@
+<plugin>
+  <name>ignored</name>
+  <classname>scala.test.plugins.ThePlugin</classname>
+</plugin>
+
diff --git a/test/files/pos/t7704.scala b/test/files/pos/t7704.scala
new file mode 100644
index 0000000000..cae88d3324
--- /dev/null
+++ b/test/files/pos/t7704.scala
@@ -0,0 +1,10 @@
+class Attr { type V ; class Val }
+class StrAttr extends Attr { type V = String }
+class BoolAttr extends Attr { type V = Boolean }
+ 
+object Main {
+  def f(x: Attr) = x match {
+    case v: StrAttr  => new v.Val
+    case v: BoolAttr => new v.Val
+  }
+}
diff --git a/test/files/pos/t7750.flags b/test/files/pos/t7750.flags
new file mode 100644
index 0000000000..b216e74c97
--- /dev/null
+++ b/test/files/pos/t7750.flags
@@ -0,0 +1 @@
+-Xfatal-warnings -feature
diff --git a/test/files/pos/t7750.scala b/test/files/pos/t7750.scala
new file mode 100644
index 0000000000..befec76949
--- /dev/null
+++ b/test/files/pos/t7750.scala
@@ -0,0 +1,8 @@
+trait LazyCombiner[Elem, +To, Buff <: Growable[Elem] with Sizing]
+trait Growable[T]
+trait Sizing
+
+
+object Test {
+  null.isInstanceOf[LazyCombiner[_, _, _]] // issued an existential feature warning
+}
diff --git a/test/files/pos/t8267.scala b/test/files/pos/t8267.scala
new file mode 100644
index 0000000000..37b498fe3e
--- /dev/null
+++ b/test/files/pos/t8267.scala
@@ -0,0 +1,33 @@
+class Bippy { trait Foo[A] }
+
+final class RichBippy[C <: Bippy with Singleton](val c1: C) {
+  def f: Int = 1
+  def f[A](x: A)(ev: c1.Foo[A]): Int = 2
+
+  def g[A <: Nothing](x: A): Int = 1
+  def g[A](x: A)(ev: c1.Foo[A]): Int = 2
+
+  def h[A](x: A)(ev: c1.Foo[A]): Int = 1
+
+  def i(x: Nothing): Int = 1
+  def i(x: AnyRef)(ev: c1.Foo[x.type]): Int = 2
+}
+
+object p {
+
+  val c  = new Bippy
+  val d0 = new RichBippy[c.type](c)
+  def d1 = new RichBippy[c.type](c)
+ 
+  d0.f[Int](5)(null: c.Foo[Int])  // ok
+  d1.f[Int](5)(null: c.Foo[Int])  // fails
+
+  d0.g[Int](5)(null: c.Foo[Int])  // ok
+  d1.g[Int](5)(null: c.Foo[Int])  // fails
+
+  d0.h[Int](5)(null: c.Foo[Int])  // ok
+  d1.h[Int](5)(null: c.Foo[Int])  // ok
+
+  d0.i("")(null)  // ok
+  d1.i("")(null)  // ok
+}
diff --git a/test/files/pos/t8310.flags b/test/files/pos/t8310.flags
new file mode 100644
index 0000000000..48fd867160
--- /dev/null
+++ b/test/files/pos/t8310.flags
@@ -0,0 +1 @@
+-Xexperimental
diff --git a/test/files/pos/t8310.scala b/test/files/pos/t8310.scala
new file mode 100644
index 0000000000..874caf4d3b
--- /dev/null
+++ b/test/files/pos/t8310.scala
@@ -0,0 +1,22 @@
+trait Comparinator[T] { def compare(a: T, b: T): Int }
+
+object TestOkay {
+  def sort(x: Comparinator[_ >: String]) = ()
+  sort((a: String, b: String) => a.compareToIgnoreCase(b))
+}
+
+object TestOkay2 {
+  def sort[T](x: Comparinator[_ >: T]) = ()
+  sort((a: String, b: String) => a.compareToIgnoreCase(b))
+}
+
+object TestOkay3 {
+  def sort[T](xs: Option[T], x: Comparinator[_ >: T]) = ()
+  sort(Some(""), (a: String, b: String) => a.compareToIgnoreCase(b))
+}
+
+object TestKoOverloaded {
+  def sort[T](xs: Option[T]) = ()
+  def sort[T](xs: Option[T], x: Comparinator[_ >: T]) = ()
+  sort(Some(""), (a: String, b: String) => a.compareToIgnoreCase(b))
+}
diff --git a/test/files/neg/t845.scala b/test/files/pos/t845.scala
index ddf6a16f32..ddf6a16f32 100644
--- a/test/files/neg/t845.scala
+++ b/test/files/pos/t845.scala
diff --git a/test/files/pos/t8828.scala b/test/files/pos/t8828.scala
index 92092b4dd4..182aba54c0 100644
--- a/test/files/pos/t8828.scala
+++ b/test/files/pos/t8828.scala
@@ -11,7 +11,7 @@ package inner {
   }
 
   // the trait is sealed and doWork is not 
-  // and cannot be overriden: no warning
+  // and cannot be overridden: no warning
   private[outer] sealed trait C {
     def doWork(a: A): A = a
   }
diff --git a/test/files/pos/t8868a/Sub_2.scala b/test/files/pos/t8868a/Sub_2.scala
new file mode 100644
index 0000000000..a19b529c88
--- /dev/null
+++ b/test/files/pos/t8868a/Sub_2.scala
@@ -0,0 +1 @@
+class Sub extends T
diff --git a/test/files/pos/t8868a/T_1.scala b/test/files/pos/t8868a/T_1.scala
new file mode 100644
index 0000000000..9fb97b1413
--- /dev/null
+++ b/test/files/pos/t8868a/T_1.scala
@@ -0,0 +1,6 @@
+class C
+
+trait T {
+  @deprecated(since = "", message = "")
+  class X
+}
diff --git a/test/files/pos/t8868b/Sub_2.scala b/test/files/pos/t8868b/Sub_2.scala
new file mode 100644
index 0000000000..58b44db2b3
--- /dev/null
+++ b/test/files/pos/t8868b/Sub_2.scala
@@ -0,0 +1,2 @@
+class Sub extends T
+
diff --git a/test/files/pos/t8868b/T_1.scala b/test/files/pos/t8868b/T_1.scala
new file mode 100644
index 0000000000..0b71cfdaa3
--- /dev/null
+++ b/test/files/pos/t8868b/T_1.scala
@@ -0,0 +1,4 @@
+@deprecated(since = "2.4.0", message = "")
+trait T {
+  class X
+}
diff --git a/test/files/pos/t8868c/Sub_2.scala b/test/files/pos/t8868c/Sub_2.scala
new file mode 100644
index 0000000000..58b44db2b3
--- /dev/null
+++ b/test/files/pos/t8868c/Sub_2.scala
@@ -0,0 +1,2 @@
+class Sub extends T
+
diff --git a/test/files/pos/t8868c/T_1.scala b/test/files/pos/t8868c/T_1.scala
new file mode 100644
index 0000000000..dc541950d8
--- /dev/null
+++ b/test/files/pos/t8868c/T_1.scala
@@ -0,0 +1,9 @@
+class C(a: Any) extends annotation.StaticAnnotation
+
+@C({val x = 0; x})
+trait T {
+  class X
+
+  @C({val x = 0; x})
+  def foo = 42
+}
diff --git a/test/files/pos/t8893.scala b/test/files/pos/t8893.scala
new file mode 100644
index 0000000000..b87c8bdd3c
--- /dev/null
+++ b/test/files/pos/t8893.scala
@@ -0,0 +1,129 @@
+// Took > 10 minutes to run the tail call phase.
+object Test {
+    def a(): Option[String] = Some("a")
+
+    def main(args: Array[String]) {
+        a() match {
+            case Some(b1) =>
+        a() match {
+            case Some(b2) =>
+        a() match {
+            case Some(b3) =>
+        a() match {
+            case Some(b4) =>
+        a() match {
+            case Some(b5) =>
+        a() match {
+            case Some(b6) =>
+        a() match {
+            case Some(b7) =>
+        a() match {
+            case Some(b8) =>
+        a() match {
+            case Some(b9) =>
+        a() match {
+            case Some(b10) =>
+        a() match {
+            case Some(b11) =>
+        a() match {
+            case Some(b12) =>
+        a() match {
+            case Some(b13) =>
+        a() match {
+            case Some(b14) =>
+        a() match {
+            case Some(b15) =>
+        a() match {
+            case Some(b16) =>
+        a() match {
+            case Some(b17) =>
+        a() match {
+            case Some(b18) =>
+        a() match {
+            case Some(b19) =>
+        a() match {
+            case Some(b20) =>
+        a() match {
+            case Some(b21) =>
+        a() match {
+            case Some(b22) =>
+        a() match {
+            case Some(b23) =>
+        a() match {
+            case Some(b24) =>
+        a() match {
+            case Some(b25) =>
+        a() match {
+            case Some(b26) =>
+        a() match {
+            case Some(b27) =>
+        a() match {
+            case Some(b28) =>
+        a() match {
+            case Some(b29) =>
+        a() match {
+            case Some(b30) =>
+                println("yay")
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+            case None => None
+        }
+    }
+}
+
diff --git a/test/files/pos/t8894.scala b/test/files/pos/t8894.scala
new file mode 100644
index 0000000000..3b26f1ae7e
--- /dev/null
+++ b/test/files/pos/t8894.scala
@@ -0,0 +1,12 @@
+class CC(val i: Int, val s: String)
+object CC extends {
+  type P = (Int, String)
+
+  //def unapply(c: CC): Option[(Int, String)] = Some((c.i, c.s)) // OK
+  def unapply(c: CC): Option[P] = Some((c.i, c.s)) // fails (because of the type alias)
+}
+
+class Test {
+  val cc = new CC(23, "foo")
+  val CC(i, s) = cc
+}
\ No newline at end of file
diff --git a/test/files/pos/t8900.scala b/test/files/pos/t8900.scala
new file mode 100644
index 0000000000..376bd786f2
--- /dev/null
+++ b/test/files/pos/t8900.scala
@@ -0,0 +1,11 @@
+package foo
+package lambdaking
+
+class Test {
+  def byname(b: => Any) = ???
+  def foo: Any = {
+    def bar: Any = {
+      byname(bar)
+    }
+  }
+}
diff --git a/test/files/pos/t8934a/A_1.scala b/test/files/pos/t8934a/A_1.scala
new file mode 100644
index 0000000000..6c1f29d030
--- /dev/null
+++ b/test/files/pos/t8934a/A_1.scala
@@ -0,0 +1,18 @@
+import language.experimental.macros
+import reflect.macros.whitebox.Context
+
+object Unapply {
+  def impl1(c: Context)(a: c.Tree): c.Tree = {
+    import c.universe._
+    q"(new { def unapply[T](a: String): Option[(Int, String)] = ??? }).unapply($a)"
+  }
+  def unapply(a: Any): Any = macro impl1
+}
+
+object UnapplySeq {
+  def impl1(c: Context)(a: c.Tree): c.Tree = {
+    import c.universe._
+    q"(new { def unapplySeq[T](a: String): Option[(Int, Seq[String])] = ??? }).unapplySeq($a)"
+  }
+  def unapplySeq(a: Any): Any = macro impl1
+}
diff --git a/test/files/pos/t8934a/Test_2.flags b/test/files/pos/t8934a/Test_2.flags
new file mode 100644
index 0000000000..618dfe2b75
--- /dev/null
+++ b/test/files/pos/t8934a/Test_2.flags
@@ -0,0 +1 @@
+-Ystop-after:typer -Ymacro-expand:discard -nowarn
diff --git a/test/files/pos/t8934a/Test_2.scala b/test/files/pos/t8934a/Test_2.scala
new file mode 100644
index 0000000000..e1792ed3c5
--- /dev/null
+++ b/test/files/pos/t8934a/Test_2.scala
@@ -0,0 +1,12 @@
+object Test {
+  "" match {
+    case Unapply(a, b) =>
+      a: Int
+      b: String
+    case UnapplySeq(a, b1, b2) =>
+      a: Int
+      b1: String
+      b2: String
+  }
+}
+// These used to fail `too many patterns` under -Ymacro-expand:discard
diff --git a/test/files/pos/t8947/Client_2.scala b/test/files/pos/t8947/Client_2.scala
new file mode 100644
index 0000000000..1a5082a2f9
--- /dev/null
+++ b/test/files/pos/t8947/Client_2.scala
@@ -0,0 +1 @@
+object Test { X.extractor }
\ No newline at end of file
diff --git a/test/files/pos/t8947/Macro_1.scala b/test/files/pos/t8947/Macro_1.scala
new file mode 100644
index 0000000000..4a5de3decb
--- /dev/null
+++ b/test/files/pos/t8947/Macro_1.scala
@@ -0,0 +1,41 @@
+import language.experimental.macros
+import scala.reflect.macros._
+import blackbox.Context
+
+object X {
+
+  def classTagOrNull[T](implicit t: reflect.ClassTag[T] = null) = t
+  // the failed search for ClassTag[T] does not issue a visible
+  // error as we fall back to the default argument. But, the
+  // macro engine things we have expanded the macro `materializeClassTag[D]()`
+  // to `EmptyTree`, and then attaches a backreference from the expansion
+  // to the expandee. This is the `MacroExpansionAttachment` tree attachment.
+  def foo[D] = classTagOrNull[D]
+
+  def extractor: Any = macro X.extractorMacro
+  def extractorMacro(c: Context): c.Expr[Any] = {
+    // Later, in reify, an unrelated use of `EmptyTree` in the AST representing
+    // the argument is now treated as a macro expansion which should be rolled
+    // back in the tree we reify! This ends up generating a call to `implicitly`
+    // which leads to an ambiguous error.
+    //
+    // Any macro call that expands to EmptyTree could have triggered this problem.
+    c.universe.reify(new { def something(data: Any) = ??? })
+  }
+
+  // Workarounds:
+  //
+  // 1. Use quasiquotes rather than `reify`. (But, beware to fully qualify all references, e.g. `_root_.scala.Predef.???`)
+  // 2. Avoid failed ClassTag lookups (e.g. in the original bug report, annotate the type argument to `map`)
+  // 3. In the macro implementation, just before calling the `reify` macro, you could call another macro
+  //
+  //      def prepareReify = macro prepareReifyImpl
+  //      def prepareReifyImpl(c: Context) = {
+  //        val symtab = c.universe.asInstanceOf[reflect.internal.SymbolTable]
+  //        symtab.EmptyTree.setAttachments(symtab.NoPosition)
+  //      }
+  //
+  //   To make this visible to the macro implementaiton, it will need to be compiled in an earlier stage,
+  //   e.g a separate SBT sub-project.
+
+}
diff --git a/test/files/pos/t8954.flags b/test/files/pos/t8954.flags
new file mode 100644
index 0000000000..7de3c0f3ee
--- /dev/null
+++ b/test/files/pos/t8954.flags
@@ -0,0 +1 @@
+-Xfatal-warnings -deprecation
diff --git a/test/files/pos/t8954/t1.scala b/test/files/pos/t8954/t1.scala
new file mode 100644
index 0000000000..3986d9f3b5
--- /dev/null
+++ b/test/files/pos/t8954/t1.scala
@@ -0,0 +1,13 @@
+package scala.foo
+
+// 1. a class about to be made final
+@deprecatedInheritance class A {
+  def foo(): Unit = ???
+}
+
+// 1.1:
+// - no inheritance warning because same file
+// - no "override non-deprecated member" because @deprecatedInheritance
+class B2 extends A {
+  @deprecated("","") override def foo(): Unit = ???
+}
diff --git a/test/files/pos/t8954/t2.scala b/test/files/pos/t8954/t2.scala
new file mode 100644
index 0000000000..4def127832
--- /dev/null
+++ b/test/files/pos/t8954/t2.scala
@@ -0,0 +1,39 @@
+package scala.foo
+
+// 1.2 deprecated children should be fine...
+@deprecated("", "") class B extends A {
+
+  // 1.3 and shouldn't trigger the
+  // "overriding non-deprecated parent" warning
+  override def foo(): Unit = ???
+}
+
+@deprecated("","") class F {
+  // 1.4 a class inside a deprecated class should work too
+  class G extends A
+}
+
+// 2. a method about to be made final
+class C {
+  @deprecatedOverriding def foo(): Unit = ???
+}
+
+// 2.1 overriding with a deprecated def should be fine
+// and also shoudln't trigger the "deprecation is useless"
+// warning
+class D extends C {
+  @deprecated("","") override def foo(): Unit = ???
+}
+
+// 2.2 overriding from a deprecated class should be fine
+@deprecated("","") class E extends C {
+  override def foo(): Unit = ???
+}
+
+// 2.3 overriding from deeper inside a deprecated class
+// should work too
+@deprecated("","") class H {
+  class I extends C {
+    override def foo(): Unit = ???
+  }
+}
diff --git a/test/files/pos/t8962.scala b/test/files/pos/t8962.scala
new file mode 100644
index 0000000000..4331c154ba
--- /dev/null
+++ b/test/files/pos/t8962.scala
@@ -0,0 +1,31 @@
+package test.nestedcov
+
+sealed abstract class Outer[+A]
+case class Let[+A](expr: Outer[Inner[A]]) extends Outer[A]
+
+sealed abstract class Inner[+A]
+
+sealed abstract class Outer2[+A, +B]
+case class Let2[+A](expr: Outer2[Inner2[A], A]) extends Outer2[A, A]
+
+sealed abstract class Inner2[+A]
+
+sealed abstract class Outer3[+A, +B]
+case class Let3[+A](expr: Outer3[A, A]) extends Outer3[A, A]
+
+object NestedCov {
+  def run[A](nc: Outer[A]) = nc match {
+    case Let(expr) =>
+      expr : Outer[Inner[A]]
+  }
+
+  def run2[A](nc: Outer2[A, A]) = nc match {
+    case Let2(expr) =>
+      expr : Outer2[Inner2[A], A]
+  }
+
+  def run3[A](nc: Outer3[A, A]) = nc match {
+    case Let3(expr) =>
+      expr : Outer3[A, A]
+  }
+}
diff --git a/test/files/pos/t8965.flags b/test/files/pos/t8965.flags
new file mode 100644
index 0000000000..85d8eb2ba2
--- /dev/null
+++ b/test/files/pos/t8965.flags
@@ -0,0 +1 @@
+-Xfatal-warnings
diff --git a/test/files/pos/t8965.scala b/test/files/pos/t8965.scala
new file mode 100644
index 0000000000..4f39330f4e
--- /dev/null
+++ b/test/files/pos/t8965.scala
@@ -0,0 +1,7 @@
+class A {
+  def f(x: Any with AnyRef, y: Any with AnyRef) = x eq y
+  // a.scala:2: warning: Any and Any are unrelated: they will most likely never compare equal
+  //   def f(x: Any with AnyRef, y: Any with AnyRef) = x eq y
+  //                                                     ^
+  // one warning found
+}
diff --git a/test/files/pos/t8999.flags b/test/files/pos/t8999.flags
new file mode 100644
index 0000000000..0f96f1f872
--- /dev/null
+++ b/test/files/pos/t8999.flags
@@ -0,0 +1 @@
+-nowarn
\ No newline at end of file
diff --git a/test/files/pos/t8999.scala b/test/files/pos/t8999.scala
new file mode 100644
index 0000000000..99c4b2ad84
--- /dev/null
+++ b/test/files/pos/t8999.scala
@@ -0,0 +1,271 @@
+object Types {
+
+  abstract sealed class Type
+
+  case object AnyType extends Type
+
+  case object NothingType extends Type
+
+  case object UndefType extends Type
+
+  case object BooleanType extends Type
+
+  case object IntType extends Type
+
+  case object LongType extends Type
+
+  case object FloatType extends Type
+
+  case object DoubleType extends Type
+
+  case object StringType extends Type
+
+  case object NullType extends Type
+
+  sealed abstract class ReferenceType extends Type
+
+  final case class ClassType(className: String) extends ReferenceType
+
+  final case class ArrayType(baseClassName: String, dimensions: Int) extends ReferenceType
+
+  final case class RecordType(fields: List[RecordType.Field]) extends Type
+
+  object RecordType {
+    final case class Field(name: String, originalName: Option[String],
+        tpe: Type, mutable: Boolean)
+  }
+
+  case object NoType extends Type
+
+}
+
+
+sealed abstract class ClassKind
+
+object ClassKind {
+
+  case object Class extends ClassKind
+
+  case object ModuleClass extends ClassKind
+
+  case object Interface extends ClassKind
+
+  case object RawJSType extends ClassKind
+
+  case object HijackedClass extends ClassKind
+
+  case object TraitImpl extends ClassKind
+
+}
+
+object Trees {
+
+  import Types._
+
+  abstract sealed class Tree
+
+  case object EmptyTree extends Tree
+
+  sealed trait PropertyName
+  case class Ident(name: String, originalName: Option[String]) extends PropertyName
+  object Ident {
+    def apply(name: String): Ident =
+      new Ident(name, Some(name))
+  }
+
+  case class VarDef(name: Ident, vtpe: Type, mutable: Boolean, rhs: Tree) extends Tree
+
+  case class ParamDef(name: Ident, ptpe: Type, mutable: Boolean) extends Tree
+
+  case class Skip() extends Tree
+
+  class Block private(val stats: List[Tree]) extends Tree
+
+  object Block {
+    def unapply(block: Block): Some[List[Tree]] = Some(block.stats)
+  }
+
+  case class Labeled(label: Ident, tpe: Type, body: Tree) extends Tree
+
+  case class Assign(lhs: Tree, rhs: Tree) extends Tree
+
+  case class Return(expr: Tree, label: Option[Ident] = None) extends Tree
+
+  case class If(cond: Tree, thenp: Tree, elsep: Tree) extends Tree
+
+  case class While(cond: Tree, body: Tree, label: Option[Ident] = None) extends Tree
+
+  case class DoWhile(body: Tree, cond: Tree, label: Option[Ident] = None) extends Tree
+
+  case class Try(block: Tree, errVar: Ident, handler: Tree, finalizer: Tree) extends Tree
+
+  case class Throw(expr: Tree) extends Tree
+
+  case class Continue(label: Option[Ident] = None) extends Tree
+
+  case class Match(selector: Tree, cases: List[(List[Literal], Tree)], default: Tree) extends Tree
+
+  case class Debugger() extends Tree
+
+  case class New(cls: ClassType, ctor: Ident, args: List[Tree]) extends Tree
+
+  case class LoadModule(cls: ClassType) extends Tree
+
+  case class StoreModule(cls: ClassType, value: Tree) extends Tree
+
+  case class Select(qualifier: Tree, item: Ident, mutable: Boolean) extends Tree
+
+  case class Apply(receiver: Tree, method: Ident, args: List[Tree]) extends Tree
+
+  case class StaticApply(receiver: Tree, cls: ClassType, method: Ident, args: List[Tree]) extends Tree
+
+  case class TraitImplApply(impl: ClassType, method: Ident, args: List[Tree]) extends Tree
+
+  case class UnaryOp(op: Int, lhs: Tree) extends Tree
+
+  case class BinaryOp(op: Int, lhs: Tree, rhs: Tree) extends Tree
+
+  case class NewArray(tpe: ArrayType, lengths: List[Tree]) extends Tree
+
+  case class ArrayValue(tpe: ArrayType, elems: List[Tree]) extends Tree
+
+  case class ArrayLength(array: Tree) extends Tree
+
+  case class ArraySelect(array: Tree, index: Tree) extends Tree
+
+  case class RecordValue(tpe: RecordType, elems: List[Tree]) extends Tree
+
+  case class IsInstanceOf(expr: Tree, cls: ReferenceType) extends Tree
+
+  case class AsInstanceOf(expr: Tree, cls: ReferenceType) extends Tree
+
+  case class Unbox(expr: Tree, charCode: Char) extends Tree
+
+  case class GetClass(expr: Tree) extends Tree
+
+  case class CallHelper(helper: String, args: List[Tree]) extends Tree
+
+  case class JSNew(ctor: Tree, args: List[Tree]) extends Tree
+
+  case class JSDotSelect(qualifier: Tree, item: Ident) extends Tree
+
+  case class JSBracketSelect(qualifier: Tree, item: Tree) extends Tree
+
+  case class JSFunctionApply(fun: Tree, args: List[Tree]) extends Tree
+
+  case class JSDotMethodApply(receiver: Tree, method: Ident, args: List[Tree]) extends Tree
+
+  case class JSBracketMethodApply(receiver: Tree, method: Tree, args: List[Tree]) extends Tree
+
+  case class JSDelete(prop: Tree) extends Tree
+
+  case class JSUnaryOp(op: String, lhs: Tree) extends Tree
+
+  case class JSBinaryOp(op: String, lhs: Tree, rhs: Tree) extends Tree
+
+  case class JSArrayConstr(items: List[Tree]) extends Tree
+
+  case class JSObjectConstr(fields: List[(PropertyName, Tree)]) extends Tree
+
+  case class JSEnvInfo() extends Tree
+
+  sealed trait Literal extends Tree
+
+  case class Undefined() extends Literal
+
+  case class UndefinedParam() extends Literal
+
+  case class Null() extends Literal
+
+  case class BooleanLiteral(value: Boolean) extends Literal
+
+  case class IntLiteral(value: Int) extends Literal
+
+  case class LongLiteral(value: Long) extends Literal
+
+  case class FloatLiteral(value: Float) extends Literal
+
+  case class DoubleLiteral(value: Double) extends Literal
+
+  case class StringLiteral(value: String) extends Literal with PropertyName
+
+  case class ClassOf(cls: ReferenceType) extends Literal
+
+  case class VarRef(ident: Ident, mutable: Boolean) extends Tree
+
+  case class This() extends Tree
+
+  case class Closure(captureParams: List[ParamDef], params: List[ParamDef],
+                     body: Tree, captureValues: List[Tree]) extends Tree
+
+  case class ClassDef(name: Ident, kind: ClassKind, parent: Option[Ident], ancestors: List[Ident], defs: List[Tree]) extends Tree
+
+  case class MethodDef(name: PropertyName, args: List[ParamDef], resultType: Type, body: Tree) extends Tree
+
+  case class PropertyDef(name: PropertyName, getterBody: Tree, setterArg: ParamDef, setterBody: Tree) extends Tree
+
+  case class ConstructorExportDef(name: String, args: List[ParamDef], body: Tree) extends Tree
+
+  case class ModuleExportDef(fullName: String) extends Tree
+
+  final class TreeHash(val treeHash: Array[Byte], val posHash: Array[Byte])
+}
+
+object Main {
+  import Trees._
+  import Types._
+
+  private def transform(tree: Tree) = {
+    val ObjectClass = "O"
+    tree match {
+      case VarDef(_, _, _, rhs)                                             =>
+      case tree: Block                                                      =>
+      case Labeled(ident@Ident(label, _), tpe, body)                        =>
+      case Assign(lhs, rhs)                                                 =>
+      case Return(expr, optLabel)                                           =>
+      case If(cond, thenp, elsep)                                           =>
+      case While(cond, body, optLabel)                                      =>
+      case DoWhile(body, cond, None)                                        =>
+      case Try(block, errVar, EmptyTree, finalizer)                         =>
+      case Try(block, errVar@Ident(name, originalName), handler, finalizer) =>
+      case Throw(expr)                                                      =>
+      case Continue(optLabel)                                               =>
+      case Match(selector, cases, default)                                  =>
+      case New(cls, ctor, args)                                             =>
+      case StoreModule(cls, value)                                          =>
+      case tree: Select                                                     =>
+      case tree: Apply                                                      =>
+      case tree: StaticApply                                                =>
+      case tree: TraitImplApply                                             =>
+      case tree@UnaryOp(_, arg)                                             =>
+      case tree@BinaryOp(op, lhs, rhs)                                      =>
+      case NewArray(tpe, lengths)                                           =>
+      case ArrayValue(tpe, elems)                                           =>
+      case ArrayLength(array)                                               =>
+      case ArraySelect(array, index)                                        =>
+      case RecordValue(tpe, elems)                                          =>
+      case IsInstanceOf(expr, ClassType(ObjectClass))                       =>
+      case IsInstanceOf(expr, tpe)                                          =>
+      case AsInstanceOf(expr, ClassType(ObjectClass))                       =>
+      case AsInstanceOf(expr, cls)                                          =>
+      case Unbox(arg, charCode)                                             =>
+      case GetClass(expr)                                                   =>
+      case JSNew(ctor, args)                                                =>
+      case JSDotSelect(qualifier, item)                                     =>
+      case JSBracketSelect(qualifier, item)                                 =>
+      case tree: JSFunctionApply                                            =>
+      case JSDotMethodApply(receiver, method, args)                         =>
+      case JSBracketMethodApply(receiver, method, args)                     =>
+      case JSDelete(JSDotSelect(obj, prop))                                 =>
+      case JSDelete(JSBracketSelect(obj, prop))                             =>
+      case JSUnaryOp(op, lhs)                                               =>
+      case JSBinaryOp(op, lhs, rhs)                                         =>
+      case JSArrayConstr(items)                                             =>
+      case JSObjectConstr(fields)                                           =>
+      case _: VarRef | _: This                                              =>
+      case Closure(captureParams, params, body, captureValues)              =>
+      case _: Skip | _: Debugger | _: LoadModule |
+           _: JSEnvInfo | _: Literal | EmptyTree                            =>
+    }
+  }
+}
\ No newline at end of file
diff --git a/test/files/pos/t9008.scala b/test/files/pos/t9008.scala
new file mode 100644
index 0000000000..d11b8604f2
--- /dev/null
+++ b/test/files/pos/t9008.scala
@@ -0,0 +1,5 @@
+trait Monad[M[_]]
+
+object Test {
+  def x: Monad[M forSome { type M[_] }] = ???
+}
diff --git a/test/files/pos/t9018.scala b/test/files/pos/t9018.scala
new file mode 100644
index 0000000000..7fb4cf21b3
--- /dev/null
+++ b/test/files/pos/t9018.scala
@@ -0,0 +1,16 @@
+object TestObject {
+
+  def m(i: Int): AnyRef = i match {
+    case 0 => new C()
+    case 1 => Some(E.A).getOrElse("")
+  }
+
+  class C extends Ordered[C] {
+    def compare(that: C): Int = ???
+  }
+
+  object E extends Enumeration {
+    type CharacterClass = Value
+    val A = Value
+  }
+}
diff --git a/test/files/presentation/doc.check b/test/files/presentation/doc.check
new file mode 100644
index 0000000000..5a3ff13151
--- /dev/null
+++ b/test/files/presentation/doc.check
@@ -0,0 +1 @@
+reload: Base.scala, Class.scala, Derived.scala
diff --git a/test/files/presentation/doc/doc.scala b/test/files/presentation/doc/doc.scala
new file mode 100755
index 0000000000..f2233f1828
--- /dev/null
+++ b/test/files/presentation/doc/doc.scala
@@ -0,0 +1,147 @@
+import scala.reflect.internal.util.{ BatchSourceFile, SourceFile }
+import scala.tools.nsc.doc
+import scala.tools.nsc.doc.base._
+import scala.tools.nsc.doc.base.comment._
+import scala.tools.nsc.interactive._
+import scala.tools.nsc.interactive.tests._
+
+object Test extends InteractiveTest {
+  val tags = Seq(
+    "@example  `\"abb\".permutations = Iterator(abb, bab, bba)`",
+    "@version 1.0, 09/07/2012",
+    "@since 2.10",
+    "@todo this is unsafe!",
+    "@note Don't inherit!",
+    "@see something else"
+  )
+
+  val names = Seq("Class", "Def", "Val", "Var", "AbstracType", "TypeAlias", "Trait", "InnerClass")
+  val bareText =
+    """abstract class %s {
+    |  def %s = ""
+    |  val %s = ""
+    |  var %s: String = _
+    |  type %s
+    |  type %s = String
+    |  class %s
+    |}
+    |trait %s""".stripMargin.format(names: _*)
+
+  def docComment(nTags: Int) = "/**\n%s*/".format(tags.take(nTags).mkString("\n"))
+
+  def text(name: String, nTags: Int) = {
+    val nameIndex = bareText.indexOf(name)
+    val (pre, post) = bareText.splitAt(nameIndex)
+    val crIndex = pre.lastIndexOf("\n")
+    val (prepre, prepost) = pre.splitAt(crIndex)
+    prepre + docComment(nTags) + prepost + post
+  }
+
+  override lazy val compiler = {
+    prepareSettings(settings)
+    new Global(settings, compilerReporter) with MemberLookupBase with CommentFactoryBase with doc.ScaladocGlobalTrait {
+      outer =>
+
+      val global: this.type = this
+
+      override lazy val analyzer = new {
+        val global: outer.type = outer
+      } with doc.ScaladocAnalyzer with InteractiveAnalyzer {
+        override def newTyper(context: Context): InteractiveTyper with ScaladocTyper =
+          new Typer(context) with InteractiveTyper with ScaladocTyper
+      }
+
+      def chooseLink(links: List[LinkTo]): LinkTo = links.head
+      def internalLink(sym: Symbol, site: Symbol) = None
+      def toString(link: LinkTo) = link.toString
+      def warnNoLink = false
+      def findExternalLink(sym: Symbol, name: String) = None
+
+      override def forScaladoc = true
+
+      def getComment(sym: Symbol, source: SourceFile, fragments: List[(Symbol,SourceFile)]): Option[Comment] = {
+        val docResponse = new Response[(String, String, Position)]
+        askDocComment(sym, source, sym.owner, fragments, docResponse)
+        docResponse.get.left.toOption flatMap {
+          case (expanded, raw, pos) =>
+            if (expanded.isEmpty)
+              None
+            else
+              Some(ask { () => parseAtSymbol(expanded, raw, pos, sym.owner) })
+        }
+      }
+    }
+  }
+
+  override def runDefaultTests() {
+    import compiler._
+    def findSource(name: String) = sourceFiles.find(_.file.name == name).get
+
+    val className = names.head
+    for (name <- names;
+         i <- 1 to tags.length) {
+      val newText = text(name, i)
+      val source = findSource("Class.scala")
+      val batch = new BatchSourceFile(source.file, newText.toCharArray)
+      val reloadResponse = new Response[Unit]
+      compiler.askReload(List(batch), reloadResponse)
+      reloadResponse.get.left.toOption match {
+        case None =>
+          println("Couldn't reload")
+        case Some(_) =>
+          val parseResponse = new Response[Tree]
+          askParsedEntered(batch, true, parseResponse)
+          parseResponse.get.left.toOption match {
+            case None =>
+              println("Couldn't parse")
+            case Some(_) =>
+              val sym = compiler.ask { () =>
+                val toplevel = compiler.rootMirror.EmptyPackage.info.decl(TypeName(name))
+                if (toplevel eq NoSymbol) {
+                  val clazz = compiler.rootMirror.EmptyPackage.info.decl(TypeName(className))
+                  val term = clazz.info.decl(TermName(name))
+                  if (term eq NoSymbol) clazz.info.decl(TypeName(name)) else
+                    if (term.isAccessor) term.accessed else term
+                } else toplevel
+              }
+
+              getComment(sym, batch, (sym,batch)::Nil) match {
+                case None => println(s"Got no doc comment for $name")
+                case Some(comment) =>
+                  import comment._
+                  def cnt(bodies: Iterable[Body]) = bodies.size
+                  val actual = cnt(example) + cnt(version) + cnt(since) + cnt(todo) + cnt(note) + cnt(see)
+                  if (actual != i)
+                    println(s"Got docComment with $actual tags instead of $i, file text:\n$newText")
+              }
+          }
+      }
+    }
+
+    // Check inter-classes documentation one-time retrieved ok.
+    val baseSource = findSource("Base.scala")
+    val derivedSource = findSource("Derived.scala")
+    def existsText(where: Any, text: String): Boolean = where match {
+      case s: String => s contains text
+      case s: Seq[_] => s exists (existsText(_, text))
+      case p: Product => p.productIterator exists (existsText(_, text))
+      case c: Comment => existsText(c.body, text)
+    }
+    val (derived, base) = compiler.ask { () =>
+      val derived = compiler.rootMirror.RootPackage.info.decl(newTermName("p")).info.decl(newTypeName("Derived"))
+      (derived, derived.ancestors(0))
+    }
+    val cmt1 = getComment(derived, derivedSource, (base, baseSource)::(derived, derivedSource)::Nil)
+    if (!existsText(cmt1, "This is Derived comment"))
+      println("Unexpected Derived class comment:"+cmt1)
+
+    val (fooDerived, fooBase) = compiler.ask { () =>
+      val decl = derived.tpe.decl(newTermName("foo"))
+      (decl, decl.allOverriddenSymbols(0))
+    }
+
+    val cmt2 = getComment(fooDerived, derivedSource, (fooBase, baseSource)::(fooDerived, derivedSource)::Nil)
+    if (!existsText(cmt2, "Base method has documentation"))
+      println("Unexpected foo method comment:"+cmt2)
+  }
+}
diff --git a/test/files/presentation/doc/src/Class.scala b/test/files/presentation/doc/src/Class.scala
new file mode 100755
index 0000000000..a974bd6f5c
--- /dev/null
+++ b/test/files/presentation/doc/src/Class.scala
@@ -0,0 +1 @@
+object Class
\ No newline at end of file
diff --git a/test/files/presentation/doc/src/p/Base.scala b/test/files/presentation/doc/src/p/Base.scala
new file mode 100755
index 0000000000..d91632b6f6
--- /dev/null
+++ b/test/files/presentation/doc/src/p/Base.scala
@@ -0,0 +1,11 @@
+package p
+
+/**
+ * @define BaseComment This is $BaseVar comment.
+ */
+trait Base {
+  /**
+   * Base method has documentation.
+   */
+  def foo: String
+}
diff --git a/test/files/presentation/doc/src/p/Derived.scala b/test/files/presentation/doc/src/p/Derived.scala
new file mode 100755
index 0000000000..1a9c9a26d1
--- /dev/null
+++ b/test/files/presentation/doc/src/p/Derived.scala
@@ -0,0 +1,9 @@
+package p
+
+/**
+ * $BaseComment
+ * @define BaseVar Derived
+ */
+class Derived extends Base {
+  def foo = ""
+}
diff --git a/test/files/presentation/private-case-class-members.check b/test/files/presentation/private-case-class-members.check
new file mode 100644
index 0000000000..678f9a34e6
--- /dev/null
+++ b/test/files/presentation/private-case-class-members.check
@@ -0,0 +1 @@
+Test OK
diff --git a/test/files/presentation/private-case-class-members/Test.scala b/test/files/presentation/private-case-class-members/Test.scala
new file mode 100644
index 0000000000..e64c8238ea
--- /dev/null
+++ b/test/files/presentation/private-case-class-members/Test.scala
@@ -0,0 +1,34 @@
+import scala.tools.nsc.interactive.tests.InteractiveTest
+import scala.reflect.internal.util.SourceFile
+import scala.tools.nsc.interactive.Response
+
+object Test extends InteractiveTest {
+  override def execute(): Unit = {
+    val source = loadSourceAndWaitUntilTypechecked("State.scala")
+    checkErrors(source)
+  }
+
+  private def loadSourceAndWaitUntilTypechecked(sourceName: String): SourceFile = {
+    val sourceFile = sourceFiles.find(_.file.name == sourceName).head
+    compiler.askToDoFirst(sourceFile)
+    val res = new Response[Unit]
+    compiler.askReload(List(sourceFile), res)
+    res.get
+    askLoadedTyped(sourceFile).get
+    // the second round of type-checking makes it fail
+    compiler.askReload(List(sourceFile), res)
+    res.get
+    askLoadedTyped(sourceFile).get
+
+    sourceFile
+  }
+
+  private def checkErrors(source: SourceFile): Unit = compiler.getUnitOf(source) match {
+    case Some(unit) =>
+      val problems = unit.problems.toList
+      if(problems.isEmpty) reporter.println("Test OK")
+      else problems.foreach(problem => reporter.println(problem.msg))
+
+    case None => reporter.println("No compilation unit found for " + source.file.name)
+  }
+}
diff --git a/test/files/presentation/private-case-class-members/src/State.scala b/test/files/presentation/private-case-class-members/src/State.scala
new file mode 100644
index 0000000000..c31817076c
--- /dev/null
+++ b/test/files/presentation/private-case-class-members/src/State.scala
@@ -0,0 +1,5 @@
+object State
+case class State(private val foo: Int)
+
+case class State2(private val foo: Int)
+object State2
diff --git a/test/files/presentation/quasiquotes.flags b/test/files/presentation/quasiquotes.flags
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/test/files/presentation/quasiquotes.flags
diff --git a/test/files/presentation/t8934.check b/test/files/presentation/t8934.check
new file mode 100644
index 0000000000..0ece87f808
--- /dev/null
+++ b/test/files/presentation/t8934.check
@@ -0,0 +1,2 @@
+reload: Source.scala
+Test OK
diff --git a/test/files/presentation/t8934/Runner.scala b/test/files/presentation/t8934/Runner.scala
new file mode 100644
index 0000000000..944f458391
--- /dev/null
+++ b/test/files/presentation/t8934/Runner.scala
@@ -0,0 +1,27 @@
+import scala.tools.nsc.interactive.tests.InteractiveTest
+import scala.reflect.internal.util.SourceFile
+import scala.tools.nsc.interactive.Response
+
+object Test extends InteractiveTest {
+
+  override def execute(): Unit = {
+    val src = loadSourceAndWaitUntilTypechecked("Source.scala")
+    checkErrors(src)
+  }
+
+  private def loadSourceAndWaitUntilTypechecked(sourceName: String): SourceFile = {
+    val sourceFile = sourceFiles.find(_.file.name == sourceName).head
+    askReload(List(sourceFile)).get
+    askLoadedTyped(sourceFile).get
+    sourceFile
+  }
+
+  private def checkErrors(source: SourceFile): Unit = compiler.getUnitOf(source) match {
+    case Some(unit) =>
+      val problems = unit.problems.toList
+      if(problems.isEmpty) reporter.println("Test OK")
+      else problems.foreach(problem => reporter.println(problem.msg))
+
+    case None => reporter.println("No compilation unit found for " + source.file.name)
+  }
+}
diff --git a/test/files/presentation/t8934/src/Source.scala b/test/files/presentation/t8934/src/Source.scala
new file mode 100644
index 0000000000..769c8fd38b
--- /dev/null
+++ b/test/files/presentation/t8934/src/Source.scala
@@ -0,0 +1,10 @@
+class Quasi {
+  import reflect.runtime.universe._
+
+  def test: Unit = {
+    (null: Any) match {
+      case q"$foo($bar)" =>
+    }
+    ()
+  }
+}
diff --git a/test/files/presentation/t8941.check b/test/files/presentation/t8941.check
new file mode 100644
index 0000000000..341804903a
--- /dev/null
+++ b/test/files/presentation/t8941.check
@@ -0,0 +1,7 @@
+reload: Source.scala
+
+askType at Source.scala(6,7)
+================================================================================
+[response] askTypeAt (6,7)
+scala.this.Predef.???
+================================================================================
diff --git a/test/files/presentation/t8941/Runner.scala b/test/files/presentation/t8941/Runner.scala
new file mode 100644
index 0000000000..0a8923a583
--- /dev/null
+++ b/test/files/presentation/t8941/Runner.scala
@@ -0,0 +1,11 @@
+import scala.tools.nsc.interactive.tests.InteractiveTest
+
+object Test extends InteractiveTest {
+  override def runDefaultTests() {
+    // make sure typer is done.. the virtual pattern matcher might translate
+    // some trees and mess up positions. But we'll catch it red handed!
+    // sourceFiles foreach (src => askLoadedTyped(src).get)
+    super.runDefaultTests()
+  }
+
+}
diff --git a/test/files/presentation/t8941/src/Source.scala b/test/files/presentation/t8941/src/Source.scala
new file mode 100644
index 0000000000..7438cccb03
--- /dev/null
+++ b/test/files/presentation/t8941/src/Source.scala
@@ -0,0 +1,8 @@
+object Foo {
+  implicit class MatCreator(val ctx: StringContext) extends AnyVal {
+    def m(args: Any*): Unit = {
+      ctx.checkLengths(args)
+    }
+    ???/*?*/
+  }
+}
diff --git a/test/files/presentation/t8941b/IdempotencyTest.scala b/test/files/presentation/t8941b/IdempotencyTest.scala
new file mode 100644
index 0000000000..af01b36898
--- /dev/null
+++ b/test/files/presentation/t8941b/IdempotencyTest.scala
@@ -0,0 +1,73 @@
+package scala.tools.nsc
+package interactive
+package tests.core
+
+import reporters.{Reporter => CompilerReporter}
+import scala.tools.nsc.interactive.InteractiveReporter
+import scala.reflect.internal.util.SourceFile
+
+/** Determistically interrupts typechecking of `code` when a defintion named
+  * `MagicInterruptionMarker` is typechecked, and then performs a targetted
+  * typecheck of the tree at the specal comment marker marker
+  */  
+abstract class IdempotencyTest { self =>
+  private val settings = new Settings
+  settings.usejavacp.value = true
+
+  private object Break extends scala.util.control.ControlThrowable
+
+  private val compilerReporter: CompilerReporter = new InteractiveReporter {
+    override def compiler = self.compiler
+  }
+
+  object compiler extends Global(settings, compilerReporter) {
+    override def checkForMoreWork(pos: Position) {
+    }
+    override def signalDone(context: Context, old: Tree, result: Tree) {
+      // println("signalDone: " + old.toString.take(50).replaceAll("\n", "\\n"))
+      if (!interrupted && analyzer.lockedCount == 0 && interruptsEnabled && shouldInterrupt(result)) {
+        interrupted = true
+        val typed = typedTreeAt(markerPosition)
+        checkTypedTree(typed)
+        throw Break
+      }
+      super.signalDone(context, old, result)
+    }
+
+    // we're driving manually using our own thread, disable the check here.
+    override def assertCorrectThread() {}
+  }
+
+  import compiler._
+
+  private var interrupted = false
+
+  // Extension points
+  protected def code: String
+  protected def shouldInterrupt(tree: Tree): Boolean = {
+    tree.symbol != null && tree.symbol.name.toString == "MagicInterruptionMarker"
+  }
+  protected def checkTypedTree(tree: Tree): Unit = {}
+  
+
+  private val source: SourceFile = newSourceFile(code)
+  private def markerPosition: Position = source.position(code.indexOf("/*?*/"))
+
+  def assertNoProblems() {
+    val problems = getUnit(source).get.problems
+    assert(problems.isEmpty, problems.mkString("\n"))
+  }
+
+  def show() {
+    reloadSource(source)
+    try {
+      typedTree(source, true)
+      assert(false, "Expected to break out of typechecking.")
+    } catch {
+      case Break => // expected
+    }
+    assertNoProblems()
+  }
+
+  def main(args: Array[String]) { show() }
+}
diff --git a/test/files/presentation/t8941b/Test.scala b/test/files/presentation/t8941b/Test.scala
new file mode 100644
index 0000000000..7269a14286
--- /dev/null
+++ b/test/files/presentation/t8941b/Test.scala
@@ -0,0 +1,53 @@
+import scala.tools.nsc.interactive.tests.core.IdempotencyTest
+
+// At the time of writing this test, removing any part of `enterExistingSym` 
+// leads to a failure.
+object Test {
+  def main(args: Array[String]) {
+    test("""
+      object Foo {
+        def term {
+          def foo(c: String = "") = c
+          class MagicInterruptionMarker
+          foo()/*?*/
+        }
+      }
+    """)
+
+    test("""
+      object Foo {
+        def term {
+          def foo = 42
+          class MagicInterruptionMarker
+          foo/*?*/
+        }
+      }
+    """)
+
+    test("""
+      object Foo {
+        def term {
+          lazy val foo = 42
+          class MagicInterruptionMarker
+          foo/*?*/
+        }
+      }
+    """)
+
+    test("""
+      object Foo {
+        implicit class C(val a: String) extends AnyVal
+        class MagicInterruptionMarker
+        ""/*?*/
+      }
+    """)
+  }
+
+  def test(code0: String) {
+    val t = new IdempotencyTest {
+      def code = code0
+    }
+    t.show()
+  }
+}
+
diff --git a/test/files/presentation/visibility/src/Completions.scala b/test/files/presentation/visibility/src/Completions.scala
index 8c07934915..69ec3959ad 100644
--- a/test/files/presentation/visibility/src/Completions.scala
+++ b/test/files/presentation/visibility/src/Completions.scala
@@ -11,7 +11,7 @@ package accessibility {
     def secretPublic(): Unit
 
     def someTests(other: Foo) {
-      other./*!*/secretPrivate // should be all but scretThis
+      other./*!*/secretPrivate // should be all but secretThis
 
       this./*!*/secretProtected // should hit five completions
     }
@@ -25,7 +25,7 @@ package accessibility {
 
   class UnrelatedClass {
     def someTests(foo: Foo) {
-      foo./*!*/ // should list public and protected[accessiblity]
+      foo./*!*/ // should list public and protected[accessibility]
     }
   }
 
diff --git a/test/files/res/t6613.check b/test/files/res/t6613.check
new file mode 100644
index 0000000000..bbd9331b16
--- /dev/null
+++ b/test/files/res/t6613.check
@@ -0,0 +1,5 @@
+
+nsc> 
+nsc> 
+nsc> 
+nsc> 
diff --git a/test/files/res/t6613.res b/test/files/res/t6613.res
new file mode 100644
index 0000000000..e3fa000fdd
--- /dev/null
+++ b/test/files/res/t6613.res
@@ -0,0 +1,3 @@
+t6613/Enummy.java
+t6613/Broken.scala
+t6613/Broken.scala
diff --git a/test/files/res/t6613/Broken.scala b/test/files/res/t6613/Broken.scala
new file mode 100644
index 0000000000..9bcd12dbe1
--- /dev/null
+++ b/test/files/res/t6613/Broken.scala
@@ -0,0 +1 @@
+class Broken() { def broken() = Enummy.Broke.CHIP }
diff --git a/test/files/res/t6613/Enummy.java b/test/files/res/t6613/Enummy.java
new file mode 100644
index 0000000000..1863ef1297
--- /dev/null
+++ b/test/files/res/t6613/Enummy.java
@@ -0,0 +1 @@
+public class Enummy { public enum Broke { SHARD, CHIP } }
diff --git a/test/files/res/t8871.check b/test/files/res/t8871.check
new file mode 100644
index 0000000000..bbd9331b16
--- /dev/null
+++ b/test/files/res/t8871.check
@@ -0,0 +1,5 @@
+
+nsc> 
+nsc> 
+nsc> 
+nsc> 
diff --git a/test/files/res/t8871.res b/test/files/res/t8871.res
new file mode 100644
index 0000000000..9b1a5fb57f
--- /dev/null
+++ b/test/files/res/t8871.res
@@ -0,0 +1,4 @@
+t8871/tag.scala
+t8871/usetag.scala
+t8871/usetag.scala
+
diff --git a/test/files/res/t8871/tag.scala b/test/files/res/t8871/tag.scala
new file mode 100644
index 0000000000..1a1803b77d
--- /dev/null
+++ b/test/files/res/t8871/tag.scala
@@ -0,0 +1,3 @@
+class Tag {
+  @inline def apply[@specialized A, T](a: A): A = a
+}
diff --git a/test/files/res/t8871/usetag.scala b/test/files/res/t8871/usetag.scala
new file mode 100644
index 0000000000..139d768552
--- /dev/null
+++ b/test/files/res/t8871/usetag.scala
@@ -0,0 +1,6 @@
+trait Foo
+
+object Test {
+  val y = new Tag().apply[Double, Foo](3.3)
+  // under FSC, this gave t8871/usetag.scala:4: error: wrong number of type parameters for method apply$mDc$sp: [T](a: Double)Double
+}
diff --git a/test/files/res/t9089.check b/test/files/res/t9089.check
new file mode 100644
index 0000000000..6cf64f734b
--- /dev/null
+++ b/test/files/res/t9089.check
@@ -0,0 +1,4 @@
+
+nsc> 
+nsc> 
+nsc> 
diff --git a/test/files/res/t9089.res b/test/files/res/t9089.res
new file mode 100644
index 0000000000..ab5cc8534d
--- /dev/null
+++ b/test/files/res/t9089.res
@@ -0,0 +1,2 @@
+t9089/A.scala
+t9089/A.scala
diff --git a/test/files/res/t9089/A.scala b/test/files/res/t9089/A.scala
new file mode 100644
index 0000000000..bccf269639
--- /dev/null
+++ b/test/files/res/t9089/A.scala
@@ -0,0 +1 @@
+object O { def f(x: => Int): Int = x }
diff --git a/test/files/run/applydynamic_sip.scala b/test/files/run/applydynamic_sip.scala
index cf918a82ed..47d0c6a303 100644
--- a/test/files/run/applydynamic_sip.scala
+++ b/test/files/run/applydynamic_sip.scala
@@ -40,7 +40,7 @@ object Test extends App {
   // qual.sel(arg = a, a2: _*)
   // qual.sel(arg, arg2 = "a2", a2: _*)
 
-  // If qual.sel appears immediately on the left-hand side of an assigment
+  // If qual.sel appears immediately on the left-hand side of an assignment
   // qual.updateDynamic(“sel”)(expr)
   qual.sel = expr
 
diff --git a/test/files/run/delambdafy_uncurry_byname_inline.check b/test/files/run/delambdafy_uncurry_byname_inline.check
index 0dc69b379a..d96a995f44 100644
--- a/test/files/run/delambdafy_uncurry_byname_inline.check
+++ b/test/files/run/delambdafy_uncurry_byname_inline.check
@@ -7,7 +7,7 @@ package <empty> {
     };
     def bar(x: () => Int): Int = x.apply();
     def foo(): Int = Foo.this.bar({
-      @SerialVersionUID(0) final <synthetic> class $anonfun extends scala.runtime.AbstractFunction0[Int] with Serializable {
+      @SerialVersionUID(value = 0) final <synthetic> class $anonfun extends scala.runtime.AbstractFunction0[Int] with Serializable {
         def <init>(): <$anon: () => Int> = {
           $anonfun.super.<init>();
           ()
diff --git a/test/files/run/delambdafy_uncurry_inline.check b/test/files/run/delambdafy_uncurry_inline.check
index e2b024b462..5521cc4a2c 100644
--- a/test/files/run/delambdafy_uncurry_inline.check
+++ b/test/files/run/delambdafy_uncurry_inline.check
@@ -7,7 +7,7 @@ package <empty> {
     };
     def bar(): Unit = {
       val f: Int => Int = {
-        @SerialVersionUID(0) final <synthetic> class $anonfun extends scala.runtime.AbstractFunction1[Int,Int] with Serializable {
+        @SerialVersionUID(value = 0) final <synthetic> class $anonfun extends scala.runtime.AbstractFunction1[Int,Int] with Serializable {
           def <init>(): <$anon: Int => Int> = {
             $anonfun.super.<init>();
             ()
diff --git a/test/files/run/global-showdef.check b/test/files/run/global-showdef.check
index 4c2fd41a1a..4ac96b4315 100644
--- a/test/files/run/global-showdef.check
+++ b/test/files/run/global-showdef.check
@@ -1,14 +1,14 @@
 <<-- class foo.bar.Bippy after phase 'typer' -->>
   def showdefTestMemberClass1: Int
+<<-- object foo.bar.Bippy after phase 'typer' -->>
+  def showdefTestMemberObject2: String
 <<-- type foo.bar.Bippy.BippyType after phase 'typer' -->>
   def showdefTestMemberType1: Unit
+<<-- object foo.bar.Bippy.Boppity.Boo after phase 'typer' -->>
+  def showdefTestMemberObject1: String
 <<-- type foo.bar.Bippy.BippyType after phase 'typer' -->>
   def showdefTestMemberType2: Unit
 <<-- class foo.bar.Bippy.Boppity after phase 'typer' -->>
   def showdefTestMemberClass2: Int
 <<-- class foo.bar.Bippy.Boppity.Boo after phase 'typer' -->>
   def showdefTestMemberClass3: Int
-<<-- object foo.bar.Bippy after phase 'typer' -->>
-  def showdefTestMemberObject2: String
-<<-- object foo.bar.Bippy.Boppity.Boo after phase 'typer' -->>
-  def showdefTestMemberObject1: String
diff --git a/test/files/run/global-showdef.scala b/test/files/run/global-showdef.scala
index 1d4891fd1f..276fcc1e7c 100644
--- a/test/files/run/global-showdef.scala
+++ b/test/files/run/global-showdef.scala
@@ -1,11 +1,10 @@
-import scala.tools.nsc._
-import scala.reflect.io.AbstractFile
+import scala.tools.partest.DirectTest
 import scala.tools.nsc.util.stringFromStream
-import scala.reflect.internal.util.{ SourceFile, BatchSourceFile }
-import scala.tools.nsc.reporters.ConsoleReporter
 
-object Test {
-  val src: SourceFile = new BatchSourceFile("src", """
+object Test extends DirectTest {
+  override def extraSettings: String = "-usejavacp -Yshow:typer -Ystop-after:typer"
+
+  override def code = """
 package foo.bar
 
 class Bippy {
@@ -32,39 +31,28 @@ object Bippy {
 
   def showdefTestMemberObject2 = "abc"
 }
-  """)
+  """
+
+  override def show(): Unit = {
+    val classes = List("Bippy", "Bippy#BippyType", "Bippy.BippyType", "Bippy#Boppity", "Bippy#Boppity#Boo")
+    val objects = List("Bippy", "Bippy#Boppity#Boo")
+
+    def interesting(line: String) = (line contains "def showdefTestMember") || (line startsWith "<<-- ")
 
-  def mkCompiler(args: String*) = {
-    val settings             = new Settings()
-    val command              = new CompilerCommand("-usejavacp" :: args.toList, settings)
+    def run(args: String*) = slurp(args: _*).lines filter interesting foreach println
 
-    new Global(settings)
+    classes.zipAll(objects, "", "") foreach {
+      case (c, "") => run("-Xshow-class", c)
+      case (c, o)  => run("-Xshow-class", c, "-Xshow-object", o)
+    }
   }
 
-  def slurp(body: => Unit): String = stringFromStream { stream =>
+  // slurp the compilation result
+  def slurp(args: String*): String = stringFromStream { stream =>
     Console.withOut(stream) {
       Console.withErr(stream) {
-        body
+        compile(args: _*)
       }
     }
   }
-  def lines(args: String*): List[String] = {
-    val output = slurp {
-      val compiler = mkCompiler(args: _*)
-      val run = new compiler.Run()
-      run.compileSources(List(src))
-    }
-    output.lines.toList
-  }
-  def showClass(name: String) = lines("-Yshow:typer", "-Xshow-class", name)
-  def showObject(name: String) = lines("-Yshow:typer", "-Xshow-object", name)
-
-  def show(xs: List[String]) = {
-    xs filter (x => (x contains "def showdefTestMember") || (x startsWith "<<-- ")) foreach println
-  }
-
-  def main(args: Array[String]) {
-    show(List("Bippy", "Bippy#BippyType", "Bippy.BippyType", "Bippy#Boppity", "Bippy#Boppity#Boo") flatMap showClass)
-    show(List("Bippy", "Bippy#Boppity#Boo") flatMap showObject)
-  }
 }
diff --git a/test/files/run/icode-reader-dead-code.check b/test/files/run/icode-reader-dead-code.check
index d1739fed3b..c9de93283e 100644
--- a/test/files/run/icode-reader-dead-code.check
+++ b/test/files/run/icode-reader-dead-code.check
@@ -1,4 +1,7 @@
 Bytecode for method f
+
+  // access flags 0x11
+  public final f()I
    L0
     LINENUMBER 4 L0
     ICONST_1
@@ -7,7 +10,11 @@ Bytecode for method f
     LOCALVARIABLE this Lp/A; L0 L1 0
     MAXSTACK = 1
     MAXLOCALS = 1
+
 Bytecode for method f
+
+  // access flags 0x11
+  public final f()I
    L0
     LINENUMBER 4 L0
     ICONST_1
@@ -17,3 +24,4 @@ Bytecode for method f
     LOCALVARIABLE this Lp/A; L0 L1 0
     MAXSTACK = 1
     MAXLOCALS = 1
+
diff --git a/test/files/run/iterator-concat.check b/test/files/run/iterator-concat.check
deleted file mode 100644
index 23835b07ae..0000000000
--- a/test/files/run/iterator-concat.check
+++ /dev/null
@@ -1,4 +0,0 @@
-100
-1000
-10000
-100000
diff --git a/test/files/run/iterator-concat.scala b/test/files/run/iterator-concat.scala
deleted file mode 100644
index f11363410f..0000000000
--- a/test/files/run/iterator-concat.scala
+++ /dev/null
@@ -1,15 +0,0 @@
-object Test {
-  // Create `size` Function0s, each of which evaluates to an Iterator
-  // which produces 1. Then fold them over ++ to get a single iterator,
-  // which should sum to "size".
-  def mk(size: Int): Iterator[Int] = {
-    val closures = (1 to size).toList.map(x => (() => Iterator(1)))
-    closures.foldLeft(Iterator.empty: Iterator[Int])((res, f) => res ++ f())
-  }
-  def main(args: Array[String]): Unit = {
-    println(mk(100).sum)
-    println(mk(1000).sum)
-    println(mk(10000).sum)
-    println(mk(100000).sum)
-  }
-}
diff --git a/test/files/run/iterator-iterate-lazy.scala b/test/files/run/iterator-iterate-lazy.scala
deleted file mode 100644
index 92b170062e..0000000000
--- a/test/files/run/iterator-iterate-lazy.scala
+++ /dev/null
@@ -1,5 +0,0 @@
-object Test {
-  def main(args: Array[String]): Unit = {
-    Iterator.iterate((1 to 5).toList)(_.tail).takeWhile(_.nonEmpty).map(_.head).toList
-  }
-}
diff --git a/test/files/run/iterators.check b/test/files/run/iterators.check
deleted file mode 100644
index bb139c1610..0000000000
--- a/test/files/run/iterators.check
+++ /dev/null
@@ -1,13 +0,0 @@
-test check_from was successful
-test check_range was successful
-test check_range2 was successful
-test check_range3 was successful
-test check_take was successful
-test check_drop was successful
-test check_foreach was successful
-test check_forall was successful
-test check_fromArray was successful
-test check_toSeq was successful
-test check_indexOf was successful
-test check_findIndexOf was successful
-
diff --git a/test/files/run/iterators.scala b/test/files/run/iterators.scala
deleted file mode 100644
index 57e05d3472..0000000000
--- a/test/files/run/iterators.scala
+++ /dev/null
@@ -1,136 +0,0 @@
-//############################################################################
-// Iterators
-//############################################################################
-
-//############################################################################
-
-import scala.language.postfixOps
-
-object Test {
-
-  def check_from: Int = {
-    val it1 = Iterator.from(-1)
-    val it2 = Iterator.from(0, -1)
-    it1.next + it2.next
-  }
-
-  def check_range: Int = {
-    val xs1 = Iterator.range(0, 10,  2) toList;
-    val xs2 = Iterator.range(0, 10, -2) toList;
-    val xs3 = Iterator.range(10, 0, -2) toList;
-    val xs4 = Iterator.range(10, 0,  2) toList;
-    val xs5 = Iterator.range(0, 10, 11) toList;
-    xs1.length + xs2.length + xs3.length + xs4.length + xs5.length
-  }
-
-  def check_range2: Int = {
-    val r1start = 0
-    val r1end = 10
-    val r1step = 1
-    val r1 = Iterator.range(r1start, r1end, r1step) toList;
-    val r2 = Iterator.range(r1start, r1end, r1step + 1) toList;
-    val r3 = Iterator.range(r1end, r1start, -r1step) toList;
-    val r4 = Iterator.range(0, 10, 11) toList;
-    // 10 + 5 + 10 + 1
-    r1.length + r2.length + r3.length + r4.length
-  }
-
-  def check_range3: Int = {
-    def trues(xs: List[Boolean]) = xs.foldLeft(0)((a, b) => if (b) a+1 else a)
-    val r1 = Iterator.range(0, 10)
-    val xs1 = List(r1 contains 5, r1 contains 6)
-    val r2a = Iterator.range(0, 10, 2)
-    val r2b = Iterator.range(0, 10, 2)
-    val xs2 = List(r2a contains 5, r2b contains 6)
-    val r3 = Iterator.range(0, 10, 11)
-    val xs3 = List(r3 contains 5, r3 contains 6)
-    // 2 + 1 + 0
-    trues(xs1) + trues(xs2) + trues(xs3)
-  }
-
-  def check_take: Int = {
-    val it1 = Iterator.from(0)
-    val xs1 = it1 take 10 toList;
-    xs1.length
-  }
-
-  def check_drop: Int = {
-    val it1 = Iterator.from(0)
-    val it2 = it1 map { 2 * _ }
-    val n1 = it1 drop 2 next
-    val n2 = it2 drop 2 next;
-    n1 + n2
-  }
-
-  def check_foreach: Int = {
-    val it1 = Iterator.from(0) take 20
-    var n = 0
-    it1 foreach { n += _ }
-    n
-  }
-
-  def check_forall: Int = {
-    val it1 = Iterator.from(0)
-    val it2 = Iterator.from(1)
-    0
-  }
-
-  def check_fromArray: Int = {  // ticket #429
-    val a = List(1, 2, 3, 4).toArray
-    var xs0 = a.iterator.toList;
-    var xs1 = a.slice(0, 1).iterator.toList;
-    var xs2 = a.slice(0, 2).iterator.toList;
-    var xs3 = a.slice(0, 3).iterator.toList;
-    var xs4 = a.slice(0, 4).iterator.toList;
-    xs0.length + xs1.length + xs2.length + xs3.length + xs4.length
-  }
-
-  def check_toSeq: String =
-    List(1, 2, 3, 4, 5).iterator.toSeq.mkString("x")
-
-  def check_indexOf: String = {
-    val i = List(1, 2, 3, 4, 5).indexOf(4)
-    val j = List(1, 2, 3, 4, 5).indexOf(16)
-    "" + i + "x" + j
-  }
-
-  def check_findIndexOf: String = {
-    val i = List(1, 2, 3, 4, 5).indexWhere { x: Int => x >= 4 }
-    val j = List(1, 2, 3, 4, 5).indexWhere { x: Int => x >= 16 }
-    "" + i + "x" + j
-  }
-
-  def check_success[A](name: String, closure: => A, expected: A) {
-    print("test " + name)
-    try {
-      val actual: A = closure
-      if (actual == expected)
-        print(" was successful")
-      else
-        print(" failed: expected "+ expected +", found "+ actual)
-    }
-    catch {
-      case exception: Throwable =>
-        print(" raised exception " + exception)
-    }
-    println()
-  }
-
-  def main(args: Array[String]) {
-    check_success("check_from",     check_from,      -1)
-    check_success("check_range",    check_range,     11)
-    check_success("check_range2",   check_range2,    26)
-    check_success("check_range3",   check_range3,     3)
-    check_success("check_take",     check_take,      10)
-    check_success("check_drop",     check_drop,      12)
-    check_success("check_foreach",  check_foreach,  190)
-    check_success("check_forall",   check_forall,     0)
-    check_success("check_fromArray",check_fromArray, 14)
-    check_success("check_toSeq",  check_toSeq, "1x2x3x4x5")
-    check_success("check_indexOf",     check_indexOf,     "3x-1")
-    check_success("check_findIndexOf", check_findIndexOf, "3x-1")
-    println()
-  }
-}
-
-//############################################################################
diff --git a/test/files/run/literals.check b/test/files/run/literals.check
index 62c5fd68ae..092340eead 100644
--- a/test/files/run/literals.check
+++ b/test/files/run/literals.check
@@ -1,57 +1,12 @@
-warning: there were 5 deprecation warnings; re-run with -deprecation for details
-test '\u0024' == '$' was successful
-test '\u005f' == '_' was successful
-test 65.asInstanceOf[Char] == 'A' was successful
-test "\141\142" == "ab" was successful
-test "\0x61\0x62".trim() == "x61\0x62" was successful
-
-test (65 : Byte) == 'A' was successful
-
-test 0X01 == 1 was successful
-test 0x01 == 1 was successful
-test 0x10 == 16 was successful
-test 0xa == 10 was successful
-test 0x0a == 10 was successful
-test +0x01 == 1 was successful
-test +0x10 == 16 was successful
-test +0xa == 10 was successful
-test +0x0a == 10 was successful
-test -0x01 == -1 was successful
-test -0x10 == -16 was successful
-test -0xa == -10 was successful
-test -0x0a == -10 was successful
-test 0x7fffffff == 2147483647 was successful
-test 0x80000000 == -2147483648 was successful
-test 0xffffffff == -1 was successful
-
-test 1l == 1L was successful
-test 1L == 1l was successful
-test 1.asInstanceOf[Long] == 1l was successful
-test 0x7fffffffffffffffL == 9223372036854775807L was successful
-test 0x8000000000000000L == -9223372036854775808L was successful
-test 0xffffffffffffffffL == -1L was successful
-
-test 1e1f == 10.0f was successful
-test .3f == 0.3f was successful
-test 0f == 0.0f was successful
-test 01.23f == 1.23f was successful
-test 3.14f == 3.14f was successful
-test 6.022e23f == 6.022e23f was successful
-test 09f == 9.0f was successful
-test 1.asInstanceOf[Float] == 1.0 was successful
-test 1l.asInstanceOf[Float] == 1.0 was successful
-
-test 1e1 == 10.0 was successful
-test .3 == 0.3 was successful
-test 0.0 == 0.0 was successful
-test 0d == 0.0 was successful
-test 01.23 == 1.23 was successful
-test 01.23d == 1.23d was successful
-test 3.14 == 3.14 was successful
-test 1e-9d == 1.0e-9 was successful
-test 1e137 == 1.0e137 was successful
-test 1.asInstanceOf[Double] == 1.0 was successful
-test 1l.asInstanceOf[Double] == 1.0 was successful
-
-test "".length() was successful
-test ggg == 3 was successful
+literals.scala:34: warning: Octal escape literals are deprecated, use \u0061 instead.
+    check_success("\"\\141\\142\" == \"ab\"", "\141\142", "ab")
+                                               ^
+literals.scala:34: warning: Octal escape literals are deprecated, use \u0062 instead.
+    check_success("\"\\141\\142\" == \"ab\"", "\141\142", "ab")
+                                                   ^
+literals.scala:37: warning: Octal escape literals are deprecated, use \u0000 instead.
+      "\0x61\0x62".getBytes(io.Codec.UTF8.charSet) sameElements Array[Byte](0, 120, 54, 49, 0, 120, 54, 50),
+       ^
+literals.scala:37: warning: Octal escape literals are deprecated, use \u0000 instead.
+      "\0x61\0x62".getBytes(io.Codec.UTF8.charSet) sameElements Array[Byte](0, 120, 54, 49, 0, 120, 54, 50),
+            ^
diff --git a/test/files/run/literals.flags b/test/files/run/literals.flags
new file mode 100644
index 0000000000..dcc59ebe32
--- /dev/null
+++ b/test/files/run/literals.flags
@@ -0,0 +1 @@
+-deprecation
diff --git a/test/files/run/literals.scala b/test/files/run/literals.scala
index 5f23e6b492..13fda05876 100644
--- a/test/files/run/literals.scala
+++ b/test/files/run/literals.scala
@@ -14,21 +14,16 @@ object Test {
     def \u03b1\u03b1(that: GGG) = i + that.i
   }
 
-  def check_success[a](name: String, closure: => a, expected: a) {
-    print("test " + name)
-    try {
-      val actual: a = closure
-      if (actual == expected) {
-        print(" was successful");
-      } else {
-        print(" failed: expected "+ expected +", found "+ actual);
+  def check_success[A](name: String, closure: => A, expected: A) {
+    val res: Option[String] =
+      try {
+        val actual: A = closure
+        if (actual == expected) None  //print(" was successful")
+        else Some(s" failed: expected $expected, found $actual")
+      } catch {
+        case exception: Throwable => Some(s" raised exception $exception")
       }
-    } catch {
-      case exception: Throwable => {
-        print(" raised exception " + exception);
-      }
-    }
-    println
+    for (e <- res) println(s"test $name $e")
   }
 
   def main(args: Array[String]) {
@@ -37,15 +32,14 @@ object Test {
     check_success("'\\u005f' == '_'", '\u005f', '_')
     check_success("65.asInstanceOf[Char] == 'A'", 65.asInstanceOf[Char], 'A')
     check_success("\"\\141\\142\" == \"ab\"", "\141\142", "ab")
-    check_success("\"\\0x61\\0x62\".trim() == \"x61\\0x62\"", "\0x61\0x62".substring(1), "x61\0x62")
-
-    println
+    //check_success("\"\\0x61\\0x62\".trim() == \"x61\\0x62\"", "\0x61\0x62".substring(1), "x61\0x62")
+    check_success(""""\0x61\0x62".getBytes == Array(0, 120, ...)""",
+      "\0x61\0x62".getBytes(io.Codec.UTF8.charSet) sameElements Array[Byte](0, 120, 54, 49, 0, 120, 54, 50),
+      true)
 
     // boolean
     check_success("(65 : Byte) == 'A'", (65: Byte) == 'A', true) // contrib #176
 
-    println
-
     // int
     check_success("0X01 == 1", 0X01, 1)
     check_success("0x01 == 1", 0x01, 1)
@@ -67,8 +61,6 @@ object Test {
     check_success("0x80000000 == -2147483648", 0x80000000, -2147483648)
     check_success("0xffffffff == -1", 0xffffffff, -1)
 
-    println
-
     // long
     check_success("1l == 1L", 1l, 1L)
     check_success("1L == 1l", 1L, 1l)
@@ -81,8 +73,6 @@ object Test {
     check_success("0xffffffffffffffffL == -1L",
       0xffffffffffffffffL, -1L)
 
-    println
-
     // see JLS at address:
     // http://java.sun.com/docs/books/jls/second_edition/html/lexical.doc.html#230798
 
@@ -97,8 +87,6 @@ object Test {
     check_success("1.asInstanceOf[Float] == 1.0", 1.asInstanceOf[Float], 1.0f)
     check_success("1l.asInstanceOf[Float] == 1.0", 1l.asInstanceOf[Float], 1.0f)
 
-    println
-
     // double
     check_success("1e1 == 10.0", 1e1, 10.0)
     check_success(".3 == 0.3", .3, 0.3)
@@ -112,7 +100,6 @@ object Test {
     check_success("1.asInstanceOf[Double] == 1.0", 1.asInstanceOf[Double], 1.0)
     check_success("1l.asInstanceOf[Double] == 1.0", 1l.asInstanceOf[Double], 1.0)
 
-    println
     check_success("\"\".length()", "\u001a".length(), 1)
 
     val ggg = GGG(1) \u03b1\u03b1 GGG(2)
diff --git a/test/files/run/priorityQueue.scala b/test/files/run/priorityQueue.scala
deleted file mode 100644
index 327d8bf137..0000000000
--- a/test/files/run/priorityQueue.scala
+++ /dev/null
@@ -1,373 +0,0 @@
-
-
-
-import scala.collection.mutable.PriorityQueue
-
-
-
-
-
-
-// populate a priority queue a few different ways and make sure they all seem equal
-object Test {
-
-  def main(args: Array[String]) {
-    // testInsertionsAndEqualities
-    // testIntensiveEnqueueDequeue
-    // testTails
-    // testInits
-    // testFilters
-    // testDrops
-    // testEquality
-    // testMisc
-    // testReverse
-    // testToList
-    // testForeach
-  }
-
-  // def testInsertionsAndEqualities {
-  //   import scala.util.Random.nextInt
-  //   val pq1 = new PriorityQueue[String]
-  //   val pq2 = new PriorityQueue[String]
-  //   val pq3 = new PriorityQueue[String]
-  //   val pq4 = new PriorityQueue[String]
-
-  //   val strings = (1 to 20).toList map (i => List.fill((Math.abs(nextInt % 20)) + 1)("x").mkString)
-
-  //   pq1 ++= strings
-  //   pq2 ++= strings.reverse
-  //   for (s <- strings) pq3 += s
-  //   for (s <- strings.reverse) pq4 += s
-
-  //   val pqs = List(pq1, pq2, pq3, pq4, pq1.clone, pq2.clone)
-
-  //   for (queue1 <- pqs ; queue2 <- pqs) {
-  //     val l1: List[String] = queue1.dequeueAll[String, List[String]]
-  //     val l2: List[String] = queue2.dequeueAll[String, List[String]]
-  //     assert(l1 == l2)
-  //     assert(queue1.max == queue2.max)
-  //   }
-
-  //   assertPriorityDestructive(pq1)
-  // }
-
-  // not a sequence anymore, Mildred
-  // def testIndexing {
-  //   val pq = new PriorityQueue[Char]
-  //   "The quick brown fox jumps over the lazy dog".foreach(pq += _)
-
-  //   // val iter = pq.iterator
-  //   // while (iter.hasNext) println("`" + iter.next + "`")
-  //   assert(pq(0) == 'z')
-  //   assert(pq(1) == 'y')
-  //   assert(pq(2) == 'x')
-  //   assert(pq(3) == 'w')
-  //   assert(pq(4) == 'v')
-  //   assert(pq(5) == 'u')
-  //   assert(pq(7) == 't')
-  //   assert(pq(8) == 's')
-  //   assert(pq(9) == 'r')
-  //   assert(pq(10) == 'r')
-
-  //   pq.clear
-  //   "abcdefghijklmnopqrstuvwxyz".foreach(pq += _)
-  //   for (i <- 0 until 26) assert(pq(i) == ('z' - i))
-
-  //   val intpq = new PriorityQueue[Int]
-  //   val intlst = new collection.mutable.ArrayBuffer ++ (0 until 100)
-  //   val random = new util.Random(101)
-  //   while (intlst.nonEmpty) {
-  //     val idx = random.nextInt(intlst.size)
-  //     intpq += intlst(idx)
-  //     intlst.remove(idx)
-  //   }
-  //   for (i <- 0 until 100) assert(intpq(i) == (99 - i))
-  // }
-
-  // def testTails {
-  //   val pq = new PriorityQueue[Int]
-  //   for (i <- 0 until 10) pq += i * 4321 % 200
-
-  //   assert(pq.size == 10)
-  //   assert(pq.nonEmpty)
-
-  //   val tailpq = pq.tail
-  //   // pq.printstate
-  //   // tailpq.printstate
-  //   assert(tailpq.size == 9)
-  //   assert(tailpq.nonEmpty)
-  //   assertPriorityDestructive(tailpq)
-  // }
-
-  // def assertPriorityDestructive[A](pq: PriorityQueue[A])(implicit ord: Ordering[A]) {
-  //   import ord._
-  //   var prev: A = null.asInstanceOf[A]
-  //   while (pq.nonEmpty) {
-  //     val curr = pq.dequeue
-  //     if (prev != null) assert(curr <= prev)
-  //     prev = curr
-  //   }
-  // }
-
-  // def testInits {
-  //   val pq = new PriorityQueue[Long]
-  //   for (i <- 0 until 20) pq += (i + 313) * 111 % 300
-
-  //   assert(pq.size == 20)
-
-  //   val initpq = pq.init
-  //   assert(initpq.size == 19)
-  //   assertPriorityDestructive(initpq)
-  // }
-
-  // def testFilters {
-  //   val pq = new PriorityQueue[String]
-  //   for (i <- 0 until 100) pq += "Some " + (i * 312 % 200)
-
-  //   val filpq = pq.filter(_.indexOf('0') != -1)
-  //   assertPriorityDestructive(filpq)
-  // }
-
-  // def testIntensiveEnqueueDequeue {
-  //   val pq = new PriorityQueue[Int]
-
-  //   testIntensive(1000, pq)
-  //   pq.clear
-  //   testIntensive(200, pq)
-  // }
-
-  // def testIntensive(sz: Int, pq: PriorityQueue[Int]) {
-  //   val lst = new collection.mutable.ArrayBuffer[Int] ++ (0 until sz)
-  //   val rand = new util.Random(7)
-  //   while (lst.nonEmpty) {
-  //     val idx = rand.nextInt(lst.size)
-  //     pq.enqueue(lst(idx))
-  //     lst.remove(idx)
-  //     if (rand.nextDouble < 0.25 && pq.nonEmpty) pq.dequeue
-  //     assertPriority(pq)
-  //   }
-  // }
-
-  // def testDrops {
-  //   val pq = new PriorityQueue[Int]
-  //   pq ++= (0 until 100)
-  //   val droppq = pq.drop(50)
-  //   assertPriority(droppq)
-
-  //   pq.clear
-  //   pq ++= droppq
-  //   assertPriorityDestructive(droppq)
-  //   assertPriority(pq)
-  //   assertPriorityDestructive(pq)
-  // }
-
-  // // your sequence days have ended, foul priority queue
-  // // def testUpdates {
-  // //   val pq = new PriorityQueue[Int]
-  // //   pq ++= (0 until 36)
-  // //   assertPriority(pq)
-
-  // //   pq(0) = 100
-  // //   assert(pq(0) == 100)
-  // //   assert(pq.dequeue == 100)
-  // //   assertPriority(pq)
-
-  // //   pq.clear
-
-  // //   pq ++= (1 to 100)
-  // //   pq(5) = 200
-  // //   assert(pq(0) == 200)
-  // //   assert(pq(1) == 100)
-  // //   assert(pq(2) == 99)
-  // //   assert(pq(3) == 98)
-  // //   assert(pq(4) == 97)
-  // //   assert(pq(5) == 96)
-  // //   assert(pq(6) == 94)
-  // //   assert(pq(7) == 93)
-  // //   assert(pq(98) == 2)
-  // //   assert(pq(99) == 1)
-  // //   assertPriority(pq)
-
-  // //   pq(99) = 450
-  // //   assert(pq(0) == 450)
-  // //   assert(pq(1) == 200)
-  // //   assert(pq(99) == 2)
-  // //   assertPriority(pq)
-
-  // //   pq(1) = 0
-  // //   assert(pq(1) == 100)
-  // //   assert(pq(99) == 0)
-  // //   assertPriority(pq)
-  // //   assertPriorityDestructive(pq)
-  // // }
-
-  // def testEquality {
-  //   val pq1 = new PriorityQueue[Int]
-  //   val pq2 = new PriorityQueue[Int]
-
-  //   pq1 ++= (0 until 50)
-  //   var i = 49
-  //   while (i >= 0) {
-  //     pq2 += i
-  //     i -= 1
-  //   }
-  //   assert(pq1 == pq2)
-  //   assertPriority(pq2)
-
-  //   pq1 += 100
-  //   assert(pq1 != pq2)
-  //   pq2 += 100
-  //   assert(pq1 == pq2)
-  //   pq2 += 200
-  //   assert(pq1 != pq2)
-  //   pq1 += 200
-  //   assert(pq1 == pq2)
-  //   assertPriorityDestructive(pq1)
-  //   assertPriorityDestructive(pq2)
-  // }
-
-  // def testMisc {
-  //   val pq = new PriorityQueue[Int]
-  //   pq ++= (0 until 100)
-  //   assert(pq.size == 100)
-
-  //   val (p1, p2) = pq.partition(_ < 50)
-  //   assertPriorityDestructive(p1)
-  //   assertPriorityDestructive(p2)
-
-  //   val spq = pq.slice(25, 75)
-  //   assertPriorityDestructive(spq)
-
-  //   pq.clear
-  //   pq ++= (0 until 10)
-  //   pq += 5
-  //   assert(pq.size == 11)
-
-  //   val ind = pq.lastIndexWhere(_ == 5)
-  //   assert(ind == 5)
-  //   assertPriorityDestructive(pq)
-
-  //   pq.clear
-  //   pq ++= (0 until 10)
-  //   assert(pq.lastIndexWhere(_ == 9) == 0)
-  //   assert(pq.lastIndexOf(8) == 1)
-  //   assert(pq.lastIndexOf(7) == 2)
-
-  //   pq += 5
-  //   pq += 9
-  //   assert(pq.lastIndexOf(9) == 1)
-  //   assert(pq.lastIndexWhere(_ % 2 == 1) == 10)
-  //   assert(pq.lastIndexOf(5) == 6)
-
-  //   val lst = pq.reverseIterator.toList
-  //   for (i <- 0 until 5) assert(lst(i) == i)
-  //   assert(lst(5) == 5)
-  //   assert(lst(6) == 5)
-  //   assert(lst(7) == 6)
-  //   assert(lst(8) == 7)
-  //   assert(lst(9) == 8)
-  //   assert(lst(10) == 9)
-  //   assert(lst(11) == 9)
-
-  //   pq.clear
-  //   assert(pq.reverseIterator.toList.isEmpty)
-
-  //   pq ++= (50 to 75)
-  //   assert(pq.lastIndexOf(70) == 5)
-
-  //   pq += 55
-  //   pq += 70
-  //   assert(pq.lastIndexOf(70) == 6)
-  //   assert(pq.lastIndexOf(55) == 22)
-  //   assert(pq.lastIndexOf(55, 21) == 21)
-  //   assert(pq.lastIndexWhere(_ > 54) == 22)
-  //   assert(pq.lastIndexWhere(_ > 54, 21) == 21)
-  //   assert(pq.lastIndexWhere(_ > 69, 5) == 5)
-  // }
-
-  // def testReverse {
-  //   val pq = new PriorityQueue[(Int, Int)]
-  //   pq ++= (for (i <- 0 until 10) yield (i, i * i % 10))
-
-  //   assert(pq.reverse.size == pq.reverseIterator.toList.size)
-  //   assert((pq.reverse zip pq.reverseIterator.toList).forall(p => p._1 == p._2))
-  //   assert(pq.reverse.sameElements(pq.reverseIterator.toSeq))
-  //   assert(pq.reverse(0)._1 == pq(9)._1)
-  //   assert(pq.reverse(1)._1 == pq(8)._1)
-  //   assert(pq.reverse(4)._1 == pq(5)._1)
-  //   assert(pq.reverse(9)._1 == pq(0)._1)
-
-  //   pq += ((7, 7))
-  //   pq += ((7, 9))
-  //   pq += ((7, 8))
-  //   assert(pq.reverse.reverse == pq)
-  //   assert(pq.reverse.lastIndexWhere(_._2 == 6) == 6)
-  //   assertPriorityDestructive(pq.reverse.reverse)
-
-  //   val iq = new PriorityQueue[Int]
-  //   iq ++= (0 until 50)
-  //   assert(iq.reverse == iq.reverseIterator.toSeq)
-  //   assert(iq.reverse.reverse == iq)
-
-  //   iq += 25
-  //   iq += 40
-  //   iq += 10
-  //   assert(iq.reverse == iq.reverseIterator.toList)
-  //   assert(iq.reverse.reverse == iq)
-  //   assert(iq.reverse.lastIndexWhere(_ == 10) == 11)
-  //   assertPriorityDestructive(iq.reverse.reverse)
-  // }
-
-  // def testToList {
-  //   val pq = new PriorityQueue[Int]
-
-  //   pq += 1
-  //   pq += 4
-  //   pq += 0
-  //   pq += 5
-  //   pq += 3
-  //   pq += 2
-  //   assert(pq.toList == pq)
-  //   assert(pq == List(5, 4, 3, 2, 1, 0))
-  //   assert(pq.reverse == List(0, 1, 2, 3, 4, 5))
-
-  //   pq.clear
-  //   for (i <- -50 until 50) pq += i
-  //   assert(pq.toList == pq)
-  //   assert(pq.toList == (-50 until 50).reverse)
-  // }
-
-  // def testForeach {
-  //   val pq = new PriorityQueue[Char]
-
-  //   pq += 't'
-  //   pq += 'o'
-  //   pq += 'b'
-  //   pq += 'y'
-  //   val sbf = new StringBuilder
-  //   val sbi = new StringBuilder
-  //   pq.foreach(sbf += _)
-  //   pq.iterator.foreach(sbi += _)
-  //   assert(sbf.toString == sbi.toString)
-  //   assert(sbf.toString == "ytob")
-  // }
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/test/files/run/repl-javap-lambdas.scala b/test/files/run/repl-javap-lambdas.scala
new file mode 100644
index 0000000000..15e5bf6877
--- /dev/null
+++ b/test/files/run/repl-javap-lambdas.scala
@@ -0,0 +1,23 @@
+import scala.tools.partest.JavapTest
+import scala.tools.nsc.Settings
+
+// see repl-javap-memfun.java for the complementary version
+object Test extends JavapTest {
+  override def transformSettings(s: Settings) = { s.Ydelambdafy.value = "method" ; s }
+  def code = """
+    |object Betty {
+    | List(1,2,3) count (_ % 2 != 0)
+    | def f = List(1,2,3) filter (_ % 2 != 0) map (_ * 2)
+    | def g = List(1,2,3) filter (_ % 2 == 0) map (_ * 3) map (_ + 1)
+    |}
+    |:javap -fun Betty#g
+  """.stripMargin
+
+  // three anonfuns of Betty#g
+  override def yah(res: Seq[String]) = {
+    import PartialFunction.{ cond => when }
+    val r = """\s*private static final .* \$anonfun\$\d+\(.*""".r
+    def filtered = res filter (when(_) { case r(_*) => true })
+    3 == filtered.size
+  }
+}
diff --git a/test/files/run/repl-javap-memfun.scala b/test/files/run/repl-javap-memfun.scala
index d2b4243c8b..d10ebcb399 100644
--- a/test/files/run/repl-javap-memfun.scala
+++ b/test/files/run/repl-javap-memfun.scala
@@ -1,6 +1,10 @@
 import scala.tools.partest.JavapTest
+import scala.tools.nsc.Settings
 
+// see repl-javap-lambdas.scala for the complementary version
 object Test extends JavapTest {
+  // asserting the default
+  override def transformSettings(s: Settings) = { s.Ydelambdafy.value = "inline" ; s }
   def code = """
     |object Betty {
     | List(1,2,3) count (_ % 2 != 0)
diff --git a/test/files/run/repl-javap-outdir-funs.flags b/test/files/run/repl-javap-outdir-funs.flags
new file mode 100644
index 0000000000..ac96850b69
--- /dev/null
+++ b/test/files/run/repl-javap-outdir-funs.flags
@@ -0,0 +1 @@
+-Ydelambdafy:inline
\ No newline at end of file
diff --git a/test/files/run/repl-javap-outdir-funs/run-repl_7.scala b/test/files/run/repl-javap-outdir-funs/run-repl_7.scala
index 6c6fe2d515..af9651a8a3 100644
--- a/test/files/run/repl-javap-outdir-funs/run-repl_7.scala
+++ b/test/files/run/repl-javap-outdir-funs/run-repl_7.scala
@@ -1,6 +1,8 @@
 import scala.tools.partest.JavapTest
 
 object Test extends JavapTest {
+  // note the '-fun': it makes :javap search for some anonfun.
+  // for that reason, this test has a flags file that forces delambdafy:inline (doesn't allow :method)
   def code = """
     |:javap -fun disktest/Foo.class
   """.stripMargin
@@ -11,7 +13,8 @@ object Test extends JavapTest {
     if (scala.tools.partest.utils.Properties.isAvian)
       true
     else {
-      def filtered = res filter (_ contains "public final class disktest.Foo")
+      val r = "public final class disktest.Foo.*extends scala.runtime.AbstractFunction1".r
+      def filtered = res filter (r.findFirstIn(_).nonEmpty)
       1 == filtered.size
     }
 }
diff --git a/test/files/run/sammy_repeated.check b/test/files/run/sammy_repeated.check
new file mode 100644
index 0000000000..1cff0f067c
--- /dev/null
+++ b/test/files/run/sammy_repeated.check
@@ -0,0 +1 @@
+WrappedArray(1)
diff --git a/test/files/run/sammy_repeated.flags b/test/files/run/sammy_repeated.flags
new file mode 100644
index 0000000000..e1b37447c9
--- /dev/null
+++ b/test/files/run/sammy_repeated.flags
@@ -0,0 +1 @@
+-Xexperimental
\ No newline at end of file
diff --git a/test/files/run/sammy_repeated.scala b/test/files/run/sammy_repeated.scala
new file mode 100644
index 0000000000..c24dc41909
--- /dev/null
+++ b/test/files/run/sammy_repeated.scala
@@ -0,0 +1,8 @@
+trait RepeatedSink { def accept(a: Any*): Unit }
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val f: RepeatedSink = (a) => println(a)
+    f.accept(1)
+  }
+}
\ No newline at end of file
diff --git a/test/files/run/t1994.scala b/test/files/run/t1994.scala
new file mode 100644
index 0000000000..0b463e3444
--- /dev/null
+++ b/test/files/run/t1994.scala
@@ -0,0 +1,20 @@
+class A {
+  protected def x = 0
+  protected[A] def y = 0
+}
+ 
+class B extends A {
+  override def x = 1
+  def superY = super[A].y
+  override def y = 1
+}
+
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val b = new B
+    assert(b.x == 1)
+    assert(b.y == 1)
+    assert(b.superY == 0)
+  }
+}
diff --git a/test/files/run/t2866.check b/test/files/run/t2866.check
new file mode 100644
index 0000000000..7f52da85fb
--- /dev/null
+++ b/test/files/run/t2866.check
@@ -0,0 +1,3 @@
+t2866.scala:30: warning: imported `one' is permanently hidden by definition of value one
+    import A.one // warning: imported `one' is permanently hidden by definition of value one.
+             ^
diff --git a/test/files/run/t2866.scala b/test/files/run/t2866.scala
new file mode 100644
index 0000000000..8059107583
--- /dev/null
+++ b/test/files/run/t2866.scala
@@ -0,0 +1,44 @@
+// for 2.7.x compatibility
+
+object A {
+  implicit val one = 1
+}
+
+object Test extends App {
+
+  locally {
+    import A._
+    locally {
+      // assert(implicitly[Int] == 1) // error: could not find implicit value for parameter e: Int.
+                                     // !!! Why one A.one?
+      // (I assume you mean: why _not_ A.one? A.one is shadowed by local one.
+      // but the local one cannot be used yet because it does not have an explicit type.
+      implicit val one = 2
+      assert(implicitly[Int] == 2)
+      assert(one == 2)
+    }
+  }
+
+  locally {
+    import A._
+    implicit val one: Int = 2
+    assert(implicitly[Int] == 2)
+    assert(one == 2)
+  }
+
+  locally {
+    import A.one // warning: imported `one' is permanently hidden by definition of value one.
+                 // !!! Really?
+    //assert(implicitly[Int] == 1)
+    implicit val one = 2
+    assert(implicitly[Int] == 2) // !!! why not 2?
+    assert(one == 2)
+  }
+
+  locally {
+    import A.{one => _, _}
+    implicit val two = 2
+    assert(implicitly[Int] == 2) // not ambiguous in 2.8.0 nor im ambiguous in 2.7.6
+  }
+
+}
diff --git a/test/files/run/t3516.check b/test/files/run/t3516.check
deleted file mode 100644
index d0d10d82fa..0000000000
--- a/test/files/run/t3516.check
+++ /dev/null
@@ -1,3 +0,0 @@
-1
-1
-21
diff --git a/test/files/run/t3516.scala b/test/files/run/t3516.scala
deleted file mode 100644
index aa302ce85a..0000000000
--- a/test/files/run/t3516.scala
+++ /dev/null
@@ -1,13 +0,0 @@
-object Test {
-  def mkIterator = (1 to 5).iterator map (x => { println(x) ; x })
-  def mkInfinite = Iterator continually { println(1) ; 1 }
-
-  def main(args: Array[String]): Unit = {
-    // Stream is strict in its head so we should see 1 from each of them.
-    val s1 = mkIterator.toStream
-    val s2 = mkInfinite.toStream
-    // back and forth without slipping into nontermination.
-    println((Stream from 1).toIterator.drop(10).toStream.drop(10).toIterator.next)
-    ()
-  }
-}
diff --git a/test/files/run/t4594-repl-settings.scala b/test/files/run/t4594-repl-settings.scala
index 4202991607..db5dc19866 100644
--- a/test/files/run/t4594-repl-settings.scala
+++ b/test/files/run/t4594-repl-settings.scala
@@ -14,7 +14,7 @@ object Test extends SessionTest {
     |warning: there was one deprecation warning; re-run with -deprecation for details
     |a: String
     |
-    |scala> :settings +deprecation
+    |scala> :settings -deprecation
     |
     |scala> def b = depp
     |<console>:8: warning: method depp is deprecated: Please don't do that.
diff --git a/test/files/run/t4788-separate-compilation.check b/test/files/run/t4788-separate-compilation.check
new file mode 100644
index 0000000000..172ad90102
--- /dev/null
+++ b/test/files/run/t4788-separate-compilation.check
@@ -0,0 +1,5 @@
+Some(@Ljava/lang/Deprecated;())
+None
+None
+Some(@LCAnnotation;() // invisible)
+Some(@LRAnnotation;())
diff --git a/test/files/run/t4788-separate-compilation/CAnnotation_1.java b/test/files/run/t4788-separate-compilation/CAnnotation_1.java
new file mode 100644
index 0000000000..7120218d62
--- /dev/null
+++ b/test/files/run/t4788-separate-compilation/CAnnotation_1.java
@@ -0,0 +1,5 @@
+import java.lang.annotation.Retention;
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+@Retention(value=CLASS)
+@interface CAnnotation {}
diff --git a/test/files/run/t4788-separate-compilation/C_1.scala b/test/files/run/t4788-separate-compilation/C_1.scala
new file mode 100644
index 0000000000..aba9b595e4
--- /dev/null
+++ b/test/files/run/t4788-separate-compilation/C_1.scala
@@ -0,0 +1,2 @@
+@CAnnotation
+class C
diff --git a/test/files/run/t4788-separate-compilation/D_1.scala b/test/files/run/t4788-separate-compilation/D_1.scala
new file mode 100644
index 0000000000..c2479fba86
--- /dev/null
+++ b/test/files/run/t4788-separate-compilation/D_1.scala
@@ -0,0 +1,5 @@
+@Deprecated
+class DJava
+
+@deprecated("", "")
+class DScala
diff --git a/test/files/run/t4788-separate-compilation/RAnnotation_1.java b/test/files/run/t4788-separate-compilation/RAnnotation_1.java
new file mode 100644
index 0000000000..f24cf66f7b
--- /dev/null
+++ b/test/files/run/t4788-separate-compilation/RAnnotation_1.java
@@ -0,0 +1,5 @@
+import java.lang.annotation.Retention;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+@Retention(value=RUNTIME)
+@interface RAnnotation {}
diff --git a/test/files/run/t4788-separate-compilation/R_1.scala b/test/files/run/t4788-separate-compilation/R_1.scala
new file mode 100644
index 0000000000..ab0cd065d9
--- /dev/null
+++ b/test/files/run/t4788-separate-compilation/R_1.scala
@@ -0,0 +1,2 @@
+@RAnnotation
+class R
diff --git a/test/files/run/t4788-separate-compilation/SAnnotation_1.java b/test/files/run/t4788-separate-compilation/SAnnotation_1.java
new file mode 100644
index 0000000000..471f27d82a
--- /dev/null
+++ b/test/files/run/t4788-separate-compilation/SAnnotation_1.java
@@ -0,0 +1,5 @@
+import java.lang.annotation.Retention;
+import static java.lang.annotation.RetentionPolicy.SOURCE;
+
+@Retention(value=SOURCE)
+@interface SAnnotation {}
diff --git a/test/files/run/t4788-separate-compilation/S_1.scala b/test/files/run/t4788-separate-compilation/S_1.scala
new file mode 100644
index 0000000000..f8756d9bc8
--- /dev/null
+++ b/test/files/run/t4788-separate-compilation/S_1.scala
@@ -0,0 +1,2 @@
+@SAnnotation
+class S
diff --git a/test/files/run/t4788-separate-compilation/Test_2.scala b/test/files/run/t4788-separate-compilation/Test_2.scala
new file mode 100644
index 0000000000..cbbb5ff386
--- /dev/null
+++ b/test/files/run/t4788-separate-compilation/Test_2.scala
@@ -0,0 +1,35 @@
+import java.io.PrintWriter;
+
+import scala.tools.partest.BytecodeTest
+import scala.tools.asm.util._
+import scala.tools.nsc.util.stringFromWriter
+
+object Test extends BytecodeTest {
+  def annotationsForClass(className: String): Option[String] = {
+    val classNode = loadClassNode(className, skipDebugInfo = false)
+    val textifier = new Textifier
+    classNode.accept(new TraceClassVisitor(null, textifier, null))
+
+    val classString = stringFromWriter(w => textifier.print(w))
+    classString
+      .split('\n')
+      .filterNot(_.contains("@Lscala/reflect/ScalaSignature"))
+      .find(_.contains("@L"))
+      .map(_.trim)
+  }
+
+  def show {
+    // It seems like @java.lang.Deprecated shows up in both the
+    // Deprecated attribute and RuntimeVisibleAnnotation attribute,
+    // while @scala.deprecated only shows up in the Deprecated attribute.
+    // The check file just documents status quo, not sure if Scala
+    // should brought in line with Java or not...
+    // See the commit message and SI-8883 for more info.
+    println(annotationsForClass("DJava"))
+    println(annotationsForClass("DScala"))
+
+    println(annotationsForClass("S"))
+    println(annotationsForClass("C"))
+    println(annotationsForClass("R"))
+  }
+}
diff --git a/test/files/run/t4788.check b/test/files/run/t4788.check
new file mode 100644
index 0000000000..172ad90102
--- /dev/null
+++ b/test/files/run/t4788.check
@@ -0,0 +1,5 @@
+Some(@Ljava/lang/Deprecated;())
+None
+None
+Some(@LCAnnotation;() // invisible)
+Some(@LRAnnotation;())
diff --git a/test/files/run/t4788/C.scala b/test/files/run/t4788/C.scala
new file mode 100644
index 0000000000..aba9b595e4
--- /dev/null
+++ b/test/files/run/t4788/C.scala
@@ -0,0 +1,2 @@
+@CAnnotation
+class C
diff --git a/test/files/run/t4788/CAnnotation.java b/test/files/run/t4788/CAnnotation.java
new file mode 100644
index 0000000000..7120218d62
--- /dev/null
+++ b/test/files/run/t4788/CAnnotation.java
@@ -0,0 +1,5 @@
+import java.lang.annotation.Retention;
+import static java.lang.annotation.RetentionPolicy.CLASS;
+
+@Retention(value=CLASS)
+@interface CAnnotation {}
diff --git a/test/files/run/t4788/D.scala b/test/files/run/t4788/D.scala
new file mode 100644
index 0000000000..c2479fba86
--- /dev/null
+++ b/test/files/run/t4788/D.scala
@@ -0,0 +1,5 @@
+@Deprecated
+class DJava
+
+@deprecated("", "")
+class DScala
diff --git a/test/files/run/t4788/R.scala b/test/files/run/t4788/R.scala
new file mode 100644
index 0000000000..ab0cd065d9
--- /dev/null
+++ b/test/files/run/t4788/R.scala
@@ -0,0 +1,2 @@
+@RAnnotation
+class R
diff --git a/test/files/run/t4788/RAnnotation.java b/test/files/run/t4788/RAnnotation.java
new file mode 100644
index 0000000000..f24cf66f7b
--- /dev/null
+++ b/test/files/run/t4788/RAnnotation.java
@@ -0,0 +1,5 @@
+import java.lang.annotation.Retention;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+@Retention(value=RUNTIME)
+@interface RAnnotation {}
diff --git a/test/files/run/t4788/S.scala b/test/files/run/t4788/S.scala
new file mode 100644
index 0000000000..f8756d9bc8
--- /dev/null
+++ b/test/files/run/t4788/S.scala
@@ -0,0 +1,2 @@
+@SAnnotation
+class S
diff --git a/test/files/run/t4788/SAnnotation.java b/test/files/run/t4788/SAnnotation.java
new file mode 100644
index 0000000000..471f27d82a
--- /dev/null
+++ b/test/files/run/t4788/SAnnotation.java
@@ -0,0 +1,5 @@
+import java.lang.annotation.Retention;
+import static java.lang.annotation.RetentionPolicy.SOURCE;
+
+@Retention(value=SOURCE)
+@interface SAnnotation {}
diff --git a/test/files/run/t4788/Test.scala b/test/files/run/t4788/Test.scala
new file mode 100644
index 0000000000..cbbb5ff386
--- /dev/null
+++ b/test/files/run/t4788/Test.scala
@@ -0,0 +1,35 @@
+import java.io.PrintWriter;
+
+import scala.tools.partest.BytecodeTest
+import scala.tools.asm.util._
+import scala.tools.nsc.util.stringFromWriter
+
+object Test extends BytecodeTest {
+  def annotationsForClass(className: String): Option[String] = {
+    val classNode = loadClassNode(className, skipDebugInfo = false)
+    val textifier = new Textifier
+    classNode.accept(new TraceClassVisitor(null, textifier, null))
+
+    val classString = stringFromWriter(w => textifier.print(w))
+    classString
+      .split('\n')
+      .filterNot(_.contains("@Lscala/reflect/ScalaSignature"))
+      .find(_.contains("@L"))
+      .map(_.trim)
+  }
+
+  def show {
+    // It seems like @java.lang.Deprecated shows up in both the
+    // Deprecated attribute and RuntimeVisibleAnnotation attribute,
+    // while @scala.deprecated only shows up in the Deprecated attribute.
+    // The check file just documents status quo, not sure if Scala
+    // should brought in line with Java or not...
+    // See the commit message and SI-8883 for more info.
+    println(annotationsForClass("DJava"))
+    println(annotationsForClass("DScala"))
+
+    println(annotationsForClass("S"))
+    println(annotationsForClass("C"))
+    println(annotationsForClass("R"))
+  }
+}
diff --git a/test/files/run/t4950.check b/test/files/run/t4950.check
new file mode 100644
index 0000000000..3f3a302b62
--- /dev/null
+++ b/test/files/run/t4950.check
@@ -0,0 +1,9 @@
+Type in expressions to have them evaluated.
+Type :help for more information.
+
+scala> val 1 = 2
+scala.MatchError: 2 (of class java.lang.Integer)
+
+scala> val List(1) = List(1)
+
+scala> :quit
diff --git a/test/files/run/t4950.scala b/test/files/run/t4950.scala
new file mode 100644
index 0000000000..cef06027bf
--- /dev/null
+++ b/test/files/run/t4950.scala
@@ -0,0 +1,12 @@
+import scala.tools.partest.ReplTest
+
+object Test extends ReplTest {
+  // Filter out the abbreviated stacktrace "... X elided" 
+  // because the number seems to differ between versions/platforms/...
+  override def show = eval() filterNot (_ contains "elided") foreach println
+  def code =
+"""
+val 1 = 2
+val List(1) = List(1)
+"""
+}
diff --git a/test/files/run/t5313.scala b/test/files/run/t5313.scala
index 0d7168fa89..7f5af74c3f 100644
--- a/test/files/run/t5313.scala
+++ b/test/files/run/t5313.scala
@@ -11,7 +11,7 @@ object Test extends IcodeComparison {
       def bar = {
         var kept1 = new Object
         val result = new java.lang.ref.WeakReference(kept1)
-        kept1 = null // we can't eliminate this assigment because result can observe
+        kept1 = null // we can't eliminate this assignment because result can observe
                    // when the object has no more references. See SI-5313
         kept1 = new Object // but we can eliminate this one because kept1 has already been clobbered
         var erased2 = null // we can eliminate this store because it's never used
diff --git a/test/files/run/t5665.scala b/test/files/run/t5665.scala
new file mode 100644
index 0000000000..3ac498b5c0
--- /dev/null
+++ b/test/files/run/t5665.scala
@@ -0,0 +1,13 @@
+object O {
+  trait T {
+    private[this] val c: Int = 42
+    def f =
+      { x: Int => c }
+  }
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    assert(new O.T{}.f(0) == 42)
+  }
+}
diff --git a/test/files/run/t5830.check b/test/files/run/t5830.check
index 675387eb8e..9260854676 100644
--- a/test/files/run/t5830.check
+++ b/test/files/run/t5830.check
@@ -1,5 +1,6 @@
 a with oef
 a with oef
+a with oef
 a
 def with oef
 def
diff --git a/test/files/run/t5830.scala b/test/files/run/t5830.scala
index 5d808bfa28..03b9c540e0 100644
--- a/test/files/run/t5830.scala
+++ b/test/files/run/t5830.scala
@@ -1,12 +1,11 @@
 import scala.annotation.switch
 
 object Test extends App {
-  // TODO: should not emit a switch
-  // def noSwitch(ch: Char, eof: Boolean) = (ch: @switch) match {
-  //   case 'a' if eof => println("a with oef") // then branch
-  // }
+  def noSwitch(ch: Char, eof: Boolean) = ch match {
+    case 'a' if eof => println("a with oef") // then branch
+  }
 
-  def onlyThen(ch: Char, eof: Boolean) = (ch: @switch) match {
+  def onlyThen(ch: Char, eof: Boolean) = ch match {
     case 'a' if eof => println("a with oef") // then branch
     case 'c' =>
   }
@@ -18,7 +17,7 @@ object Test extends App {
     case 'c' =>
   }
 
-  def defaultUnguarded(ch: Char, eof: Boolean) = (ch: @switch) match {
+  def defaultUnguarded(ch: Char, eof: Boolean) = ch match {
     case ' ' if eof => println("spacey oef")
     case _ => println("default")
   }
@@ -44,7 +43,7 @@ object Test extends App {
   //   case 'c' =>
   // }
 
-  // noSwitch('a', true)
+  noSwitch('a', true)
   onlyThen('a', true)       // 'a with oef'
   ifThenElse('a', true)     // 'a with oef'
   ifThenElse('a', false)    // 'a'
diff --git a/test/files/run/t5938.scala b/test/files/run/t5938.scala
new file mode 100644
index 0000000000..59a95ac37f
--- /dev/null
+++ b/test/files/run/t5938.scala
@@ -0,0 +1,35 @@
+import scala.tools.partest.DirectTest
+
+object Test extends DirectTest {
+
+  override def extraSettings: String =
+    s"-usejavacp -d ${testOutput.path}"
+
+  override def code = """
+object O extends C {
+  def main(args: Array[String]): Unit = {
+  }
+  // Static forwarder for foo and setter_foo_= added more once in a multi-run compile.
+}
+  """.trim
+
+  override def show(): Unit = {
+    val global = newCompiler()
+    Console.withErr(System.out) {
+      compileString(global)(code)
+      compileString(global)(code)
+      loadClass // was "duplicate name and signature in class X"
+    }
+  }
+
+  def loadClass: Class[_] = {
+    val cl = new java.net.URLClassLoader(Array(testOutput.toFile.toURL));
+    cl.loadClass("O")
+  }
+}
+
+trait T {
+  val foo: String = ""
+}
+class C extends T
+
diff --git a/test/files/run/t6011c.scala b/test/files/run/t6011c.scala
index 0647e3f81a..96a685b9cf 100644
--- a/test/files/run/t6011c.scala
+++ b/test/files/run/t6011c.scala
@@ -6,7 +6,7 @@ object Test extends App {
   // at scala.reflect.internal.SymbolTable.abort(SymbolTable.scala:50)
   // at scala.tools.nsc.Global.abort(Global.scala:249)
   // at scala.tools.nsc.backend.jvm.GenASM$JPlainBuilder$jcode$.emitSWITCH(GenASM.scala:1850)
-  ((1: Byte): @unchecked @annotation.switch) match {
+  ((1: Byte): @unchecked) match {
     case 1 => 2
     case 1 => 3 // crash
   }
diff --git a/test/files/run/t6028.check b/test/files/run/t6028.check
index 55ff42d8d7..edc8b22d6d 100644
--- a/test/files/run/t6028.check
+++ b/test/files/run/t6028.check
@@ -24,7 +24,7 @@ package <empty> {
         (new <$anon: Function0>(T.this, tryyParam, tryyLocal): Function0)
       }
     };
-    @SerialVersionUID(0) final <synthetic> class $anonfun$foo$1 extends scala.runtime.AbstractFunction0$mcI$sp with Serializable {
+    @SerialVersionUID(value = 0) final <synthetic> class $anonfun$foo$1 extends scala.runtime.AbstractFunction0$mcI$sp with Serializable {
       def <init>($outer: T, methodParam$1: Int, methodLocal$1: Int): <$anon: Function0> = {
         $anonfun$foo$1.super.<init>();
         ()
@@ -60,7 +60,7 @@ package <empty> {
       };
       scala.this.Predef.print(scala.Int.box(barParam$1))
     };
-    @SerialVersionUID(0) final <synthetic> class $anonfun$tryy$1 extends scala.runtime.AbstractFunction0$mcV$sp with Serializable {
+    @SerialVersionUID(value = 0) final <synthetic> class $anonfun$tryy$1 extends scala.runtime.AbstractFunction0$mcV$sp with Serializable {
       def <init>($outer: T, tryyParam$1: Int, tryyLocal$1: runtime.IntRef): <$anon: Function0> = {
         $anonfun$tryy$1.super.<init>();
         ()
diff --git a/test/files/run/t6114.scala b/test/files/run/t6114.scala
index cb880ece00..8ad02d5bb2 100644
--- a/test/files/run/t6114.scala
+++ b/test/files/run/t6114.scala
@@ -51,7 +51,7 @@ object Test extends App {
     val next = list.asScala ++ List(4,5,6)
     assert(next != list.asScala)
 
-    // Note: Clone is hidden at this level, so no overriden cloning.
+    // Note: Clone is hidden at this level, so no overridden cloning.
   }
 
   testList
diff --git a/test/files/run/t6260c.check b/test/files/run/t6260c.check
index 1a57f2d741..78e9b27371 100644
--- a/test/files/run/t6260c.check
+++ b/test/files/run/t6260c.check
@@ -1,5 +1,9 @@
 f(C@2e)
 
+#partest !-Ydelambdafy:method
 Test$$anonfun$$apply
+#partest -Ydelambdafy:method
+Test$lambda$1$$apply
+#partest
 apply
 g(C@2e)
diff --git a/test/files/run/t6440.check b/test/files/run/t6440.check
index 2358f08fcc..4d8618182b 100644
--- a/test/files/run/t6440.check
+++ b/test/files/run/t6440.check
@@ -1,5 +1,4 @@
-pos: source-newSource1.scala,line-9,offset=109 missing or invalid dependency detected while loading class file 'U.class'.
-Could not access term pack1 in package <root>,
-because it (or its dependencies) are missing. Check your build definition for
-missing or conflicting dependencies. (Re-run with `-Ylog-classpath` to see the problematic classpath.)
-A full rebuild may help if 'U.class' was compiled against an incompatible version of <root>. ERROR
+pos: source-newSource1.scala,line-9,offset=109 reference to U is ambiguous;
+it is imported twice in the same scope by
+import pack2._
+and import X._ ERROR
diff --git a/test/files/run/t6440.scala b/test/files/run/t6440.scala
index 5a3a4150d9..94eda3642e 100644
--- a/test/files/run/t6440.scala
+++ b/test/files/run/t6440.scala
@@ -41,7 +41,7 @@ object Test extends StoreReporterDirectTest {
     assert(tClass.delete())
     assert(pack1.delete())
 
-    // bad symbolic reference error expected (but no stack trace!)
+    // should report ambiguous import, despite the fact that a parent of pack2.U is absent
     compileCode(app)
     println(filteredInfos.mkString("\n"))
   }
diff --git a/test/files/run/t6502.check b/test/files/run/t6502.check
new file mode 100644
index 0000000000..95d36ee221
--- /dev/null
+++ b/test/files/run/t6502.check
@@ -0,0 +1,8 @@
+test1 res1: true
+test1 res2: true
+test2 res1: true
+test2 res2: true
+test3 res1: true
+test3 res2: true
+test4 res1: true
+test4 res2: true
diff --git a/test/files/run/t6502.scala b/test/files/run/t6502.scala
new file mode 100644
index 0000000000..4ce034a482
--- /dev/null
+++ b/test/files/run/t6502.scala
@@ -0,0 +1,116 @@
+import scala.tools.nsc.Settings
+import scala.tools.nsc.interpreter.ILoop
+import scala.tools.nsc.settings.ClassPathRepresentationType
+import scala.tools.partest._
+
+object Test extends StoreReporterDirectTest {
+  def code = ???
+
+  def compileCode(code: String, jarFileName: String) = {
+    val classpath = List(sys.props("partest.lib"), testOutput.path) mkString sys.props("path.separator")
+    compileString(newCompiler("-cp", classpath, "-d", s"${testOutput.path}/$jarFileName"))(code)
+  }
+
+  // TODO flat classpath doesn't support the classpath invalidation yet so we force using the recursive one
+  // it's the only test which needed such a workaround
+  override def settings = {
+    val settings = new Settings
+    settings.YclasspathImpl.value = ClassPathRepresentationType.Recursive
+    settings
+  }
+
+  def app1 = """
+    package test
+
+    object Test extends App {
+      def test(): Unit = {
+        println("testing...")
+      }
+    }"""
+
+  def app2 = """
+    package test
+
+    object Test extends App {
+      def test(): Unit = {
+        println("testing differently...")
+      }
+    }"""
+
+  def app3 = """
+    package test
+
+    object Test3 extends App {
+      def test(): Unit = {
+        println("new object in existing package")
+      }
+    }"""
+
+  def test1(): Unit = {
+    val jar = "test1.jar"
+    compileCode(app1, jar)
+
+    val codeToRun = toCodeInSeparateLines(s":require ${testOutput.path}/$jar", "test.Test.test()")
+    val output = ILoop.run(codeToRun, settings)
+    val lines  = output.split("\n")
+    val res1   = lines(4).contains("Added") && lines(4).contains("test1.jar")
+    val res2   = lines(lines.length-3).contains("testing...")
+
+    println(s"test1 res1: $res1")
+    println(s"test1 res2: $res2")
+  }
+
+  def test2(): Unit = {
+    // should reject jars with conflicting entries
+    val jar1 = "test1.jar"
+    val jar2 = "test2.jar"
+    compileCode(app2, jar2)
+
+    val codeToRun = toCodeInSeparateLines(s":require ${testOutput.path}/$jar1", s":require ${testOutput.path}/$jar2")
+    val output = ILoop.run(codeToRun, settings)
+    val lines  = output.split("\n")
+    val res1   = lines(4).contains("Added") && lines(4).contains("test1.jar")
+    val res2   = lines(lines.length-3).contains("test2.jar") && lines(lines.length-3).contains("existing classpath entries conflict")
+
+    println(s"test2 res1: $res1")
+    println(s"test2 res2: $res2")
+  }
+
+  def test3(): Unit = {
+    // should accept jars with overlapping packages, but no conflicts
+    val jar1 = "test1.jar"
+    val jar3 = "test3.jar"
+    compileCode(app3, jar3)
+
+    val codeToRun = toCodeInSeparateLines(s":require ${testOutput.path}/$jar1", s":require ${testOutput.path}/$jar3", "test.Test3.test()")
+    val output = ILoop.run(codeToRun, settings)
+    val lines  = output.split("\n")
+    val res1   = lines(4).contains("Added") && lines(4).contains("test1.jar")
+    val res2   = lines(lines.length-3).contains("new object in existing package")
+
+    println(s"test3 res1: $res1")
+    println(s"test3 res2: $res2")
+  }
+
+  def test4(): Unit = {
+    // twice the same jar should be rejected
+    val jar1   = "test1.jar"
+    val codeToRun = toCodeInSeparateLines(s":require ${testOutput.path}/$jar1", s":require ${testOutput.path}/$jar1")
+    val output = ILoop.run(codeToRun, settings)
+    val lines  = output.split("\n")
+    val res1   = lines(4).contains("Added") && lines(4).contains("test1.jar")
+    val res2   = lines(lines.length-3).contains("test1.jar") && lines(lines.length-3).contains("existing classpath entries conflict")
+
+    println(s"test4 res1: $res1")
+    println(s"test4 res2: $res2")
+  }
+
+  def show(): Unit = {
+    test1()
+    test2()
+    test3()
+    test4()
+  }
+
+  def toCodeInSeparateLines(lines: String*): String = lines.map(_ + "\n").mkString
+}
diff --git a/test/files/run/t6541-option.scala b/test/files/run/t6541-option.scala
new file mode 100644
index 0000000000..2c10c9e09d
--- /dev/null
+++ b/test/files/run/t6541-option.scala
@@ -0,0 +1,19 @@
+import scala.tools.partest.ReplTest
+
+object Test extends ReplTest {
+  def code = """
+:setting -Xsource:2.12
+case class C12(clazz: Class[_])
+val o: Option[Class[T] forSome { type T}] = C12.unapply(C12(classOf[String]))
+
+:setting -Xsource:2.11
+import scala.language.existentials
+case class C11(clazz: Class[_])
+val o: Option[Class[T]] forSome { type T } = C11.unapply(C11(classOf[String]))
+  """
+
+  override def show() = {
+    val r = eval().mkString("\n")
+    assert(!(r.contains("warning") || r.contains("error")), r)
+  }
+}
diff --git a/test/files/run/t6541.flags b/test/files/run/t6541.flags
new file mode 100644
index 0000000000..68d0ddfec2
--- /dev/null
+++ b/test/files/run/t6541.flags
@@ -0,0 +1 @@
+-feature -Xfatal-warnings -Xsource:2.12
\ No newline at end of file
diff --git a/test/files/run/t6541.scala b/test/files/run/t6541.scala
new file mode 100644
index 0000000000..f127143691
--- /dev/null
+++ b/test/files/run/t6541.scala
@@ -0,0 +1,25 @@
+class A
+class B[T](x: T)
+case class C(a: A, b: B[_])
+
+case class D(a: A, b: B[_]*)
+
+case class E(c: Class[_])
+
+object Test extends App {
+  def f1(c: C) = c match {
+    case C(a, b) => ()
+  }
+
+  def f2(d: D) = d match {
+    case D(a, b1, b2) => ()
+  }
+
+  def f3(e: E) = e match {
+    case E(c) => ()
+  }
+
+  f1(C(new A, new B(1)))
+  f2(D(new A, new B(1), new B(2)))
+  f3(E(classOf[E]))
+}
diff --git a/test/files/run/t6555.check b/test/files/run/t6555.check
index 9ac115a13f..e3b467ce7c 100644
--- a/test/files/run/t6555.check
+++ b/test/files/run/t6555.check
@@ -6,7 +6,7 @@ package <empty> {
       ()
     };
     private[this] val f: Int => Int = {
-      @SerialVersionUID(0) final <synthetic> class $anonfun extends scala.runtime.AbstractFunction1$mcII$sp with Serializable {
+      @SerialVersionUID(value = 0) final <synthetic> class $anonfun extends scala.runtime.AbstractFunction1$mcII$sp with Serializable {
         def <init>(): <$anon: Int => Int> = {
           $anonfun.super.<init>();
           ()
diff --git a/test/files/run/t6622.check b/test/files/run/t6622.check
new file mode 100644
index 0000000000..5d006d88e6
--- /dev/null
+++ b/test/files/run/t6622.check
@@ -0,0 +1,10 @@
+ O1.resultVal isMemberClass = false, null
+class A$1
+ O1.resultDef isMemberClass = false, public void O1$.resultDef()
+class A$2
+ C2.resultVal isMemberClass = false, null
+class $B$1
+ O3.resultDef isMemberClass = false, public void O3$.resultDef()
+class C$1
+ O4.resultDefDefault isMemberClass = false, public java.lang.Object O4$.resultDefDefault$default$1()
+class C$2
diff --git a/test/files/run/t6622.scala b/test/files/run/t6622.scala
new file mode 100644
index 0000000000..de8ffa01bf
--- /dev/null
+++ b/test/files/run/t6622.scala
@@ -0,0 +1,50 @@
+import Test.check
+
+object O1 {
+  lazy val resultVal = {
+    class A
+    check("O1.resultVal", classOf[A])
+  }
+
+  def resultDef = {
+    class A
+    check("O1.resultDef", classOf[A])
+  }
+}
+
+class C2 {
+  val resultVal = {
+    val tmp = {
+      class B
+      check("C2.resultVal", classOf[B])
+    }
+  }
+}
+
+object O3 {
+  def resultDef = {
+    class C
+    check("O3.resultDef", classOf[C])
+  }
+}
+
+object O4 {
+  def resultDefDefault(a: Any = {
+    class C
+    check("O4.resultDefDefault", classOf[C])
+  }) = ();
+}
+
+
+object Test extends App {
+  def check(desc: String, clazz: Class[_]) {
+    println(s" $desc isMemberClass = ${clazz.isMemberClass}, ${clazz.getEnclosingMethod}")
+    println(reflect.runtime.currentMirror.classSymbol(clazz))
+  }
+
+  O1.resultVal
+  O1.resultDef
+  new C2().resultVal
+  O3.resultDef
+  O4.resultDefDefault()
+}
diff --git a/test/files/run/t6669.scala b/test/files/run/t6669.scala
index e18f2514a9..27c4970d60 100644
--- a/test/files/run/t6669.scala
+++ b/test/files/run/t6669.scala
@@ -1,4 +1,5 @@
 import java.io.{ByteArrayOutputStream, PrintStream}
+import scala.reflect.io.File
 
 object Test extends App {
   val baos = new ByteArrayOutputStream()
@@ -9,9 +10,11 @@ object Test extends App {
     scala.tools.scalap.Main.main(Array("-verbose", "java.lang.Object"))
   }
 
+  val currentLocationCpFragment = File.pathSeparator + "."
+
   // now make sure we saw the '.' in the classpath
   val msg1 = baos.toString()
-  assert(msg1 contains "directory classpath: .", s"Did not see '.' in the default class path. Full results were:\n$msg1")
+  assert(msg1 contains currentLocationCpFragment, s"Did not see '.' in the default class path. Full results were:\n$msg1")
 
   // then test again with a user specified classpath
   baos.reset
@@ -22,5 +25,5 @@ object Test extends App {
 
   // now make sure we did not see the '.' in the classpath
   val msg2 = baos.toString()
-  assert(!(msg2 contains "directory classpath: ."), s"Did saw '.' in the user specified class path. Full results were:\n$msg2")
+  assert(!(msg2 contains currentLocationCpFragment), s"Did saw '.' in the user specified class path. Full results were:\n$msg2")
 }
diff --git a/test/files/run/t7019.scala b/test/files/run/t7019.scala
new file mode 100644
index 0000000000..5dcc09d2b6
--- /dev/null
+++ b/test/files/run/t7019.scala
@@ -0,0 +1,10 @@
+final class Foo(val i: Int) extends AnyVal {
+  def foo() = go(i)
+  private[this] def go(i: Int) = i * 2
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    assert(new Foo(1).foo() == 2)
+  }
+}
diff --git a/test/files/run/t7407.flags b/test/files/run/t7407.flags
index c8547a27dc..be4ef0798a 100644
--- a/test/files/run/t7407.flags
+++ b/test/files/run/t7407.flags
@@ -1 +1 @@
--Ynooptimise -Ybackend:GenBCode
+-Ynooptimise -Yopt:l:none -Ybackend:GenBCode
diff --git a/test/files/run/t7459a.scala b/test/files/run/t7459a.scala
new file mode 100644
index 0000000000..e9653c6e79
--- /dev/null
+++ b/test/files/run/t7459a.scala
@@ -0,0 +1,14 @@
+class LM {
+  class Node[B1]
+  case class CC(n: LM)
+
+  // crash
+  val f: (LM => Any) = {
+    case tttt =>
+      new tttt.Node[Any]()
+  }
+}
+
+object Test extends App {
+  new LM().f(new LM())
+}
diff --git a/test/files/run/t7459b-optimize.flags b/test/files/run/t7459b-optimize.flags
new file mode 100644
index 0000000000..49d036a887
--- /dev/null
+++ b/test/files/run/t7459b-optimize.flags
@@ -0,0 +1 @@
+-optimize
diff --git a/test/files/run/t7459b-optimize.scala b/test/files/run/t7459b-optimize.scala
new file mode 100644
index 0000000000..605890962c
--- /dev/null
+++ b/test/files/run/t7459b-optimize.scala
@@ -0,0 +1,21 @@
+class LM {
+  class Node[B1]
+
+  // crash
+  val g: (CC => Any) = {
+    case CC(tttt) =>
+      new tttt.Node[Any]()
+  }
+
+  val h: (Some[CC] => Any) = {
+    case Some(CC(tttt)) =>
+      new tttt.Node[Any]()
+  }
+}
+
+object Test extends App {
+  new LM().g(new CC(new LM()))
+  new LM().h(Some(new CC(new LM())))
+}
+case class CC(n: LM)
+
diff --git a/test/files/run/t7459b.scala b/test/files/run/t7459b.scala
new file mode 100644
index 0000000000..605890962c
--- /dev/null
+++ b/test/files/run/t7459b.scala
@@ -0,0 +1,21 @@
+class LM {
+  class Node[B1]
+
+  // crash
+  val g: (CC => Any) = {
+    case CC(tttt) =>
+      new tttt.Node[Any]()
+  }
+
+  val h: (Some[CC] => Any) = {
+    case Some(CC(tttt)) =>
+      new tttt.Node[Any]()
+  }
+}
+
+object Test extends App {
+  new LM().g(new CC(new LM()))
+  new LM().h(Some(new CC(new LM())))
+}
+case class CC(n: LM)
+
diff --git a/test/files/run/t7459c.scala b/test/files/run/t7459c.scala
new file mode 100644
index 0000000000..144c5d793b
--- /dev/null
+++ b/test/files/run/t7459c.scala
@@ -0,0 +1,16 @@
+class LM {
+  class Node[B1]
+
+  // crash
+  val g: (CC => Any) = {
+    case CC(tttt) =>
+      tttt.## // no crash
+      new tttt.Node[Any]()
+  }
+}
+
+object Test extends App {
+  new LM().g(new CC(new LM()))
+}
+case class CC(n: LM)
+
diff --git a/test/files/run/t7459d.scala b/test/files/run/t7459d.scala
new file mode 100644
index 0000000000..3263701f9d
--- /dev/null
+++ b/test/files/run/t7459d.scala
@@ -0,0 +1,15 @@
+class LM {
+  class Node[B1]
+  case class CC(n: LM)
+
+  // crash
+  val f: (LM => Any) = {
+    case tttt =>
+      val uuuu: (tttt.type, Any) = (tttt, 0)
+      new uuuu._1.Node[Any]()
+  }
+}
+
+object Test extends App {
+  new LM().f(new LM())
+}
diff --git a/test/files/run/t7459f.scala b/test/files/run/t7459f.scala
new file mode 100644
index 0000000000..63e2109560
--- /dev/null
+++ b/test/files/run/t7459f.scala
@@ -0,0 +1,12 @@
+object Test extends App {
+  class C
+
+  case class FooSeq(x: Int, y: String, z: C*)
+
+  FooSeq(1, "a", new C()) match {
+    case FooSeq(1, "a", x@_* ) =>
+      //println(x.toList)
+      x.asInstanceOf[x.type]
+      assert(x.isInstanceOf[x.type])
+  }
+}
diff --git a/test/files/run/t7965.scala b/test/files/run/t7965.scala
new file mode 100644
index 0000000000..df80d4b5bb
--- /dev/null
+++ b/test/files/run/t7965.scala
@@ -0,0 +1,54 @@
+// Test that scala doesn't apply boxing or varargs conversions to the
+// @PolymorphicSignature magical methods, MethodHandle#{invoke, invokeExact}
+object Test {
+  val code = """
+
+object O {
+  private def foo = "foo"
+  private def bar(x: Int): Int = -x
+  private def baz(x: Box): Unit = x.a = "present"
+  val lookup = java.lang.invoke.MethodHandles.lookup
+}
+
+import java.lang.invoke._
+class Box(var a: Any)
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    def lookup(name: String, params: Array[Class[_]], ret: Class[_]) = {
+      val mt = MethodType.methodType(ret, params)
+      O.lookup.findVirtual(O.getClass, name, mt)
+    }
+    val fooResult = (lookup("foo", Array(), classOf[String]).invokeExact(O): Int)
+    assert(fooResult == "foo")
+
+    val barResult = (lookup("bar", Array(classOf[Int]), classOf[Int]).invokeExact(O, 42): Int)
+    assert(barResult == -42)
+
+    val box = new Box(null)
+    (lookup("baz", Array(classOf[Box]), Void.TYPE).invokeExact(O, box) : Unit)
+    assert(box.a == "present")
+
+    // Note: Application in statement position in a block in Java also infers return type of Unit,
+    // but we don't support that, ascribe the type to Unit as above.
+    // as done in Java.
+    // lookup("baz", Array(classOf[Box]), Void.TYPE).invokeExact(O, box)
+    ()
+  }
+}
+
+"""
+  def main(args: Array[String]): Unit = {
+    if (util.Properties.isJavaAtLeast("1.7")) test()
+  }
+
+  def test() {
+    import scala.reflect.runtime._
+    import scala.tools.reflect.ToolBox
+
+    val m = currentMirror
+    val tb = m.mkToolBox()
+    import tb._
+    eval(parse(code))
+  }
+}
diff --git a/test/files/run/t8087.scala b/test/files/run/t8087.scala
new file mode 100644
index 0000000000..6047211756
--- /dev/null
+++ b/test/files/run/t8087.scala
@@ -0,0 +1,12 @@
+trait Foo {
+  @volatile private[this] var x: String = ""
+  @volatile private var y: String = ""
+}
+
+class Bar extends Foo
+
+object Test extends App {
+  classOf[Bar].getDeclaredFields.foreach(f => {
+    assert(java.lang.reflect.Modifier.isVolatile(f.getModifiers), f.getName)
+  })
+}
diff --git a/test/files/run/t8253.check b/test/files/run/t8253.check
new file mode 100644
index 0000000000..0b4cb2d1f7
--- /dev/null
+++ b/test/files/run/t8253.check
@@ -0,0 +1,40 @@
+
+<sample xmlns='ns1'/>
+{
+  var $tmpscope: _root_.scala.xml.NamespaceBinding = $scope;
+  $tmpscope = new _root_.scala.xml.NamespaceBinding(null, "ns1", $tmpscope);
+  {
+    val $scope: _root_.scala.xml.NamespaceBinding = $tmpscope;
+    new _root_.scala.xml.Elem(null, "sample", _root_.scala.xml.Null, $scope, true)
+  }
+}
+
+<sample xmlns={identity(ns1)}/>
+{
+  var $tmpscope: _root_.scala.xml.NamespaceBinding = $scope;
+  $tmpscope = new _root_.scala.xml.NamespaceBinding(null, ns1, $tmpscope);
+  {
+    val $scope: _root_.scala.xml.NamespaceBinding = $tmpscope;
+    new _root_.scala.xml.Elem(null, "sample", _root_.scala.xml.Null, $scope, true)
+  }
+}
+
+<sample xmlns:foo='ns1'/>
+{
+  var $tmpscope: _root_.scala.xml.NamespaceBinding = $scope;
+  $tmpscope = new _root_.scala.xml.NamespaceBinding("foo", "ns1", $tmpscope);
+  {
+    val $scope: _root_.scala.xml.NamespaceBinding = $tmpscope;
+    new _root_.scala.xml.Elem(null, "sample", _root_.scala.xml.Null, $scope, true)
+  }
+}
+
+<sample xmlns:foo={identity(ns1)}/>
+{
+  var $tmpscope: _root_.scala.xml.NamespaceBinding = $scope;
+  $tmpscope = new _root_.scala.xml.NamespaceBinding("foo", ns1, $tmpscope);
+  {
+    val $scope: _root_.scala.xml.NamespaceBinding = $tmpscope;
+    new _root_.scala.xml.Elem(null, "sample", _root_.scala.xml.Null, $scope, true)
+  }
+}
diff --git a/test/files/run/t8253.scala b/test/files/run/t8253.scala
new file mode 100644
index 0000000000..a00d8b91a4
--- /dev/null
+++ b/test/files/run/t8253.scala
@@ -0,0 +1,14 @@
+object Test extends App {
+  import reflect.runtime.universe._ // not using the XML library in compiler tests
+
+  def show(code: String, t: Tree) = println(s"\n$code\n$t")
+
+  val ns1 = "ns1"
+  show("<sample xmlns='ns1'/>", q"<sample xmlns='ns1'/>")
+  show("<sample xmlns={identity(ns1)}/>", q"<sample xmlns={ns1}/>")
+  show("<sample xmlns:foo='ns1'/>", q"<sample xmlns:foo='ns1'/>")
+  show("<sample xmlns:foo={identity(ns1)}/>", q"<sample xmlns:foo={ns1}/>")
+
+  // `identity(foo)` used to match the overly permissive match in SymbolXMLBuilder
+  // which was intended to more specifically match `_root_.scala.xml.Text(...)`
+}
diff --git a/test/files/run/t8445.check b/test/files/run/t8445.check
new file mode 100644
index 0000000000..41fd6d3ed1
--- /dev/null
+++ b/test/files/run/t8445.check
@@ -0,0 +1 @@
+warning: there was one feature warning; re-run with -feature for details
diff --git a/test/files/run/t8445.scala b/test/files/run/t8445.scala
new file mode 100644
index 0000000000..ed196b62a2
--- /dev/null
+++ b/test/files/run/t8445.scala
@@ -0,0 +1,11 @@
+object X {
+  class Y
+  def y = new Y {
+    class Z
+    def z = classOf[Z]
+  }
+}
+
+object Test extends App {
+  assert(X.y.z.getEnclosingClass.getName == "X$$anon$1")
+}
diff --git a/test/files/run/t8502.scala b/test/files/run/t8502.scala
new file mode 100644
index 0000000000..903e573711
--- /dev/null
+++ b/test/files/run/t8502.scala
@@ -0,0 +1,41 @@
+import scala.tools.partest._
+import java.io.File
+
+object Test extends StoreReporterDirectTest {
+  def code = ???
+
+  def compileCode(code: String) = {
+    val classpath = List(sys.props("partest.lib"), testOutput.path) mkString sys.props("path.separator")
+    compileString(newCompiler("-cp", classpath, "-d", testOutput.path))(code)
+  }
+
+  def show(): Unit = {
+    compileCode("""
+      object U {
+        def foo(log: vanishing.Vanishing) = ()
+      }
+
+      package vanishing {
+        class Vanishing
+      }
+      """)
+    assert(filteredInfos.isEmpty, filteredInfos)
+    deletePackage("vanishing")
+    compileCode("""
+      class Test {
+        U
+      }
+    """)
+    assert(storeReporter.infos.isEmpty, storeReporter.infos.mkString("\n")) // Included a MissingRequirementError before.
+  }
+
+  def deletePackage(name: String) {
+    val directory = new File(testOutput.path, name)
+    for (f <- directory.listFiles()) {
+      assert(f.getName.endsWith(".class"))
+      assert(f.delete())
+    }
+    assert(directory.listFiles().isEmpty)
+    assert(directory.delete())
+  }
+}
diff --git a/test/files/run/t8549.scala b/test/files/run/t8549.scala
index d3355208fa..cb254e3810 100644
--- a/test/files/run/t8549.scala
+++ b/test/files/run/t8549.scala
@@ -79,9 +79,12 @@ object Test extends App {
     }
   }
 
-  // Generated on 20140505-14:47:14 with Scala version 2.11.1-20140505-142300-e8562571d2)
+  // Generated on 20141010-14:01:28 with Scala version 2.11.2)
   overwrite.foreach(updateComment)
 
+  check(Some(1))("rO0ABXNyAApzY2FsYS5Tb21lESLyaV6hi3QCAAFMAAF4dAASTGphdmEvbGFuZy9PYmplY3Q7eHIADHNjYWxhLk9wdGlvbv5pN/3bDmZ0AgAAeHBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAQ==")
+  check(None)("rO0ABXNyAAtzY2FsYS5Ob25lJEZQJPZTypSsAgAAeHIADHNjYWxhLk9wdGlvbv5pN/3bDmZ0AgAAeHA=")
+
   check(List(1, 2, 3))( "rO0ABXNyADJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAABAwAAeHBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJzcQB+AAIAAAADc3IALHNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3RTZXJpYWxpemVFbmQkilxjW/dTC20CAAB4cHg=")
   check(Nil)(           "rO0ABXNyADJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAABAwAAeHBzcgAsc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuTGlzdFNlcmlhbGl6ZUVuZCSKXGNb91MLbQIAAHhweA==")
 
diff --git a/test/files/run/t8601-closure-elim.flags b/test/files/run/t8601-closure-elim.flags
index 49d036a887..2b5fd8a7b2 100644
--- a/test/files/run/t8601-closure-elim.flags
+++ b/test/files/run/t8601-closure-elim.flags
@@ -1 +1 @@
--optimize
+-optimize -Ydelambdafy:inline
diff --git a/test/files/run/t8843-repl-xlat.scala b/test/files/run/t8843-repl-xlat.scala
new file mode 100644
index 0000000000..6426dbe7d4
--- /dev/null
+++ b/test/files/run/t8843-repl-xlat.scala
@@ -0,0 +1,33 @@
+
+import scala.tools.partest.SessionTest
+
+// Handy hamburger helper for repl resources
+object Test extends SessionTest {
+  def session =
+"""Type in expressions to have them evaluated.
+Type :help for more information.
+
+scala> $intp.isettings.unwrapStrings = false
+$intp.isettings.unwrapStrings: Boolean = false
+
+scala> class Bippy
+defined class Bippy
+
+scala> $intp.classLoader getResource "Bippy.class"
+res0: java.net.URL = memory:(memory)/$line4/$read$$iw$$iw$Bippy.class
+
+scala> ($intp.classLoader getResources "Bippy.class").nextElement
+res1: java.net.URL = memory:(memory)/$line4/$read$$iw$$iw$Bippy.class
+
+scala> ($intp.classLoader classBytes "Bippy").nonEmpty
+res2: Boolean = true
+
+scala> ($intp.classLoader classAsStream "Bippy") != null
+res3: Boolean = true
+
+scala> $intp.classLoader getResource "Bippy"
+res4: java.net.URL = null
+
+scala> :quit"""
+}
+
diff --git a/test/files/run/t8845.flags b/test/files/run/t8845.flags
new file mode 100644
index 0000000000..aada25f80d
--- /dev/null
+++ b/test/files/run/t8845.flags
@@ -0,0 +1 @@
+-Ybackend:GenBCode -Ynooptimize
diff --git a/test/files/run/t8845.scala b/test/files/run/t8845.scala
new file mode 100644
index 0000000000..8ccdbdadc7
--- /dev/null
+++ b/test/files/run/t8845.scala
@@ -0,0 +1,17 @@
+// crashes compiler under GenASM, works under GenBCode.
+object Interpreter {
+  def mkDataProp(i: Int) = i
+  def break(n: Int): Unit =
+    try {
+      n match {
+        case _ =>
+          val newDesc = mkDataProp(n)
+          n match { case _ => return }
+      }
+    } catch { case e: Throwable => }
+    finally { }
+}
+
+object Test extends App {
+  Interpreter.break(0)
+}
diff --git a/test/files/run/t8888.flags b/test/files/run/t8888.flags
new file mode 100644
index 0000000000..48b438ddf8
--- /dev/null
+++ b/test/files/run/t8888.flags
@@ -0,0 +1 @@
+-Ydelambdafy:method
diff --git a/test/files/run/t8888.scala b/test/files/run/t8888.scala
new file mode 100644
index 0000000000..36cc1ddf3e
--- /dev/null
+++ b/test/files/run/t8888.scala
@@ -0,0 +1,12 @@
+class C {
+  final def resume: Unit = (this: Any) match {
+    case x : C => (x: Any) match {
+      case y : C =>
+        () => (x, y) // used to trigger a ClassFormatError under -Ydelambdafy:method
+    }
+  }
+}
+
+object Test extends App {
+  new C().resume
+}
diff --git a/test/files/run/t8893.scala b/test/files/run/t8893.scala
new file mode 100644
index 0000000000..6fef8ae912
--- /dev/null
+++ b/test/files/run/t8893.scala
@@ -0,0 +1,40 @@
+import annotation.tailrec
+
+object Test {
+  def a(): Option[String] = Some("a")
+
+  def test1: Any = {
+    a() match {
+      case Some(b1) =>
+        a() match {
+          case Some(b2) =>
+            @tailrec
+            def tick(i: Int): Unit = if (i < 0) () else tick(i - 1)
+            tick(10000000) // testing that this doesn't SOE
+          case None => None
+        }
+      case None => None
+    }
+  }
+
+  def test2: Any = {
+    a() match {
+      case Some(b1) =>
+        a() match {
+          case Some(b2) =>
+            @tailrec
+            def tick(i: Int): Unit = if (i < 0) () else tick(i - 1)
+            tick(10000000) // testing that this doesn't SOE
+          case None => test1
+        }
+      case None =>
+        test1 // not a tail call
+        test1
+    }
+  }
+
+  def main(args: Array[String]) {
+    test1
+    test2
+  }
+}
diff --git a/test/files/run/t8893b.scala b/test/files/run/t8893b.scala
new file mode 100644
index 0000000000..19120871aa
--- /dev/null
+++ b/test/files/run/t8893b.scala
@@ -0,0 +1,15 @@
+// Testing that recursive calls in tail positions are replaced with
+// jumps, even though the method contains recursive calls outside
+// of the tail position.
+object Test {
+  def tick(i : Int): Unit =
+    if (i == 0) ()
+    else if (i == 42) {
+      tick(0) /*not in tail posiiton*/
+      tick(i - 1)
+    } else tick(i - 1)
+
+  def main(args: Array[String]): Unit = {
+    tick(1000000)
+  }
+}
diff --git a/test/files/run/t8907.scala b/test/files/run/t8907.scala
new file mode 100644
index 0000000000..7952ac82d9
--- /dev/null
+++ b/test/files/run/t8907.scala
@@ -0,0 +1,39 @@
+import scala.tools.partest._
+import java.io.File
+
+object Test extends StoreReporterDirectTest {
+  def code = ???
+
+  def compileCode(code: String) = {
+    val classpath = List(sys.props("partest.lib"), testOutput.path) mkString sys.props("path.separator")
+    compileString(newCompiler("-cp", classpath, "-d", testOutput.path))(code)
+  }
+
+  def show(): Unit = {
+    compileCode("""
+      class C { class Inner }
+
+      class D {
+        object O {
+          def foo(c: C)(i: c.Inner): c.Inner = ???
+        }
+      }
+      """)
+    assert(filteredInfos.isEmpty, filteredInfos)
+    deleteClass("C")
+    compileCode("""
+      class E {
+        def foo = {
+          (null: D).toString
+        }
+      }
+    """)
+    assert(storeReporter.infos.isEmpty, storeReporter.infos.mkString("\n")) // Included a MissingRequirementError before.
+  }
+
+  def deleteClass(name: String) {
+    val classFile = new File(testOutput.path, name + ".class")
+    assert(classFile.exists)
+    assert(classFile.delete())  
+  }
+}
diff --git a/test/files/run/t8925.check b/test/files/run/t8925.check
new file mode 100644
index 0000000000..112e7005df
--- /dev/null
+++ b/test/files/run/t8925.check
@@ -0,0 +1,2 @@
+bar
+abcd
diff --git a/test/files/run/t8925.flags b/test/files/run/t8925.flags
new file mode 100644
index 0000000000..be4ef0798a
--- /dev/null
+++ b/test/files/run/t8925.flags
@@ -0,0 +1 @@
+-Ynooptimise -Yopt:l:none -Ybackend:GenBCode
diff --git a/test/files/run/t8925.scala b/test/files/run/t8925.scala
new file mode 100644
index 0000000000..33f4505f03
--- /dev/null
+++ b/test/files/run/t8925.scala
@@ -0,0 +1,31 @@
+object Ex {
+  def unapply(t: Throwable): Option[Throwable] = Some(t)
+}
+
+class A {
+  var x = ""
+
+  def bar =
+    try {
+      "bar"
+    } finally {
+      try {
+        x += "a"
+      } finally {
+        x += "b"
+        try {
+          x += "c"
+          throw null
+        } catch {
+          case Ex(_) =>
+            x += "d"
+        }
+      }
+    }
+}
+
+object Test extends App {
+  val a = new A
+  println(a.bar)
+  println(a.x)
+}
diff --git a/test/files/run/t8931.check b/test/files/run/t8931.check
new file mode 100644
index 0000000000..d08546b5a9
--- /dev/null
+++ b/test/files/run/t8931.check
@@ -0,0 +1 @@
+List(interface B)
diff --git a/test/files/run/t8931.scala b/test/files/run/t8931.scala
new file mode 100644
index 0000000000..11718471bc
--- /dev/null
+++ b/test/files/run/t8931.scala
@@ -0,0 +1,15 @@
+
+trait A
+
+trait B extends A
+
+class C extends A with B
+
+object Test extends App {
+  val c = classOf[C]
+
+  println(c.getGenericInterfaces.toList)
+
+  assert(c.getGenericInterfaces.length == c.getInterfaces.length,
+    s"mismatch between ${c.getGenericInterfaces} and ${c.getInterfaces}")
+}
diff --git a/test/files/run/t8933.check b/test/files/run/t8933.check
new file mode 100644
index 0000000000..d5ef468b98
--- /dev/null
+++ b/test/files/run/t8933.check
@@ -0,0 +1 @@
+'traitSymbol
diff --git a/test/files/run/t8933/A_1.scala b/test/files/run/t8933/A_1.scala
new file mode 100644
index 0000000000..996e3b4a2c
--- /dev/null
+++ b/test/files/run/t8933/A_1.scala
@@ -0,0 +1,6 @@
+class MotherClass
+
+trait MixinWithSymbol {
+  self: MotherClass =>
+  def symbolFromTrait: Symbol = 'traitSymbol
+}
diff --git a/test/files/run/t8933/Test_2.scala b/test/files/run/t8933/Test_2.scala
new file mode 100644
index 0000000000..c506a7c51f
--- /dev/null
+++ b/test/files/run/t8933/Test_2.scala
@@ -0,0 +1,10 @@
+class MotherClass extends MixinWithSymbol {
+  val classSymbol = 'classSymbol
+}
+
+object Test {
+  def main(args: Array[String]) {
+    val symbol = (new MotherClass).symbolFromTrait
+    println(symbol)
+  }
+}
diff --git a/test/files/run/t8933b/A.scala b/test/files/run/t8933b/A.scala
new file mode 100644
index 0000000000..d25d893c6f
--- /dev/null
+++ b/test/files/run/t8933b/A.scala
@@ -0,0 +1,4 @@
+trait MixinWithSymbol {
+  self: MotherClass =>
+  def symbolFromTrait: Any = 'traitSymbol
+}
diff --git a/test/files/run/t8933b/Test.scala b/test/files/run/t8933b/Test.scala
new file mode 100644
index 0000000000..46eedd660f
--- /dev/null
+++ b/test/files/run/t8933b/Test.scala
@@ -0,0 +1,9 @@
+class MotherClass extends MixinWithSymbol {
+  def foo = 'sym1
+}
+
+object Test {
+  def main(args: Array[String]) {
+    (new MotherClass).symbolFromTrait
+  }
+}
diff --git a/test/files/run/t8933c.scala b/test/files/run/t8933c.scala
new file mode 100644
index 0000000000..22011bc323
--- /dev/null
+++ b/test/files/run/t8933c.scala
@@ -0,0 +1,14 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    try {    
+      {throw T; Symbol}.apply("a")
+      assert(false, "exception not thrown")
+    } catch {
+      case T => // ok
+      case t: Throwable =>
+        assert(false, "wrong not thrown: " + t)
+    }
+  }
+}
+
+object T extends Throwable
diff --git a/test/files/run/t8960.scala b/test/files/run/t8960.scala
new file mode 100644
index 0000000000..a58ac53d33
--- /dev/null
+++ b/test/files/run/t8960.scala
@@ -0,0 +1,72 @@
+object Test extends App {
+  def test(o: AnyRef, sp: Boolean = false) = {
+    val isSpecialized      = o.getClass.getSuperclass.getName contains "$sp"
+    val isDelambdafyMethod = o.getClass.getName contains "$lambda$"
+    assert(
+      // delambdafy:method doesn't currently emit specialized anonymous function classes
+      if (sp) (isSpecialized || isDelambdafyMethod) else !isSpecialized,
+      o.getClass.getName)
+
+    val Some(f) = o.getClass.getDeclaredFields.find(_.getName == "serialVersionUID")
+    assert(f.getLong(null) == 0l)
+  }
+
+  test(() => (), sp = true)
+  test(() => 1,  sp = true)
+  test(() => "")
+
+  test((x: Int) => x, sp = true)
+  test((x: Boolean) => x)
+  test((x: Int) => "")
+
+  test((x1: Int, x2: Int) => 0d, sp = true)
+  test((x1: Int, x2: AnyRef) => 0d)
+  test((x1: Any, x2: Any) => x1)
+
+  // scala> println((for (i <- 3 to 22) yield (for (j <- 1 to i) yield s"x$j: Int").mkString("  test((", ", ", ") => x1)")).mkString("\n"))
+
+  test((x1: Int, x2: Int, x3: Int) => x1)
+  test((x1: Int, x2: Int, x3: Int, x4: Int) => x1)
+  test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int) => x1)
+  test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int) => x1)
+  test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int) => x1)
+  test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int) => x1)
+  test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int) => x1)
+  test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int) => x1)
+  test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int) => x1)
+  test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int) => x1)
+  test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int) => x1)
+  test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int) => x1)
+  test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int) => x1)
+  test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int) => x1)
+  test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int) => x1)
+  test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int) => x1)
+  test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int, x19: Int) => x1)
+  test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int, x19: Int, x20: Int) => x1)
+  test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int, x19: Int, x20: Int, x21: Int) => x1)
+  test((x1: Int, x2: Int, x3: Int, x4: Int, x5: Int, x6: Int, x7: Int, x8: Int, x9: Int, x10: Int, x11: Int, x12: Int, x13: Int, x14: Int, x15: Int, x16: Int, x17: Int, x18: Int, x19: Int, x20: Int, x21: Int, x22: Int) => x1)
+
+  test({
+    case x: Int => x
+  }: PartialFunction[Int, Int], sp = true)
+
+  test({
+    case x: Int => x
+  }: PartialFunction[Any, Any])
+
+  test({
+    case x: Int => ()
+  }: PartialFunction[Int, Unit], sp = true)
+
+  test({
+    case x: String => 1
+  }: PartialFunction[String, Int])
+
+  test({
+    case x: String => ()
+  }: PartialFunction[String, Unit])
+
+  test({
+    case x: String => x
+  }: PartialFunction[String, String])
+}
diff --git a/test/files/run/t9003.flags b/test/files/run/t9003.flags
new file mode 100644
index 0000000000..49d036a887
--- /dev/null
+++ b/test/files/run/t9003.flags
@@ -0,0 +1 @@
+-optimize
diff --git a/test/files/run/t9003.scala b/test/files/run/t9003.scala
new file mode 100644
index 0000000000..4f24712201
--- /dev/null
+++ b/test/files/run/t9003.scala
@@ -0,0 +1,71 @@
+object Single {
+  var i = 0
+  def isEmpty = false
+  def get = i
+  def unapply(a: Single.type) = this
+}
+
+object Product {
+  var i = 0
+  def _1: Int = i
+  def _2: String = ???
+  def productArity = 2
+  def unapply(a: Product.type) = this
+  def isEmpty = false
+  def get: this.type = this
+}
+
+object Sequence {
+  var i = 0
+  def apply(n: Int): Int = i
+  def length = 2
+  def unapplySeq(a: Sequence.type) = this
+  def isEmpty = false
+  def get = this
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    def assertZero(i: Int) = assert(i == 0)
+
+    Single match {
+      case Single(i) =>
+        Single.i = 1
+        assertZero(i) // fails under -optimize
+    }
+
+    Product match {
+      case Product(i, _) =>
+        Product.i = 1
+        assertZero(i) // fails under -optimize
+    }
+
+    Sequence match {
+      case Sequence(i, _ @ _*) =>
+        Sequence.i = 1
+        assertZero(i) // okay
+    }
+
+    Sequence.i = 0
+    Sequence match {
+      case Sequence(_, i) =>
+        Sequence.i = 1
+        assertZero(i) // okay
+    }
+
+    val buffer = collection.mutable.Buffer(0, 0)
+    buffer match {
+      case Seq(_, i) =>
+        buffer(1) = 1
+        assertZero(i) // failed
+    }
+
+    case class CaseSequence(as: Int*)
+    val buffer1 = collection.mutable.Buffer(0, 0)
+    CaseSequence(buffer1: _*) match {
+      case CaseSequence(_, i) =>
+        buffer1(1) = 1
+        assertZero(i) // failed
+    }
+  }
+}
diff --git a/test/files/run/t9027.check b/test/files/run/t9027.check
new file mode 100644
index 0000000000..3429254286
--- /dev/null
+++ b/test/files/run/t9027.check
@@ -0,0 +1,19 @@
+{
+  {
+    val $buf = new _root_.scala.xml.NodeBuffer();
+    $buf.$amp$plus(new _root_.scala.xml.Elem(null, "a", _root_.scala.xml.Null, $scope, true));
+    $buf.$amp$plus(new _root_.scala.xml.Elem(null, "b", _root_.scala.xml.Null, $scope, true));
+    $buf
+  };
+  println("hello, world.")
+}
+{
+  {
+    val $buf = new _root_.scala.xml.NodeBuffer();
+    $buf.$amp$plus(new _root_.scala.xml.Elem(null, "a", _root_.scala.xml.Null, $scope, true));
+    $buf.$amp$plus(new _root_.scala.xml.Elem(null, "b", _root_.scala.xml.Null, $scope, true));
+    $buf.$amp$plus(new _root_.scala.xml.Elem(null, "c", _root_.scala.xml.Null, $scope, true));
+    $buf
+  };
+  println("hello, world.")
+}
diff --git a/test/files/run/t9027.scala b/test/files/run/t9027.scala
new file mode 100644
index 0000000000..26238147da
--- /dev/null
+++ b/test/files/run/t9027.scala
@@ -0,0 +1,15 @@
+
+// used to be parsed as .println
+object Test extends App {
+  import reflect.runtime._, universe._
+
+  val trees = List(
+  q"""<a/><b/>
+      println("hello, world.")""",
+  q"""<a/>
+      <b/>
+      <c/>
+      println("hello, world.")"""
+  )
+  trees foreach println
+}
diff --git a/test/files/run/various-flat-classpath-types.check b/test/files/run/various-flat-classpath-types.check
new file mode 100644
index 0000000000..401f707d0e
--- /dev/null
+++ b/test/files/run/various-flat-classpath-types.check
@@ -0,0 +1,12 @@
+ZipBin()
+JarBin()
+DirBin()
+ZipSrc()
+JarSrc()
+DirSrc()
+NestedZipBin()
+NestedJarBin()
+NestedDirBin()
+NestedZipSrc()
+NestedJarSrc()
+NestedDirSrc()
\ No newline at end of file
diff --git a/test/files/run/various-flat-classpath-types.scala b/test/files/run/various-flat-classpath-types.scala
new file mode 100644
index 0000000000..d39019e885
--- /dev/null
+++ b/test/files/run/various-flat-classpath-types.scala
@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) 2014 Contributor. All rights reserved.
+ */
+
+import java.io.{File => JFile, FileInputStream, FileOutputStream}
+import java.util.zip.{ZipEntry, ZipOutputStream}
+import scala.reflect.io.{Directory, File}
+import scala.tools.nsc.classpath.FlatClassPath.RootPackage
+import scala.tools.nsc.classpath.PackageNameUtils
+import scala.tools.nsc.io.Jar
+
+/**
+ * Generates directories, jars and zip files containing sources and classes
+ * (the result of a compilation which is executed here)
+ * and use them as a class- and sourcepath during compilation and running
+ * created application. At the end everything is cleaned up.
+ *
+ * It can test also current, recursive classpath. Just right now we force
+ * flat classpath to test it also when the recursive one would be set as a default.
+ */
+object Test {
+
+  private implicit class JFileOps(file: JFile) {
+
+    def createDir(newDirName: String) = {
+      val newDir = new JFile(file, newDirName)
+      newDir.mkdir()
+      newDir
+    }
+
+    def createSrcFile(newFileName: String) = createFile(newFileName + ".scala")
+
+    def createFile(fullFileName: String) = {
+      val newFile = new JFile(file, fullFileName)
+      newFile.createNewFile()
+      newFile
+    }
+
+    def writeAll(text: String): Unit = File(file) writeAll text
+
+    def moveContentToZip(zipName: String): Unit = {
+      val newZip = zipsDir createFile s"$zipName.zip"
+      val outputStream = new ZipOutputStream(new FileOutputStream(newZip))
+
+      def addFileToZip(dirPrefix: String = "")(fileToAdd: JFile): Unit =
+        if (fileToAdd.isDirectory) {
+          val dirEntryName = fileToAdd.getName + "/"
+          outputStream.putNextEntry(new ZipEntry(dirEntryName))
+          fileToAdd.listFiles() foreach addFileToZip(dirEntryName)
+        } else {
+          val inputStream = new FileInputStream(fileToAdd)
+          outputStream.putNextEntry(new ZipEntry(dirPrefix + fileToAdd.getName))
+
+          val buffer = new Array[Byte](1024)
+          var count = inputStream.read(buffer)
+          while (count > 0) {
+            outputStream.write(buffer, 0, count)
+            count = inputStream.read(buffer)
+          }
+
+          inputStream.close()
+        }
+
+      file.listFiles() foreach addFileToZip()
+      outputStream.close()
+
+      cleanDir(file)
+    }
+
+    def moveContentToJar(jarName: String): Unit = {
+      val newJar = jarsDir createFile s"$jarName.jar"
+      Jar.create(file = File(newJar), sourceDir = Directory(file), mainClass = "won't be used")
+      cleanDir(file)
+    }
+
+    def path: String = file.getAbsolutePath
+  }
+
+  private case class DirRep(name: String, nestedDirs: Seq[DirRep] = Nil, sourceFiles: Seq[String] = Nil)
+
+  private val compiler = new scala.tools.nsc.MainClass
+  private val appRunner = new scala.tools.nsc.MainGenericRunner
+  private val classPathImplFlag = "-YclasspathImpl:flat"
+  private val javaClassPath = sys.props("java.class.path")
+
+  // creates a test dir in a temporary dir containing compiled files of this test
+  // root dir will be automatically deleted after the end of test
+  private val rootDir = new JFile(sys.props("partest.output"))
+  private val testDir = rootDir createDir s"cp-tests-${System.currentTimeMillis()}"
+
+  private val jarsDir = testDir createDir "jars"
+  private val zipsDir = testDir createDir "zips"
+  private val srcDir = testDir createDir "src"
+  private val binDir = testDir createDir "bin"
+  private val outDir = testDir createDir "out"
+
+  def main(args: Array[String]): Unit = {
+    createClassesZipInZipsDir()
+    createClassesJarInJarsDir()
+    createClassesInBinDir()
+    createSourcesZipInZipsDir()
+    createSourcesJarInJarsDir()
+    createSourcesInSrcDir()
+    compileFinalApp()
+    runApp()
+    // at the end all created files will be deleted automatically
+  }
+
+  private def createClassesZipInZipsDir(): Unit = {
+    val baseFileName = "ZipBin"
+    createStandardSrcHierarchy(baseFileName)
+    compileSrc(baseFileName)
+    outDir moveContentToZip "Bin"
+    cleanDir(srcDir)
+  }
+
+  private def createClassesJarInJarsDir(): Unit = {
+    val baseFileName = "JarBin"
+    createStandardSrcHierarchy(baseFileName)
+    compileSrc(baseFileName)
+    outDir moveContentToJar "Bin"
+    cleanDir(srcDir)
+  }
+
+  private def createClassesInBinDir(): Unit = {
+    val baseFileName = "DirBin"
+    createStandardSrcHierarchy(baseFileName)
+    compileSrc(baseFileName, destination = binDir)
+    cleanDir(srcDir)
+  }
+
+  private def createSourcesZipInZipsDir(): Unit = {
+    createStandardSrcHierarchy(baseFileName = "ZipSrc")
+    srcDir moveContentToZip "Src"
+  }
+
+  private def createSourcesJarInJarsDir(): Unit = {
+    createStandardSrcHierarchy(baseFileName = "JarSrc")
+    srcDir moveContentToJar "Src"
+  }
+
+  private def createSourcesInSrcDir(): Unit = {
+    createStandardSrcHierarchy(baseFileName = "DirSrc")
+
+    val appFile = srcDir createSrcFile "Main"
+    appFile writeAll s"""import nested._
+         | object Main extends App {
+         |   println(new ZipBin)
+         |   println(new JarBin)
+         |   println(new DirBin)
+         |   println(new ZipSrc)
+         |   println(new JarSrc)
+         |   println(new DirSrc)
+         |
+         |   println(new NestedZipBin)
+         |   println(new NestedJarBin)
+         |   println(new NestedDirBin)
+         |   println(new NestedZipSrc)
+         |   println(new NestedJarSrc)
+         |   println(new NestedDirSrc)
+         | }
+       """.stripMargin
+  }
+
+  private def compileFinalApp(): Unit = {
+    val classPath = mkPath(javaClassPath, binDir.path, zipsDir.path + "/Bin.zip", jarsDir.path + "/Bin.jar")
+    val sourcePath = mkPath(srcDir.path, zipsDir.path + "/Src.zip", jarsDir.path + "/Src.jar")
+
+    compiler.process(Array(classPathImplFlag, "-cp", classPath, "-sourcepath", sourcePath,
+      "-d", outDir.path, s"${srcDir.path}/Main.scala"))
+  }
+
+  private def runApp(): Unit = {
+    val classPath = mkPath(javaClassPath, outDir.path, binDir.path, zipsDir.path + "/Bin.zip", jarsDir.path + "/Bin.jar")
+    appRunner.process(Array(classPathImplFlag, "-cp", classPath, "Main"))
+  }
+
+  private def createStandardSrcHierarchy(baseFileName: String): Unit =
+    createSources(RootPackage, srcDir,
+      DirRep("",
+        nestedDirs = Seq(DirRep("nested", sourceFiles = Seq("Nested" + baseFileName))),
+        sourceFiles = Seq(baseFileName)
+      )
+    )
+
+  private def createSources(pkg: String, dirFile: JFile, dirRep: DirRep): Unit = {
+    dirRep.nestedDirs foreach { rep =>
+      val nestedDir = dirFile createDir rep.name
+      val nestedPkg = PackageNameUtils.packagePrefix(pkg) + rep.name
+      createSources(nestedPkg, nestedDir, rep)
+    }
+
+    val pkgHeader = if (pkg == RootPackage) "" else s"package $pkg\n\n"
+    dirRep.sourceFiles foreach { srcName =>
+      val text = s"""${pkgHeader}case class $srcName(x: String = "")"""
+      val srcFile = dirFile createSrcFile srcName
+      srcFile writeAll text
+    }
+  }
+
+  private def compileSrc(baseFileName: String, destination: JFile = outDir): Unit = {
+    val srcDirPath = srcDir.path
+    compiler.process(Array(classPathImplFlag, "-cp", javaClassPath, "-d", destination.path,
+      s"$srcDirPath/$baseFileName.scala", s"$srcDirPath/nested/Nested$baseFileName.scala"))
+  }
+
+  private def cleanDir(dir: JFile): Unit =
+    dir.listFiles().foreach { file =>
+      if (file.isDirectory) cleanDir(file)
+      file.delete()
+    }
+
+  private def mkPath(pathEntries: String*) = pathEntries.mkString(File.pathSeparator)
+}
diff --git a/test/files/run/virtpatmat_nested_lists.flags b/test/files/run/virtpatmat_nested_lists.flags
new file mode 100644
index 0000000000..ca9a4c0697
--- /dev/null
+++ b/test/files/run/virtpatmat_nested_lists.flags
@@ -0,0 +1 @@
+-Ypatmat-exhaust-depth off
\ No newline at end of file
diff --git a/test/files/run/virtpatmat_opt_sharing.flags b/test/files/run/virtpatmat_opt_sharing.flags
new file mode 100644
index 0000000000..ca9a4c0697
--- /dev/null
+++ b/test/files/run/virtpatmat_opt_sharing.flags
@@ -0,0 +1 @@
+-Ypatmat-exhaust-depth off
\ No newline at end of file
diff --git a/test/files/run/xMigration.check b/test/files/run/xMigration.check
new file mode 100644
index 0000000000..378f7bb6c3
--- /dev/null
+++ b/test/files/run/xMigration.check
@@ -0,0 +1,49 @@
+Type in expressions to have them evaluated.
+Type :help for more information.
+
+scala> Map(1 -> "eis").values    // no warn
+res0: Iterable[String] = MapLike(eis)
+
+scala> :setting -Xmigration:none
+
+scala> Map(1 -> "eis").values    // no warn
+res1: Iterable[String] = MapLike(eis)
+
+scala> :setting -Xmigration:any
+
+scala> Map(1 -> "eis").values    // warn
+<console>:8: warning: method values in trait MapLike has changed semantics in version 2.8.0:
+`values` returns `Iterable[B]` rather than `Iterator[B]`.
+              Map(1 -> "eis").values    // warn
+                              ^
+res2: Iterable[String] = MapLike(eis)
+
+scala> :setting -Xmigration:2.8
+
+scala> Map(1 -> "eis").values    // no warn
+res3: Iterable[String] = MapLike(eis)
+
+scala> :setting -Xmigration:2.7
+
+scala> Map(1 -> "eis").values    // warn
+<console>:8: warning: method values in trait MapLike has changed semantics in version 2.8.0:
+`values` returns `Iterable[B]` rather than `Iterator[B]`.
+              Map(1 -> "eis").values    // warn
+                              ^
+res4: Iterable[String] = MapLike(eis)
+
+scala> :setting -Xmigration:2.11
+
+scala> Map(1 -> "eis").values    // no warn
+res5: Iterable[String] = MapLike(eis)
+
+scala> :setting -Xmigration      // same as :any
+
+scala> Map(1 -> "eis").values    // warn
+<console>:8: warning: method values in trait MapLike has changed semantics in version 2.8.0:
+`values` returns `Iterable[B]` rather than `Iterator[B]`.
+              Map(1 -> "eis").values    // warn
+                              ^
+res6: Iterable[String] = MapLike(eis)
+
+scala> :quit
diff --git a/test/files/run/xMigration.scala b/test/files/run/xMigration.scala
new file mode 100644
index 0000000000..688e878397
--- /dev/null
+++ b/test/files/run/xMigration.scala
@@ -0,0 +1,19 @@
+import scala.tools.partest.ReplTest
+
+object Test extends ReplTest {
+  def code = """
+Map(1 -> "eis").values    // no warn
+:setting -Xmigration:none
+Map(1 -> "eis").values    // no warn
+:setting -Xmigration:any
+Map(1 -> "eis").values    // warn
+:setting -Xmigration:2.8
+Map(1 -> "eis").values    // no warn
+:setting -Xmigration:2.7
+Map(1 -> "eis").values    // warn
+:setting -Xmigration:2.11
+Map(1 -> "eis").values    // no warn
+:setting -Xmigration      // same as :any
+Map(1 -> "eis").values    // warn
+  """
+}
diff --git a/test/files/scalacheck/nan-ordering.scala b/test/files/scalacheck/nan-ordering.scala
index 2094a46e37..05e97a13c9 100644
--- a/test/files/scalacheck/nan-ordering.scala
+++ b/test/files/scalacheck/nan-ordering.scala
@@ -42,16 +42,16 @@ object Test extends Properties("NaN-Ordering") {
   property("Float equiv") = forAll(specFloats, specFloats) { (d1, d2) => numFloat.equiv(d1, d2) == (d1 == d2) }
 
   property("Float reverse.min") = forAll(specFloats, specFloats) { (d1, d2) => {
-      val mathmin = math.min(d1, d2)
+      val mathmax = math.max(d1, d2)
       val numericmin = numFloat.reverse.min(d1, d2)
-      mathmin == numericmin || mathmin.isNaN && numericmin.isNaN
+      mathmax == numericmin || mathmax.isNaN && numericmin.isNaN
     }
   }
 
   property("Float reverse.max") = forAll(specFloats, specFloats) { (d1, d2) => {
-      val mathmax = math.max(d1, d2)
+      val mathmin = math.min(d1, d2)
       val numericmax = numFloat.reverse.max(d1, d2)
-      mathmax == numericmax || mathmax.isNaN && numericmax.isNaN
+      mathmin == numericmax || mathmin.isNaN && numericmax.isNaN
     }
   }
 
@@ -105,16 +105,16 @@ object Test extends Properties("NaN-Ordering") {
   property("Double equiv") = forAll(specDoubles, specDoubles) { (d1, d2) => numDouble.equiv(d1, d2) == (d1 == d2) }
 
   property("Double reverse.min") = forAll(specDoubles, specDoubles) { (d1, d2) => {
-    val mathmin = math.min(d1, d2)
+    val mathmax = math.max(d1, d2)
     val numericmin = numDouble.reverse.min(d1, d2)
-    mathmin == numericmin || mathmin.isNaN && numericmin.isNaN
+    mathmax == numericmin || mathmax.isNaN && numericmin.isNaN
   }
   }
 
   property("Double reverse.max") = forAll(specDoubles, specDoubles) { (d1, d2) => {
-    val mathmax = math.max(d1, d2)
+    val mathmin = math.min(d1, d2)
     val numericmax = numDouble.reverse.max(d1, d2)
-    mathmax == numericmax || mathmax.isNaN && numericmax.isNaN
+    mathmin == numericmax || mathmin.isNaN && numericmax.isNaN
   }
   }
 
diff --git a/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala b/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala
index 774d6f428b..468bcb6dd1 100644
--- a/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala
+++ b/test/files/scalacheck/parallel-collections/ParallelIterableCheck.scala
@@ -36,7 +36,7 @@ abstract class ParallelIterableCheck[T](collName: String) extends Properties(col
 
   // used to check if constructed collection is valid
   def checkDataStructureInvariants(orig: Traversable[T], cf: AnyRef) = {
-    // can be overriden in subclasses
+    // can be overridden in subclasses
     true
   }
 
diff --git a/test/files/t8449/Client.scala b/test/files/t8449/Client.scala
new file mode 100644
index 0000000000..5d273f06b2
--- /dev/null
+++ b/test/files/t8449/Client.scala
@@ -0,0 +1,3 @@
+object Client {
+  def foo: Any = new Test().foo
+}
diff --git a/test/files/t8449/Test.java b/test/files/t8449/Test.java
new file mode 100644
index 0000000000..ecb1711b24
--- /dev/null
+++ b/test/files/t8449/Test.java
@@ -0,0 +1,10 @@
+public class Test {
+	// Raw type over a Scala type constructor
+	public scala.Function1 foo() { return null; }
+	// scalac reported:
+	// % scalac-hash v2.11.2 -d /tmp sandbox/{Test.java,Client.scala}
+	// sandbox/Test.java:2: error: trait Function1 takes type parameters
+	// 	public scala.Function1 foo() { return null; }
+	//                      ^
+	// one error found
+}