Merge remote-tracking branch 'origin/2.10.x' into pr/merge-2.10

* origin/2.10.x:
  SI-6969, mishandling of SoftReferences in method cache.
  SI-7011 Fix finding constructor type in captured var definitions
  SI-6987 Tests fsc verbose output
  SI-6987 Fixes fsc compile server verbose output
  SI-6231 Report unsupported free var capture by a trait.
  SI-6666 Restrict hidden `this` access in self/super calls.
  SI-6902 Check unreachability under @unchecked
  SI-6976 Fix value class separate compilation crasher.
  Closes SI-6952: add correct error positions for Dynamic feature check.

Conflicts:
	src/compiler/scala/tools/nsc/CompileServer.scala
	src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala

29 files changed, 507 insertions, 52 deletions

diff --git a/src/compiler/scala/tools/nsc/CompileServer.scala b/src/compiler/scala/tools/nsc/CompileServer.scala
index e4c250a3d9..72e8cc69c7 100644
--- a/src/compiler/scala/tools/nsc/CompileServer.scala
+++ b/src/compiler/scala/tools/nsc/CompileServer.scala
@@ -87,10 +87,11 @@ class StandardCompileServer extends SocketServer {
 
     val args        = input.split("\0", -1).toList
     val newSettings = new FscSettings(fscError)
-    this.verbose    = newSettings.verbose.value
     val command     = new OfflineCompilerCommand(args, newSettings)
+    this.verbose    = newSettings.verbose.value
 
     info("Settings after normalizing paths: " + newSettings)
+    if (!command.files.isEmpty) info("Input files after normalizing paths: " + (command.files mkString ","))
     printMemoryStats()
 
     // Update the idle timeout if given
@@ -168,11 +169,22 @@ object CompileServer extends StandardCompileServer {
   /** A directory holding redirected output */
   private lazy val redirectDir = (compileSocket.tmpDir / "output-redirects").createDirectory()
 
-  private def redirect(setter: PrintStream => Unit, filename: String) {
-    setter(new PrintStream((redirectDir / filename).createFile().bufferedOutput()))
-  }
+  private def createRedirect(filename: String) =
+    new PrintStream((redirectDir / filename).createFile().bufferedOutput())
+
+  def main(args: Array[String]) =
+    execute(() => (), args)
 
-  def main(args: Array[String]) {
+  /**
+   * Used for internal testing. The callback is called upon
+   * server start, notifying the caller that the server is
+   * ready to run. WARNING: the callback runs in the
+   * server's thread, blocking the server from doing any work
+   * until the callback is finished. Callbacks should be kept
+   * simple and clients should not try to interact with the
+   * server while the callback is processing.
+   */
+  def execute(startupCallback : () => Unit, args: Array[String]) {
     val debug = args contains "-v"
 
     if (debug) {
@@ -180,14 +192,16 @@ object CompileServer extends StandardCompileServer {
       echo("Redirect dir is " + redirectDir)
     }
 
-    redirect(System.setOut, "scala-compile-server-out.log")
-    redirect(System.setErr, "scala-compile-server-err.log")
-    System.err.println("...starting server on socket "+port+"...")
-    System.err.flush()
-    compileSocket setPort port
-    run()
+    Console.withErr(createRedirect("scala-compile-server-err.log")) {
+      Console.withOut(createRedirect("scala-compile-server-out.log")) {
+        Console.err.println("...starting server on socket "+port+"...")
+        Console.err.flush()
+        compileSocket setPort port
+        startupCallback()
+        run()
 
-    compileSocket deletePort port
-    sys exit 0
+        compileSocket deletePort port
+      }
+    }
   }
 }
diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
index 39460ef004..f5c8907991 100644
--- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala
+++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
@@ -201,12 +201,17 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
                 var reflPoly$Cache: SoftReference[scala.runtime.MethodCache] = new SoftReference(new EmptyMethodCache())
 
                 def reflMethod$Method(forReceiver: JClass[_]): JMethod = {
-                  var method: JMethod = reflPoly$Cache.find(forReceiver)
-                  if (method != null)
+                  var methodCache: MethodCache = reflPoly$Cache.find(forReceiver)
+                  if (methodCache eq null) {
+                    methodCache = new EmptyMethodCache
+                    reflPoly$Cache = new SoftReference(methodCache)
+                  }
+                  var method: JMethod = methodCache.find(forReceiver)
+                  if (method ne null)
                     return method
                   else {
                     method = ScalaRunTime.ensureAccessible(forReceiver.getMethod("xyz", reflParams$Cache))
-                    reflPoly$Cache = new SoftReference(reflPoly$Cache.get.add(forReceiver, method))
+                    reflPoly$Cache = new SoftReference(methodCache.add(forReceiver, method))
                     return method
                   }
                 }
@@ -223,16 +228,22 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
               def getPolyCache = gen.mkCast(fn(REF(reflPolyCacheSym), nme.get), MethodCacheClass.tpe)
 
               addStaticMethodToClass((reflMethodSym, forReceiverSym) => {
+                val methodCache = reflMethodSym.newVariable(mkTerm("methodCache"), ad.pos) setInfo MethodCacheClass.tpe
                 val methodSym = reflMethodSym.newVariable(mkTerm("method"), ad.pos) setInfo MethodClass.tpe
 
                 BLOCK(
-                  IF (getPolyCache OBJ_EQ NULL) THEN (REF(reflPolyCacheSym) === mkNewPolyCache) ENDIF,
-                  VAL(methodSym) === ((getPolyCache DOT methodCache_find)(REF(forReceiverSym))) ,
-                  IF (REF(methodSym) OBJ_!= NULL) .
+                  VAL(methodCache) === getPolyCache,
+                  IF (REF(methodCache) OBJ_EQ NULL) THEN BLOCK(
+                    REF(methodCache) === NEW(TypeTree(EmptyMethodCacheClass.tpe)),
+                    REF(reflPolyCacheSym) === gen.mkSoftRef(REF(methodCache))
+                  ) ENDIF,
+
+                  VAL(methodSym) === (REF(methodCache) DOT methodCache_find)(REF(forReceiverSym)),
+                  IF (REF(methodSym) OBJ_NE NULL) .
                     THEN (Return(REF(methodSym)))
                   ELSE {
                     def methodSymRHS  = ((REF(forReceiverSym) DOT Class_getMethod)(LIT(method), REF(reflParamsCacheSym)))
-                    def cacheRHS      = ((getPolyCache DOT methodCache_add)(REF(forReceiverSym), REF(methodSym)))
+                    def cacheRHS      = ((REF(methodCache) DOT methodCache_add)(REF(forReceiverSym), REF(methodSym)))
                     BLOCK(
                       REF(methodSym)        === (REF(ensureAccessibleMethod) APPLY (methodSymRHS)),
                       REF(reflPolyCacheSym) === gen.mkSoftRef(cacheRHS),
@@ -241,6 +252,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
                   }
                 )
               })
+
         }
 
         /* ### HANDLING METHODS NORMALLY COMPILED TO OPERATORS ### */
diff --git a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
index 77e7e013ab..12933af138 100644
--- a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
+++ b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
@@ -60,14 +60,18 @@ abstract class ExtensionMethods extends Transform with TypingTransformers {
     }
   }
 
-  /** Return the extension method that corresponds to given instance method `meth`.
-   */
+  private def companionModuleForce(sym: Symbol) = {
+    sym.andAlso(_.owner.initialize) // See SI-6976. `companionModule` only calls `rawInfo`. (Why?)
+    sym.companionModule
+  }
+
+  /** Return the extension method that corresponds to given instance method `meth`. */
   def extensionMethod(imeth: Symbol): Symbol = enteringPhase(currentRun.refchecksPhase) {
-    val companionInfo = imeth.owner.companionModule.info
+    val companionInfo = companionModuleForce(imeth.owner).info
     val candidates = extensionNames(imeth) map (companionInfo.decl(_)) filter (_.exists)
     val matching = candidates filter (alt => normalize(alt.tpe, imeth.owner) matches imeth.tpe)
     assert(matching.nonEmpty,
-      s"no extension method found for $imeth:${imeth.tpe} among ${candidates map (c => c.name+":"+c.tpe)} / ${extensionNames(imeth)}")
+      s"no extension method found for $imeth:${imeth.tpe} among ${candidates.map(c => c.name+":"+c.tpe).toList} / ${extensionNames(imeth).toList}")
     matching.head
   }
 
diff --git a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
index b081fb7e3f..f8172743b5 100644
--- a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
+++ b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
@@ -320,12 +320,24 @@ abstract class LambdaLift extends InfoTransform {
     private def memberRef(sym: Symbol) = {
       val clazz = sym.owner.enclClass
       //Console.println("memberRef from "+currentClass+" to "+sym+" in "+clazz)
-      val qual = if (clazz == currentClass) gen.mkAttributedThis(clazz)
-                 else {
-                   sym resetFlag(LOCAL | PRIVATE)
-                   if (clazz.isStaticOwner) gen.mkAttributedQualifier(clazz.thisType)
-                   else outerPath(outerValue, currentClass.outerClass, clazz)
-                 }
+      def prematureSelfReference() {
+        val what =
+          if (clazz.isStaticOwner) clazz.fullLocationString
+          else s"the unconstructed `this` of ${clazz.fullLocationString}"
+        val msg = s"Implementation restriction: access of ${sym.fullLocationString} from ${currentClass.fullLocationString}, would require illegal premature access to $what"
+        currentUnit.error(curTree.pos, msg)
+      }
+      val qual =
+        if (clazz == currentClass) gen.mkAttributedThis(clazz)
+        else {
+          sym resetFlag (LOCAL | PRIVATE)
+          if (selfOrSuperCalls exists (_.owner == clazz)) {
+            prematureSelfReference()
+            EmptyTree
+          }
+          else if (clazz.isStaticOwner) gen.mkAttributedQualifier(clazz.thisType)
+          else outerPath(outerValue, currentClass.outerClass, clazz)
+        }
       Select(qual, sym) setType sym.tpe
     }
 
@@ -352,6 +364,7 @@ abstract class LambdaLift extends InfoTransform {
 
             copyDefDef(tree)(vparamss = List(vparams ++ freeParams))
           case ClassDef(_, _, _, _) =>
+            // SI-6231
             // Disabled attempt to to add getters to freeParams
             // this does not work yet. Problem is that local symbols need local names
             // and references to local symbols need to be transformed into
@@ -369,7 +382,7 @@ abstract class LambdaLift extends InfoTransform {
         tree
     }
 
-/*  Something like this will be necessary to eliminate the implementation
+/*  SI-6231: Something like this will be necessary to eliminate the implementation
  *  restiction from paramGetter above:
  *  We need to pass getters to the interface of an implementation class.
     private def fixTraitGetters(lifted: List[Tree]): List[Tree] =
@@ -430,10 +443,10 @@ abstract class LambdaLift extends InfoTransform {
             /* Creating a constructor argument if one isn't present. */
             val constructorArg = rhs match {
               case EmptyTree =>
-                sym.primaryConstructor.info.paramTypes match {
+                sym.tpe.typeSymbol.primaryConstructor.info.paramTypes match {
                   case List(tp) => gen.mkZero(tp)
                   case _        =>
-                    log("Couldn't determine how to properly construct " + sym)
+                    debugwarn("Couldn't determine how to properly construct " + sym)
                     rhs
                 }
               case arg => arg
@@ -495,13 +508,25 @@ abstract class LambdaLift extends InfoTransform {
 
     private def preTransform(tree: Tree) = super.transform(tree) setType lifted(tree.tpe)
 
+    /** The stack of constructor symbols in which a call to this() or to the super
+      * constructor is active.
+      */
+    private val selfOrSuperCalls = mutable.Stack[Symbol]()
+    @inline private def inSelfOrSuperCall[A](sym: Symbol)(a: => A) = try {
+      selfOrSuperCalls push sym
+      a
+    } finally selfOrSuperCalls.pop()
+
     override def transform(tree: Tree): Tree = tree match {
       case Select(ReferenceToBoxed(idt), elem) if elem == nme.elem =>
         postTransform(preTransform(idt), isBoxedRef = false)
       case ReferenceToBoxed(idt) =>
         postTransform(preTransform(idt), isBoxedRef = true)
       case _ =>
-        postTransform(preTransform(tree))
+        def transformTree = postTransform(preTransform(tree))
+        if (treeInfo isSelfOrSuperConstrCall tree)
+          inSelfOrSuperCall(currentOwner)(transformTree)
+        else transformTree
     }
 
     /** Transform statements and add lifted definitions to them. */
diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala
index 6a253a98b1..3e5ac6922e 100644
--- a/src/compiler/scala/tools/nsc/transform/Mixin.scala
+++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala
@@ -1214,9 +1214,24 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
           // refer to fields in some implementation class via an abstract
           // getter in the interface.
           val iface  = toInterface(sym.owner.tpe).typeSymbol
-          val getter = sym getter iface orElse abort("No getter for " + sym + " in " + iface)
+          val ifaceGetter = sym getter iface
+
+          def si6231Restriction() {
+            // See SI-6231 comments in LamdaLift for ideas on how to lift the restriction.
+            val msg = sm"""Implementation restriction: local ${iface.fullLocationString} is unable to automatically capture the
+                |free variable ${sym} on behalf of ${currentClass}. You can manually assign it to a val inside the trait,
+                |and refer that that val in ${currentClass}. For more details, see SI-6231."""
+            reporter.error(tree.pos, msg)
+          }
 
-          typedPos(tree.pos)((qual DOT getter)())
+          if (ifaceGetter == NoSymbol) {
+            if (sym.isParamAccessor) {
+              si6231Restriction()
+              EmptyTree
+            }
+            else abort("No getter for " + sym + " in " + iface)
+          }
+          else typedPos(tree.pos)((qual DOT ifaceGetter)())
 
         case Assign(Apply(lhs @ Select(qual, _), List()), rhs) =>
           // assign to fields in some implementation class via an abstract
diff --git a/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala b/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
index ec6a33519a..27bdad3066 100644
--- a/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/PatternMatching.scala
@@ -3237,6 +3237,7 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
       // TODO: make more fine-grained, as we don't always need to jump
       def canJump: Boolean
 
+      /** Should exhaustivity analysis be skipped? */
       def unchecked: Boolean
 
 
@@ -3470,12 +3471,10 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
             case Some(cds) => cds
           }
 
-          val allReachable = unchecked || {
-            // a switch with duplicate cases yields a verify error,
-            // and a switch with duplicate cases and guards cannot soundly be rewritten to an unguarded switch
-            // (even though the verify error would disappear, the behaviour would change)
-            unreachableCase(caseDefsWithGuards) map (cd => reportUnreachable(cd.body.pos)) isEmpty
-          }
+          // a switch with duplicate cases yields a verify error,
+          // and a switch with duplicate cases and guards cannot soundly be rewritten to an unguarded switch
+          // (even though the verify error would disappear, the behaviour would change)
+          val allReachable = unreachableCase(caseDefsWithGuards) map (cd => reportUnreachable(cd.body.pos)) isEmpty
 
           if (!allReachable) Nil
           else if (noGuards(caseDefsWithGuards)) {
@@ -3718,10 +3717,10 @@ trait PatternMatching extends Transform with TypingTransformers with ast.TreeDSL
                               with SymbolicMatchAnalysis
                               with DPLLSolver { self: TreeMakers =>
     override def optimizeCases(prevBinder: Symbol, cases: List[List[TreeMaker]], pt: Type, unchecked: Boolean): (List[List[TreeMaker]], List[Tree]) = {
+      unreachableCase(prevBinder, cases, pt) foreach { caseIndex =>
+        reportUnreachable(cases(caseIndex).last.pos)
+      }
       if (!unchecked) {
-        unreachableCase(prevBinder, cases, pt) foreach { caseIndex =>
-          reportUnreachable(cases(caseIndex).last.pos)
-        }
         val counterExamples = exhaustive(prevBinder, cases, pt)
         if (counterExamples.nonEmpty)
           reportMissingCases(prevBinder.pos, counterExamples)
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 8d028857d4..f2f8f47bf2 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -1698,8 +1698,8 @@ trait Typers extends Adaptations with Tags {
      */
     def validateParentClasses(parents: List[Tree], selfType: Type) {
       val pending = ListBuffer[AbsTypeError]()
-      def validateDynamicParent(parent: Symbol) =
-        if (parent == DynamicClass) checkFeature(parent.pos, DynamicsFeature)
+      def validateDynamicParent(parent: Symbol, parentPos: Position) =
+        if (parent == DynamicClass) checkFeature(parentPos, DynamicsFeature)
 
       def validateParentClass(parent: Tree, superclazz: Symbol) =
         if (!parent.isErrorTyped) {
@@ -1746,7 +1746,7 @@ trait Typers extends Adaptations with Tags {
           if (parents exists (p => p != parent && p.tpe.typeSymbol == psym && !psym.isError))
             pending += ParentInheritedTwiceError(parent, psym)
 
-          validateDynamicParent(psym)
+          validateDynamicParent(psym, parent.pos)
         }
 
       if (!parents.isEmpty && parents.forall(!_.isErrorTyped)) {
diff --git a/src/compiler/scala/tools/util/SocketServer.scala b/src/compiler/scala/tools/util/SocketServer.scala
index d29a370c28..1b06ce2ff2 100644
--- a/src/compiler/scala/tools/util/SocketServer.scala
+++ b/src/compiler/scala/tools/util/SocketServer.scala
@@ -16,8 +16,8 @@ trait CompileOutputCommon {
   def verbose: Boolean
 
   def info(msg: String)  = if (verbose) echo(msg)
-  def echo(msg: String)  = Console println msg
-  def warn(msg: String)  = System.err println msg
+  def echo(msg: String)  = {Console println msg; Console.flush}
+  def warn(msg: String)  = {Console.err println msg; Console.flush}
   def fatal(msg: String) = { warn(msg) ; sys.exit(1) }
 }
 
diff --git a/test/files/neg/t6040.check b/test/files/neg/t6040.check
index f6757f97e3..f91df0c46d 100644
--- a/test/files/neg/t6040.check
+++ b/test/files/neg/t6040.check
@@ -1,7 +1,9 @@
-error: extension of type scala.Dynamic needs to be enabled
+t6040.scala:1: error: extension of type scala.Dynamic needs to be enabled
 by making the implicit value language.dynamics visible.
 This can be achieved by adding the import clause 'import scala.language.dynamics'
 or by setting the compiler option -language:dynamics.
 See the Scala docs for value scala.language.dynamics for a discussion
 why the feature needs to be explicitly enabled.
+class X extends Dynamic
+                ^
 one error found
diff --git a/test/files/neg/t6231.check b/test/files/neg/t6231.check
new file mode 100644
index 0000000000..b27961d393
--- /dev/null
+++ b/test/files/neg/t6231.check
@@ -0,0 +1,6 @@
+t6231.scala:4: error: Implementation restriction: local trait Bug$X$1 is unable to automatically capture the
+free variable value ev$1 on behalf of anonymous class anonfun$qux$1. You can manually assign it to a val inside the trait,
+and refer that that val in anonymous class anonfun$qux$1. For more details, see SI-6231.
+      def qux = { () => ev }
+                        ^
+one error found
diff --git a/test/files/neg/t6231.scala b/test/files/neg/t6231.scala
new file mode 100644
index 0000000000..1e5b4e0e1a
--- /dev/null
+++ b/test/files/neg/t6231.scala
@@ -0,0 +1,15 @@
+object Bug {
+  def bar(ev: Any) = {
+    trait X {
+      def qux = { () => ev }
+    }
+    new X {}.qux()
+
+    // workaround
+    trait Y {
+      val ev2 = ev // manually capture `ev` so that `ev2` is added to the trait interface.
+      def qux = { () => ev2 }
+    }
+  }
+}
+
diff --git a/test/files/neg/t6666.check b/test/files/neg/t6666.check
new file mode 100644
index 0000000000..d0378173ea
--- /dev/null
+++ b/test/files/neg/t6666.check
@@ -0,0 +1,40 @@
+t6666.scala:23: error: Implementation restriction: access of method x$2 in object O1 from anonymous class 2, would require illegal premature access to object O1
+  F.byname(x)
+           ^
+t6666.scala:30: error: Implementation restriction: access of value x$3 in object O2 from anonymous class 3, would require illegal premature access to object O2
+  F.byname(x)
+           ^
+t6666.scala:37: error: Implementation restriction: access of method x$4 in object O3 from anonymous class 4, would require illegal premature access to object O3
+  F.hof(() => x)
+              ^
+t6666.scala:50: error: Implementation restriction: access of method x$6 in class C1 from anonymous class 7, would require illegal premature access to the unconstructed `this` of class C1
+  F.byname(x)
+           ^
+t6666.scala:54: error: Implementation restriction: access of value x$7 in class C2 from anonymous class 8, would require illegal premature access to the unconstructed `this` of class C2
+  F.byname(x)
+           ^
+t6666.scala:58: error: Implementation restriction: access of method x$8 in class C3 from anonymous class 9, would require illegal premature access to the unconstructed `this` of class C3
+  F.hof(() => x)
+              ^
+t6666.scala:62: error: Implementation restriction: access of method x$9 in class C4 from object Nested$5, would require illegal premature access to the unconstructed `this` of class C4
+  object Nested { def xx = x}
+                           ^
+t6666.scala:68: error: Implementation restriction: access of method x$10 in class C5 from object Nested$6, would require illegal premature access to the unconstructed `this` of class C5
+    object Nested { def xx = x}
+                             ^
+t6666.scala:83: error: Implementation restriction: access of method x$12 in class C11 from anonymous class 12, would require illegal premature access to the unconstructed `this` of class C11
+      F.byname(x)
+               ^
+t6666.scala:102: error: Implementation restriction: access of method x$13 in class C13 from anonymous class 13, would require illegal premature access to the unconstructed `this` of class C13
+      F.hof(() => x)
+                  ^
+t6666.scala:111: error: Implementation restriction: access of method x$14 in class C14 from object Nested$7, would require illegal premature access to the unconstructed `this` of class C14
+      object Nested { def xx = x}
+                               ^
+t6666.scala:122: error: Implementation restriction: access of method x$15 in class C15 from object Nested$8, would require illegal premature access to the unconstructed `this` of class C15
+        object Nested { def xx = x}
+                                 ^
+t6666.scala:131: error: Implementation restriction: access of method foo$1 in class COuter from class CInner$1, would require illegal premature access to the unconstructed `this` of class COuter
+  class CInner extends C({foo})
+                          ^
+13 errors found
diff --git a/test/files/neg/t6666.scala b/test/files/neg/t6666.scala
new file mode 100644
index 0000000000..d37ffaf141
--- /dev/null
+++ b/test/files/neg/t6666.scala
@@ -0,0 +1,132 @@
+class C(a: Any)
+object F {
+  def byname(a: => Any) = println(a)
+  def hof(a: () => Any) = println(a())
+}
+
+class COkay extends C(0) {
+  def this(a: Any) {
+    this()
+    def x = "".toString
+    F.byname(x)
+  }
+}
+
+//
+// The thunk's apply method accesses the MODULE$
+// field before it is set.
+//
+//   0: getstatic #23; //Field O1$.MODULE$:LO1$;
+//   3: invokevirtual #26; //Method O1$.O1$$x$1:()Ljava/lang/String;
+object O1 extends C({
+  def x = "".toString
+  F.byname(x)
+})
+
+// java.lang.NullPointerException
+//   at O2$$anonfun$$init$$1.apply(<console>:11)
+object O2 extends C({
+  lazy val x = "".toString
+  F.byname(x)
+})
+
+// java.lang.NullPointerException
+//   at O3$$anonfun$$init$$1.apply(<console>:11)
+object O3 extends C({
+  def x = "".toString
+  F.hof(() => x)
+})
+
+// Okay, the nested classes don't get an outer pointer passed,
+// just an extra param for `x: String`.
+object O6 extends C({
+  val x = "".toString
+  F.byname(x); F.hof(() => x); (new { val xx = x }.xx)
+})
+
+
+class C1 extends C({
+  def x = "".toString
+  F.byname(x)
+})
+class C2 extends C({
+  lazy val x = "".toString
+  F.byname(x)
+})
+class C3 extends C({
+  def x = "".toString
+  F.hof(() => x)
+})
+class C4 extends C({
+  def x = "".toString
+  object Nested { def xx = x}
+  Nested.xx
+})
+class C5 extends C({
+  def x = "".toString
+  val y = {
+    object Nested { def xx = x}
+    Nested.xx
+  }
+})
+
+// okay, for same reason as O6
+class C6 extends C({
+  val x = "".toString
+  F.byname(x); F.hof(() => x); (new { val xx = x }.xx)
+})
+
+class C11(a: Any) {
+  def this() = {
+    this({
+     def x = "".toString
+      F.byname(x)
+    })
+  }
+}
+
+// Crashes earlier in lazyVals.
+// class C12(a: Any) {
+//   def this() = {
+//     this({
+//       lazy val x = "".toString
+//       F.byname(x)
+//     })
+//   }
+// }
+
+class C13(a: Any) {
+  def this() = {
+    this({
+      def x = "".toString
+      F.hof(() => x)
+    })
+  }
+}
+
+class C14(a: Any) {
+  def this() = {
+    this({
+      def x = "".toString
+      object Nested { def xx = x}
+      Nested.xx
+    })
+  }
+}
+
+class C15(a: Any) {
+  def this() = {
+    this({
+      def x = "".toString
+      val y = {
+        object Nested { def xx = x}
+        Nested.xx
+      }
+    })
+  }
+}
+
+class COuter extends C({
+  def foo = 0
+  class CInner extends C({foo})
+})
\ No newline at end of file
diff --git a/test/files/neg/t6902.check b/test/files/neg/t6902.check
new file mode 100644
index 0000000000..ed0ed75303
--- /dev/null
+++ b/test/files/neg/t6902.check
@@ -0,0 +1,12 @@
+t6902.scala:4: warning: unreachable code
+    case Some(b) => 3 // no warning was emitted
+                    ^
+t6902.scala:9: warning: unreachable code
+    case Some(b) => 3 // no warning was emitted
+                    ^
+t6902.scala:21: warning: unreachable code
+    case 1 => 3 // crash
+              ^
+error: No warnings can be incurred under -Xfatal-warnings.
+three warnings found
+one error found
diff --git a/test/files/neg/t6902.flags b/test/files/neg/t6902.flags
new file mode 100644
index 0000000000..e8fb65d50c
--- /dev/null
+++ b/test/files/neg/t6902.flags
@@ -0,0 +1 @@
+-Xfatal-warnings
\ No newline at end of file
diff --git a/test/files/neg/t6902.scala b/test/files/neg/t6902.scala
new file mode 100644
index 0000000000..ce5ff8b6fb
--- /dev/null
+++ b/test/files/neg/t6902.scala
@@ -0,0 +1,23 @@
+object Test {
+  Some(Some(1)) collect {
+    case Some(a) => 2
+    case Some(b) => 3 // no warning was emitted
+  }
+
+  (Some(1): @ unchecked) match {
+    case Some(a) => 2
+    case Some(b) => 3 // no warning was emitted
+  }
+
+  // A variation of SI-6011, which eluded the fix
+  // in 2.10.0.
+  //
+  // duplicate keys in SWITCH, can't pick arbitrarily one of them to evict, see SI-6011.
+  // 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 {
+    case 1 => 2
+    case 1 => 3 // crash
+  }
+}
diff --git a/test/files/neg/t6952.check b/test/files/neg/t6952.check
new file mode 100644
index 0000000000..f1e1881404
--- /dev/null
+++ b/test/files/neg/t6952.check
@@ -0,0 +1,13 @@
+t6952.scala:2: error: extension of type scala.Dynamic needs to be enabled
+by making the implicit value language.dynamics visible.
+This can be achieved by adding the import clause 'import scala.language.dynamics'
+or by setting the compiler option -language:dynamics.
+See the Scala docs for value scala.language.dynamics for a discussion
+why the feature needs to be explicitly enabled.
+trait B extends Dynamic
+                ^
+t6952.scala:3: error: extension of type scala.Dynamic needs to be enabled
+by making the implicit value language.dynamics visible.
+trait C extends A with Dynamic
+                       ^
+two errors found
diff --git a/test/files/neg/t6952.scala b/test/files/neg/t6952.scala
new file mode 100644
index 0000000000..257ea3be68
--- /dev/null
+++ b/test/files/neg/t6952.scala
@@ -0,0 +1,4 @@
+trait A
+trait B extends Dynamic
+trait C extends A with Dynamic
+trait D extends B
diff --git a/test/files/pos/t6976/Exts_1.scala b/test/files/pos/t6976/Exts_1.scala
new file mode 100644
index 0000000000..9b3a69edd9
--- /dev/null
+++ b/test/files/pos/t6976/Exts_1.scala
@@ -0,0 +1,10 @@
+object Exts {
+  implicit class AnyExts[T](val o: T) extends AnyVal {
+    def moo = "moo!"
+  }
+}
+
+trait Exts {
+  import language.implicitConversions
+  implicit def AnyExts[T](o: T) = Exts.AnyExts(o)
+}
diff --git a/test/files/pos/t6976/ImplicitBug_1.scala b/test/files/pos/t6976/ImplicitBug_1.scala
new file mode 100644
index 0000000000..c9031bab2e
--- /dev/null
+++ b/test/files/pos/t6976/ImplicitBug_1.scala
@@ -0,0 +1,27 @@
+// This one is weird and nasty. Not sure if this is scalac or sbt 
+// (tried with 0.12 & 0.12.2-RC2) bug.
+//
+// A level of indirection is required to trigger this bug.
+// Exts seems to need to be defined in separate file.
+//
+// Steps to reproduce:
+// 1. sbt clean
+// 2. sbt run (it works)
+// 3. Comment A & uncomment B.
+// 4. sbt run (it fails)
+// 5. Switch it back & sbt run. It still fails.
+//
+// In this project sbt clean helps. However in a large project where this 
+// bug was found compiler crashed even after doing sbt clean. The only
+// way to work around this was to reference Exts object explicitly (C) in 
+// the source file using its implicit classes.
+
+// Lets suppose this is a mega-trait combining all sorts of helper 
+// functionality.
+trait Support extends Exts
+
+object ImplicitsBug extends App with Support { // A
+// object ImplicitsBug extends App with Exts { // B
+  //Exts // C) this reference helped in the large project.
+  println(3.moo)
+}
diff --git a/test/files/pos/t6976/ImplicitBug_2.scala b/test/files/pos/t6976/ImplicitBug_2.scala
new file mode 100644
index 0000000000..2fea5e2993
--- /dev/null
+++ b/test/files/pos/t6976/ImplicitBug_2.scala
@@ -0,0 +1,7 @@
+trait Support extends Exts
+
+// object ImplicitsBug extends App with Support { // A
+object ImplicitsBug extends App with Exts { // B
+  //Exts // C) this reference helped in the large project.
+  println(3.moo)
+}
diff --git a/test/files/pos/t7011.flags b/test/files/pos/t7011.flags
new file mode 100644
index 0000000000..a4c161553e
--- /dev/null
+++ b/test/files/pos/t7011.flags
@@ -0,0 +1 @@
+-Ydebug -Xfatal-warnings
\ No newline at end of file
diff --git a/test/files/pos/t7011.scala b/test/files/pos/t7011.scala
new file mode 100644
index 0000000000..539f662bc0
--- /dev/null
+++ b/test/files/pos/t7011.scala
@@ -0,0 +1,7 @@
+object bar {
+	def foo {
+    lazy val x = 42
+
+    {()=>x}
+  }
+}
\ No newline at end of file
diff --git a/test/files/run/t6011c.scala b/test/files/run/t6011c.scala
new file mode 100644
index 0000000000..0647e3f81a
--- /dev/null
+++ b/test/files/run/t6011c.scala
@@ -0,0 +1,13 @@
+object Test extends App {
+  // A variation of SI-6011, which eluded the fix
+  // in 2.10.0.
+  //
+  // duplicate keys in SWITCH, can't pick arbitrarily one of them to evict, see SI-6011.
+  // 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 {
+    case 1 => 2
+    case 1 => 3 // crash
+  }
+}
diff --git a/test/files/run/t6028.check b/test/files/run/t6028.check
index 42921ae2f5..942f3d5f0c 100644
--- a/test/files/run/t6028.check
+++ b/test/files/run/t6028.check
@@ -15,7 +15,7 @@ package <empty> {
       }
     };
     def bar(barParam: Int): Object = {
-      @volatile var MethodLocalObject$module: runtime.VolatileObjectRef = new runtime.VolatileObjectRef(<empty>);
+      @volatile var MethodLocalObject$module: runtime.VolatileObjectRef = new runtime.VolatileObjectRef(null);
       T.this.MethodLocalObject$1(barParam, MethodLocalObject$module)
     };
     def tryy(tryyParam: Int): Function0 = {
diff --git a/test/files/run/t6969.check b/test/files/run/t6969.check
new file mode 100644
index 0000000000..78297812c9
--- /dev/null
+++ b/test/files/run/t6969.check
@@ -0,0 +1 @@
+All threads completed.
diff --git a/test/files/run/t6969.scala b/test/files/run/t6969.scala
new file mode 100644
index 0000000000..8cfc28c1e5
--- /dev/null
+++ b/test/files/run/t6969.scala
@@ -0,0 +1,28 @@
+object Test {
+  private type Clearable = { def clear(): Unit }
+  private def choke() = {
+    try new Array[Object]((Runtime.getRuntime().maxMemory min Int.MaxValue).toInt)
+    catch {
+      case _: OutOfMemoryError => // what do you mean, out of memory?
+      case t: Throwable        => println(t)
+    }
+  }
+  private def f(x: Clearable) = x.clear()
+  class Choker(id: Int) extends Thread {
+    private def g(iteration: Int) = {
+      val map = scala.collection.mutable.Map[Int, Int](1 -> 2)
+      try f(map) catch { case t: NullPointerException => println(s"Failed at $id/$iteration") ; throw t }
+      choke()
+    }
+    override def run() {
+      1 to 50 foreach g
+    }
+  }
+
+  def main(args: Array[String]): Unit = {
+    val threads = 1 to 3 map (id => new Choker(id))
+    threads foreach (_.start())
+    threads foreach (_.join())
+    println("All threads completed.")
+  }
+}
diff --git a/test/files/run/t6987.check b/test/files/run/t6987.check
new file mode 100644
index 0000000000..86fc96c679
--- /dev/null
+++ b/test/files/run/t6987.check
@@ -0,0 +1 @@
+got successful verbose results!
diff --git a/test/files/run/t6987.scala b/test/files/run/t6987.scala
new file mode 100644
index 0000000000..37e91d61ae
--- /dev/null
+++ b/test/files/run/t6987.scala
@@ -0,0 +1,43 @@
+import java.io._
+import tools.nsc.{CompileClient, CompileServer}
+import java.util.concurrent.{CountDownLatch, TimeUnit}
+
+object Test extends App {
+  val startupLatch = new CountDownLatch(1)
+  // we have to explicitly launch our server because when the client launches a server it uses 
+  // the "scala" shell command meaning whatever version of scala (and whatever version of libraries)
+  // happens to be in the path gets used
+  val t = new Thread(new Runnable {
+    def run() = {
+      CompileServer.execute(() => startupLatch.countDown(), Array[String]())
+    }
+  })
+  t setDaemon true
+  t.start()
+  if (!startupLatch.await(2, TimeUnit.MINUTES))
+    sys error "Timeout waiting for server to start"
+
+  val baos = new ByteArrayOutputStream()
+  val ps = new PrintStream(baos) 
+
+  val success = (scala.Console withOut ps) {
+    // shut down the server via the client using the verbose flag
+    CompileClient.process(Array("-shutdown", "-verbose"))
+  }
+
+  // now make sure we got success and a verbose result
+  val msg = baos.toString()
+
+  if (success) {
+    if (msg contains "Settings after normalizing paths") {
+     println("got successful verbose results!")
+    } else {
+     println("did not get the string expected, full results were:")
+     println(msg)
+    }
+  } else {
+    println("got a failure. Full results were:")
+    println(msg)
+  }
+  scala.Console.flush
+}