Merge pull request #5416 from SethTisue/merge-2.12.0-to-2.12.x-sep-24

merge 2.12.0 onto 2.12.x [ci: last-only]

47 files changed, 712 insertions, 219 deletions

diff --git a/.travis.yml b/.travis.yml
index 236e002a5e..c27b362a6c 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -9,15 +9,20 @@ rvm:
 script: bundle exec jekyll build -s spec/ -d build/spec
 install: bundle install
 
-# https://gist.github.com/kzap/5819745, http://docs.travis-ci.com/user/travis-pro/
+# cat /dev/urandom | head -c 10000 | openssl sha1 > ./secret
+# openssl aes-256-cbc -pass "file:./secret" -in id_dsa_spec212_b4096 -out spec/id_dsa_travis.enc -a
+# travis encrypt "PRIV_KEY_SECRET=`cat ./secret`"
 env:
-  - secure: "WWU490z7DWAI8MidMyTE+i+Ppgjg46mdr7PviF6P6ulrPlRRKOtKXpLvzgJoQmluwzEK6/+iH7D5ybCUYMLdKkQM9kSqaXJ0jeqjOelaaa1LmuOQ8IbuT8O9DwHzjjp/n4Lj/KRvvN4nGxCMI7HLla4gunvPA7M6WK7FA+YKCOU=" # set PRIV_KEY_SECRET to password used to encrypt spec/id_dsa_travis.enc
+  - secure: "TuJOUtALynPd+MV1AuMeIpVb8BUBHr7Ul7FS48XhS2PyuTRpEBkSWybYcNg3AXyzmWDAuOjUxbaNMQBvP8vvehTbIYls5H5wTGKvj0D0TNVaPIXjF8bA8KyNat9xGNzhnWm2/2BMaWpKBJWRF7Jb+zHhijMYCJEbkMtoiE5R/mY="
+
+# ^^^ set PRIV_KEY_SECRET to password used to encrypt spec/id_dsa_travis.enc
 
-# using S3 would be simpler, but we want to upload to scala-lang.org
-# after_success: bundle exec s3_website push --headless
 # the key is restricted using forced commands so that it can only upload to the directory we need here
 after_success:
   - openssl aes-256-cbc -pass "pass:$PRIV_KEY_SECRET" -in spec/id_dsa_travis.enc -out spec/id_dsa_travis -d -a
   - chmod 600 spec/id_dsa_travis
   - eval "$(ssh-agent)"
-  - '[ "${TRAVIS_PULL_REQUEST}" = "false" ] && ssh-add -D && ssh-add spec/id_dsa_travis && rsync -e "ssh -o StrictHostKeyChecking=no" -rzv build/spec/ scalatest@chara.epfl.ch:/home/linuxsoft/archives/scala/spec/2.11/'
+  - '[ "${TRAVIS_PULL_REQUEST}" = "false" ] && ssh-add -D && ssh-add spec/id_dsa_travis && rsync -e "ssh -o StrictHostKeyChecking=no" -rzv build/spec/ scalatest@chara.epfl.ch:/home/linuxsoft/archives/scala/spec/2.12/'
+
+# using S3 would be simpler, but we want to upload to scala-lang.org
+# after_success: bundle exec s3_website push --headless
diff --git a/README.md b/README.md
index ea28ba7497..3ffd419aa9 100644
--- a/README.md
+++ b/README.md
@@ -156,8 +156,9 @@ be easily executed locally.
 
 ### IDE Setup
 
-You may use IntelliJ IDEA ([src/intellij/README.md](src/intellij/README.md)) or the
-Scala IDE for Eclipse (see [src/eclipse/README.md](src/eclipse/README.md)).
+You may use IntelliJ IDEA (see [src/intellij/README.md](src/intellij/README.md)),
+the Scala IDE for Eclipse (see [src/eclipse/README.md](src/eclipse/README.md)),
+or ENSIME (see [this page on the ENSIME site](http://ensime.github.io//contributing/scalac/)).
 
 In order to use IntelliJ's incremental compiler:
   - run `dist/mkBin` in sbt to get a build and the runner scripts in `build/quick/bin`
diff --git a/build.sbt b/build.sbt
index 1ffce67465..1ea2ba6386 100644
--- a/build.sbt
+++ b/build.sbt
@@ -88,7 +88,7 @@ lazy val publishSettings : Seq[Setting[_]] = Seq(
 globalVersionSettings
 baseVersion in Global := "2.12.0"
 baseVersionSuffix in Global := "SNAPSHOT"
-mimaReferenceVersion in Global := None
+mimaReferenceVersion in Global := Some("2.12.0-RC1")
 
 lazy val commonSettings = clearSourceAndResourceDirectories ++ publishSettings ++ Seq[Setting[_]](
   organization := "org.scala-lang",
@@ -160,7 +160,7 @@ lazy val commonSettings = clearSourceAndResourceDirectories ++ publishSettings +
         <developers>
           <developer>
             <id>lamp</id>
-            <name>EPFL LAMP</name>
+            <name>LAMP/EPFL</name>
           </developer>
           <developer>
             <id>Lightbend</id>
@@ -406,7 +406,7 @@ lazy val compiler = configureAsSubproject(project)
     ),
     // Generate the ScriptEngineFactory service definition. The Ant build does this when building
     // the JAR but sbt has no support for it and it is easier to do as a resource generator:
-    generateServiceProviderResources("javax.script.ScriptEngineFactory" -> "scala.tools.nsc.interpreter.IMain$Factory"),
+    generateServiceProviderResources("javax.script.ScriptEngineFactory" -> "scala.tools.nsc.interpreter.Scripted$Factory"),
     managedResourceDirectories in Compile := Seq((resourceManaged in Compile).value),
     fixPom(
       "/project/name" -> <name>Scala Compiler</name>,
@@ -510,8 +510,10 @@ lazy val scalap = configureAsSubproject(project)
   )
   .dependsOn(compiler)
 
-lazy val partestExtras = configureAsSubproject(Project("partest-extras", file(".") / "src" / "partest-extras"))
+lazy val partestExtras = Project("partest-extras", file(".") / "src" / "partest-extras")
   .dependsOn(replJlineEmbedded)
+  .settings(commonSettings: _*)
+  .settings(generatePropertiesFileSettings: _*)
   .settings(clearSourceAndResourceDirectories: _*)
   .settings(disableDocs: _*)
   .settings(disablePublishing: _*)
@@ -597,8 +599,6 @@ lazy val partestJavaAgent = Project("partest-javaagent", file(".") / "src" / "pa
     // Setting name to "scala-partest-javaagent" so that the jar file gets that name, which the Runner relies on
     name := "scala-partest-javaagent",
     description := "Scala Compiler Testing Tool (compiler-specific java agent)",
-    // writing jar file to $buildDirectory/pack/lib because that's where it's expected to be found
-    setJarLocation,
     // add required manifest entry - previously included from file
     packageOptions in (Compile, packageBin) +=
       Package.ManifestAttributes( "Premain-Class" -> "scala.tools.partest.javaagent.ProfilingAgent" ),
@@ -834,7 +834,7 @@ lazy val root: Project = (project in file("."))
   )
 
 // The following subprojects' binaries are required for building "pack":
-lazy val distDependencies = Seq(replJline, replJlineEmbedded, compiler, library, partestExtras, partestJavaAgent, reflect, scalap, scaladoc)
+lazy val distDependencies = Seq(replJline, replJlineEmbedded, compiler, library, reflect, scalap, scaladoc)
 
 lazy val dist = (project in file("dist"))
   .settings(commonSettings)
diff --git a/project/VersionUtil.scala b/project/VersionUtil.scala
index 249aef8356..e2c2715320 100644
--- a/project/VersionUtil.scala
+++ b/project/VersionUtil.scala
@@ -18,7 +18,7 @@ object VersionUtil {
   )
 
   lazy val generatePropertiesFileSettings = Seq[Setting[_]](
-    copyrightString := "Copyright 2002-2016, LAMP/EPFL",
+    copyrightString := "Copyright 2002-2016, LAMP/EPFL and Lightbend, Inc.",
     resourceGenerators in Compile += generateVersionPropertiesFile.map(file => Seq(file)).taskValue,
     generateVersionPropertiesFile := generateVersionPropertiesFileImpl.value
   )
diff --git a/project/plugins.sbt b/project/plugins.sbt
index 0a5b8f3dd4..da84d48915 100644
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -19,4 +19,4 @@ buildInfoKeys := Seq[BuildInfoKey](buildClasspath)
 
 buildInfoPackage := "scalabuild"
 
-libraryDependencies += "com.typesafe" %% "mima-reporter" % "0.1.8"
+libraryDependencies += "com.typesafe" %% "mima-reporter" % "0.1.10"
diff --git a/spec/README.md b/spec/README.md
index 1a201fc97c..9fd7c9f6ae 100644
--- a/spec/README.md
+++ b/spec/README.md
@@ -12,7 +12,7 @@ We use Jekyll 2 and [Redcarpet](https://github.com/vmg/redcarpet) to generate th
 
 ## Building
 
-Travis CI builds the spec automatically on every commit to master and publishes to http://www.scala-lang.org/files/archive/spec/2.11/.
+Travis CI builds the spec automatically after every merged pull release and publishes to http://www.scala-lang.org/files/archive/spec/2.12/.
 
 To preview locally, run `bundle exec jekyll serve -d build/spec/ -s spec/ -w --baseurl=""` (in the root of your checkout of scala/scala),
 and open http://0.0.0.0:4000/. Jekyll will rebuild as you edit the markdown, but make sure to restart it when you change `_config.yml`.
diff --git a/spec/_config.yml b/spec/_config.yml
index 74ec602f8f..60e80ee05c 100644
--- a/spec/_config.yml
+++ b/spec/_config.yml
@@ -1,4 +1,4 @@
-baseurl: /files/archive/spec/2.11
+baseurl: /files/archive/spec/2.12
 safe: true
 lsi: false
 highlighter: null
diff --git a/spec/_layouts/default.yml b/spec/_layouts/default.yml
index 7e205f8835..06d8c1c118 100644
--- a/spec/_layouts/default.yml
+++ b/spec/_layouts/default.yml
@@ -31,7 +31,7 @@
 
 <body>
   <header>
-    <nav id="chapters"><a id="github" href="https://github.com/scala/scala/tree/2.11.x/spec"><img src="public/images/github-logo@2x.png" alt="Edit at Github"></a>{% assign sorted_pages = site.pages | sort:"name" %}{% for post in sorted_pages %}{% if post.chapter >= 0 %}<a href="{{site.baseurl}}{{ post.url }}">{{post.chapter}} {{ post.title }}</a>{% endif %}{% endfor %}</nav>
+    <nav id="chapters"><a id="github" href="https://github.com/scala/scala/tree/2.12.x/spec"><img src="public/images/github-logo@2x.png" alt="Edit at GitHub"></a>{% assign sorted_pages = site.pages | sort:"name" %}{% for post in sorted_pages %}{% if post.chapter >= 0 %}<a href="{{site.baseurl}}{{ post.url }}">{{post.chapter}} {{ post.title }}</a>{% endif %}{% endfor %}</nav>
   </header>
   <aside class="left"><nav id="toc"></nav></aside>
 
diff --git a/spec/_layouts/toc.yml b/spec/_layouts/toc.yml
index 4da7d41bea..dfd92eb114 100644
--- a/spec/_layouts/toc.yml
+++ b/spec/_layouts/toc.yml
@@ -19,9 +19,9 @@
   <div id="header-main">
   <img id="scala-logo" src="public/images/scala-spiral-white.png" />
   <span id="title">Scala Language Specification</span>
-  <a id="github" href="https://github.com/scala/scala/tree/2.11.x/spec"><img src="public/images/github-logo@2x.png" alt="Edit at Github"></a>
+  <a id="github" href="https://github.com/scala/scala/tree/2.12.x/spec"><img src="public/images/github-logo@2x.png" alt="Edit at GitHub"></a>
   </div>
-  <div id="header-sub">Version 2.11</div>
+  <div id="header-sub">Version 2.12</div>
 </header>
 <main>
 {{ content }}
diff --git a/spec/id_dsa_travis.enc b/spec/id_dsa_travis.enc
index a9a4036807..16bbd569dc 100644
--- a/spec/id_dsa_travis.enc
+++ b/spec/id_dsa_travis.enc
@@ -1,15 +1,68 @@
-U2FsdGVkX1/RKhLZeL93vFQikKRRkoa3rqt6Kbs7cJStmcTI+DohoRUidRaeSULa
-+xXQCwaSDs4+l1HdW2R4ZV62AVGhvIeKEZxc449c6qT9+wUd2PKkDghuJCy1dLTo
-2OdFLDeop0X32bsauzPQGWwrpb/Llck4KeKffJq2257Hu6T/HnzSfDnvXbjAsVeH
-ZLeXURAyDAdK9vFmFzFiEEztLkW8E3ZVyrk7Qa3GPNpmATiBdhVM8d0JJptKVgwQ
-mZfhbItLrj490sPd5zpUFKAxJjPoKIa75n/+u4butn+ON97vr7xOy6ElX7HSJUgr
-FJdVJgcO7lki0j+lfJVAP0zLnH80CgOkOJSq0Sso/ofs+lQIobo8fQqIdmoqV3z2
-KpYrgnqap1U2+ekIUKsUxk4LuO8uJhwPeMJs6FoDb+O4Aauqpy9242+P05gWkQVd
-KVWRcHVE7DulS8Fp/o5GXJUdw+rdxvQ/voJ8i0HbYpp6UcmQwBheQMSmqtp5+ML9
-rBiBe2sr7pahqI5NKoF3iZCkZW74ge3/GP2d6m2tpOzD+IfdFDXQ/r8DbK2Dvwvz
-eutOb0zrUtua2e2zvvpVxldPVpXA7A1hE0P3lns9o+TqNhEauTQimQ8/X51BHO6E
-Ap4odrf2odocacY5VC4LFYDO3vat0wSTpi6SxkemUMX5yB7euqwD3ZrMcbpPFR1B
-IU5XxW20NxUo8n+WuMUNkXTgk/Cr4OUiavVv4oLsHkmgD9LN3IYI6Rj/DSCzSbDx
-hyWc7R47iu9f5okQScx62DwVK3AyAuVWer94x0Kj8AcIRwU/VwiXjnZ59I89AKTN
-sjZJw1FfpJPqYs7fPtEiotUdaJHzJH8tiEWFrtOTuOg3h6fy0KJTPVh0WjcGXfb6
-Uh1SEgeHtMSUVhq8nd8LGQ==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 --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSyncAndTry.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSyncAndTry.scala
index 3e53419573..466793010f 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSyncAndTry.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSyncAndTry.scala
@@ -73,9 +73,11 @@ abstract class BCodeSyncAndTry extends BCodeBodyBuilder {
       /* ------ (4) exception-handler version of monitor-exit code.
        *            Reached upon abrupt termination of (2).
        *            Protected by whatever protects the whole synchronized expression.
+       *            null => "any" exception in bytecode, like we emit for finally.
+       *            Important not to use j/l/Throwable which dooms the method to a life of interpretation! (SD-233)
        * ------
        */
-      protect(startProtected, endProtected, currProgramPoint(), jlThrowableRef)
+      protect(startProtected, endProtected, currProgramPoint(), null)
       locals.load(monitor)
       emit(asm.Opcodes.MONITOREXIT)
       emit(asm.Opcodes.ATHROW)
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
index 09e82de89b..edb75514e8 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
@@ -114,7 +114,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
     if (classSym == NothingClass) srNothingRef
     else if (classSym == NullClass) srNullRef
     else {
-      val internalName = classSym.javaBinaryName.toString
+      val internalName = classSym.javaBinaryNameString
       classBTypeFromInternalName.getOrElse(internalName, {
         // The new ClassBType is added to the map in its constructor, before we set its info. This
         // allows initializing cyclic dependencies, see the comment on variable ClassBType._info.
@@ -625,7 +625,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
    */
   def mirrorClassClassBType(moduleClassSym: Symbol): ClassBType = {
     assert(isTopLevelModuleClass(moduleClassSym), s"not a top-level module class: $moduleClassSym")
-    val internalName = moduleClassSym.javaBinaryName.dropModule.toString
+    val internalName = moduleClassSym.javaBinaryNameString.stripSuffix(nme.MODULE_SUFFIX_STRING)
     classBTypeFromInternalName.getOrElse(internalName, {
       val c = ClassBType(internalName)
       // class info consistent with BCodeHelpers.genMirrorClass
@@ -642,7 +642,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
   }
 
   def beanInfoClassClassBType(mainClass: Symbol): ClassBType = {
-    val internalName = mainClass.javaBinaryName.toString + "BeanInfo"
+    val internalName = mainClass.javaBinaryNameString + "BeanInfo"
     classBTypeFromInternalName.getOrElse(internalName, {
       val c = ClassBType(internalName)
       c.info = Right(ClassInfo(
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala
index 0a54767f76..6593d4b725 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala
@@ -337,7 +337,7 @@ abstract class GenBCode extends BCodeSyncAndTry {
       bTypes.initializeCoreBTypes()
       bTypes.javaDefinedClasses.clear()
       bTypes.javaDefinedClasses ++= currentRun.symSource collect {
-        case (sym, _) if sym.isJavaDefined => sym.javaBinaryName.toString
+        case (sym, _) if sym.isJavaDefined => sym.javaBinaryNameString
       }
       Statistics.stopTimer(BackendStats.bcodeInitTimer, initStart)
 
diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala
index 8d362f13dd..daf645fd20 100644
--- a/src/compiler/scala/tools/nsc/transform/Constructors.scala
+++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala
@@ -527,7 +527,7 @@ abstract class Constructors extends Statics with Transform with TypingTransforme
             super.transform(tree)
           else if (canBeSupplanted(tree.symbol))
             gen.mkAttributedIdent(parameter(tree.symbol)) setPos tree.pos
-          else if (tree.symbol.outerSource == clazz)
+          else if (tree.symbol.outerSource == clazz && !isDelayedInitSubclass)
             gen.mkAttributedIdent(parameterNamed(nme.OUTER)) setPos tree.pos
           else
             super.transform(tree)
diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala
index 69240b07a1..cc234eb623 100644
--- a/src/compiler/scala/tools/nsc/transform/Erasure.scala
+++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala
@@ -258,7 +258,7 @@ abstract class Erasure extends InfoTransform
     // Anything which could conceivably be a module (i.e. isn't known to be
     // a type parameter or similar) must go through here or the signature is
     // likely to end up with Foo<T>.Empty where it needs Foo<T>.Empty$.
-    def fullNameInSig(sym: Symbol) = "L" + enteringJVM(sym.javaBinaryName)
+    def fullNameInSig(sym: Symbol) = "L" + enteringJVM(sym.javaBinaryNameString)
 
     def jsig(tp0: Type, existentiallyBound: List[Symbol] = Nil, toplevel: Boolean = false, primitiveOK: Boolean = true): String = {
       val tp = tp0.dealias
diff --git a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
index f3d5ceb0f0..7d50c12852 100644
--- a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
+++ b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala
@@ -8,7 +8,7 @@ package tools.nsc
 package transform
 
 import symtab._
-import Flags.{ CASE => _, _ }
+import Flags.{CASE => _, _}
 import scala.collection.mutable.ListBuffer
 
 /** This class ...
diff --git a/src/compiler/scala/tools/nsc/transform/Fields.scala b/src/compiler/scala/tools/nsc/transform/Fields.scala
index a383b65192..aa2ccd9788 100644
--- a/src/compiler/scala/tools/nsc/transform/Fields.scala
+++ b/src/compiler/scala/tools/nsc/transform/Fields.scala
@@ -22,7 +22,7 @@ import symtab.Flags._
   * in the first (closest in the subclassing lattice) subclass (not a trait) of a trait.
   *
   * For lazy vals and modules, we emit accessors that using double-checked locking (DCL) to balance thread safety
-  * and performance. A lazy val gets a compute method for the DCL's slow path, for a module it's all done in the accessor.
+  * and performance. For both lazy vals and modules, the a compute method contains the DCL's slow path.
   *
   * Local lazy vals do not receive bitmaps, but use a Lazy*Holder that has the volatile init bit and the computed value.
   * See `mkLazyLocalDef`.
@@ -193,23 +193,8 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
   // not be emitted as ACC_FINAL. They are FINAL in the Scala sense, though: cannot be overridden.
   private final val ModuleOrLazyFieldFlags = FINAL | PrivateLocal | SYNTHETIC | NEEDS_TREES
 
-  private def newModuleVarSymbol(owner: Symbol, module: Symbol, tp: Type): TermSymbol = {
-//    println(s"new module var in $site for $module of type $tp")
-    val flags = MODULEVAR | (if (owner.isClass) ModuleOrLazyFieldFlags else 0)
-
-    val moduleVar =
-      (owner.newVariable(nme.moduleVarName(module.name.toTermName), module.pos.focus, flags)
-        setInfo tp
-        addAnnotation VolatileAttr)
-
-    moduleOrLazyVarOf(module) = moduleVar
-
-    moduleVar
-  }
-
-  private def moduleInit(module: Symbol) = {
+  private def moduleInit(module: Symbol, moduleVar: Symbol) = {
 //    println(s"moduleInit for $module in ${module.ownerChain} --> ${moduleVarOf.get(module)}")
-    val moduleVar = moduleOrLazyVarOf(module)
     def moduleVarRef = gen.mkAttributedRef(moduleVar)
 
     // for local modules, we synchronize on the owner of the method that owns the module
@@ -236,7 +221,10 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
       *
       * TODO: optimize using local variable?
       */
-    Block(If(needsInit, gen.mkSynchronized(monitorHolder)(If(needsInit, init, EmptyTree)), EmptyTree) :: Nil, moduleVarRef)
+    val computeName = nme.newLazyValSlowComputeName(module.name)
+    val computeMethod = DefDef(NoMods, computeName, Nil, ListOfNil, TypeTree(UnitTpe), gen.mkSynchronized(monitorHolder)(If(needsInit, init, EmptyTree)))
+    Block(computeMethod :: If(needsInit, Apply(Ident(computeName), Nil), EmptyTree) :: Nil,
+      gen.mkCast(moduleVarRef, module.info.resultType))
   }
 
   // NoSymbol for lazy accessor sym with unit result type
@@ -303,6 +291,10 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
       lazyCallingSuper setInfo tp
     }
 
+    private def classNeedsInfoTransform(cls: Symbol): Boolean = {
+      !(cls.isPackageClass || cls.isJavaDefined) && (currentRun.compiles(cls) || refChecks.isSeparatelyCompiledScalaSuperclass(cls))
+    }
+
     def apply(tp0: Type): Type = tp0 match {
       // TODO: make less destructive (name changes, decl additions, flag setting --
       // none of this is actually undone when travelling back in time using atPhase)
@@ -358,9 +350,12 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
           ClassInfoType(parents, allDecls, clazz)
         } else tp
 
+
+      case tp@ClassInfoType(parents, oldDecls, clazz) if !classNeedsInfoTransform(clazz) => tp
+
       // mix in fields & accessors for all mixed in traits
+      case tp@ClassInfoType(parents, oldDecls, clazz) =>
 
-      case tp@ClassInfoType(parents, oldDecls, clazz) if !clazz.isPackageClass =>
         val site = clazz.thisType
 
         // setter conflicts cannot arise independently from a getter conflict, since a setter without a getter does not a val definition make
@@ -371,8 +366,16 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
           (existingGetter ne NoSymbol) && (tp matches (site memberInfo existingGetter).resultType) // !existingGetter.isDeferred && -- see (3)
         }
 
-        def newModuleVarMember(member: Symbol): TermSymbol =
-          newModuleVarSymbol(clazz, member, site.memberType(member).resultType)
+        def newModuleVarMember(module: Symbol): TermSymbol = {
+          val moduleVar =
+            (clazz.newVariable(nme.moduleVarName(module.name.toTermName), module.pos.focus, MODULEVAR | ModuleOrLazyFieldFlags)
+             setInfo site.memberType(module).resultType
+             addAnnotation VolatileAttr)
+
+          moduleOrLazyVarOf(module) = moduleVar
+
+          moduleVar
+        }
 
         def newLazyVarMember(member: Symbol): TermSymbol =
           Fields.this.newLazyVarMember(clazz, member, site.memberType(member).resultType)
@@ -522,7 +525,9 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
     def mkTypedValDef(sym: Symbol, rhs: Tree = EmptyTree) = typedPos(sym.pos)(ValDef(sym, rhs)).asInstanceOf[ValDef]
 
     /**
-      * Desugar a local `lazy val x: Int = rhs` into
+      * Desugar a local `lazy val x: Int = rhs`
+      * or a local `object x { ...}` (the rhs will be instantiating the module's class) into:
+      *
       * ```
       * val x$lzy = new scala.runtime.LazyInt()
       * def x$lzycompute(): Int =
@@ -532,22 +537,24 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
       *  }
       * def x(): Int = if (x$lzy.initialized()) x$lzy.value() else x$lzycompute()
       * ```
+      *
+      * The expansion is the same for local lazy vals and local objects,
+      * except for the suffix of the underlying val's name ($lzy or $module)
       */
-    private def mkLazyLocalDef(lazyVal: Symbol, rhs: Tree): Tree = {
+    private def mkLazyLocalDef(lazySym: Symbol, rhs: Tree): Tree = {
       import CODE._
-      import scala.reflect.NameTransformer.LAZY_LOCAL_SUFFIX_STRING
-      val owner = lazyVal.owner
+      import scala.reflect.{NameTransformer => nx}
+      val owner = lazySym.owner
 
-      val lazyValType = lazyVal.tpe.resultType
+      val lazyValType = lazySym.tpe.resultType
       val refClass    = lazyHolders.getOrElse(lazyValType.typeSymbol, LazyRefClass)
       val isUnit      = refClass == LazyUnitClass
       val refTpe      = if (refClass != LazyRefClass) refClass.tpe else appliedType(refClass.typeConstructor, List(lazyValType))
 
-      val lazyName  = lazyVal.name.toTermName
-      val pos       = lazyVal.pos.focus
+      val lazyName  = lazySym.name.toTermName
+      val pos       = lazySym.pos.focus
 
-      // used twice: once in the same owner as the lazy val, another time inside the compute method
-      val localLazyName = lazyName append LAZY_LOCAL_SUFFIX_STRING
+      val localLazyName = lazyName append (if (lazySym.isModule) nx.MODULE_VAR_SUFFIX_STRING else nx.LAZY_LOCAL_SUFFIX_STRING)
 
       // The lazy holder val need not be mutable, as we write to its field.
       // In fact, it MUST not be mutable to avoid capturing it as an ObjectRef in lambdalift
@@ -567,14 +574,14 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
       val computerSym =
         owner.newMethod(lazyName append nme.LAZY_SLOW_SUFFIX, pos, ARTIFACT | PRIVATE) setInfo MethodType(Nil, lazyValType)
 
-      val rhsAtComputer = rhs.changeOwner(lazyVal -> computerSym)
+      val rhsAtComputer = rhs.changeOwner(lazySym -> computerSym)
 
       val computer = mkAccessor(computerSym)(gen.mkSynchronized(Ident(holderSym))(
         If(initialized, getValue,
           if (isUnit) Block(rhsAtComputer :: Nil, Apply(initialize, Nil))
           else Apply(initialize, rhsAtComputer :: Nil))))
 
-      val accessor = mkAccessor(lazyVal)(
+      val accessor = mkAccessor(lazySym)(
         If(initialized, getValue,
           Apply(Ident(computerSym), Nil)))
 
@@ -582,68 +589,87 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
       // remove STABLE: prevent replacing accessor call of type Unit by BoxedUnit.UNIT in erasure
       // remove ACCESSOR: prevent constructors from eliminating the method body if the lazy val is
       // lifted into a trait (TODO: not sure about the details here)
-      lazyVal.resetFlag(STABLE | ACCESSOR)
+      lazySym.resetFlag(STABLE | ACCESSOR)
 
       Thicket(mkTypedValDef(holderSym, New(refTpe)) :: computer :: accessor :: Nil)
     }
 
     // synth trees for accessors/fields and trait setters when they are mixed into a class
-    def fieldsAndAccessors(clazz: Symbol): List[ValOrDefDef] = {
-      def fieldAccess(accessor: Symbol): List[Tree] = {
-        val fieldName = accessor.localName
-        val field = clazz.info.decl(fieldName)
-        // The `None` result denotes an error, but it's refchecks' job to report it (this fallback is for robustness).
-        // This is the result of overriding a val with a def, so that no field is found in the subclass.
-        if (field.exists) List(Select(This(clazz), field))
-        else Nil
-      }
-
-      def getterBody(getter: Symbol): List[Tree] = {
+    def fieldsAndAccessors(clazz: Symbol): List[Tree] = {
+      // scala/scala-dev#219
+      // Cast to avoid spurious mismatch in paths containing trait vals that have
+      // not been rebound to accessors in the subclass we're in now.
+      // For example, for a lazy val mixed into a class, the lazy var's info
+      // will not refer to symbols created during our info transformer,
+      // so if its type depends on a val that is now implemented after the info transformer,
+      // we'll get a mismatch when assigning `rhs` to `lazyVarOf(getter)`.
+      // TODO: could we rebind more aggressively? consider overriding in type equality?
+      def cast(tree: Tree, pt: Type) = gen.mkAsInstanceOf(tree, pt)
+
+      // Could be NoSymbol, which denotes an error, but it's refchecks' job to report it (this fallback is for robustness).
+      // This is the result of overriding a val with a def, so that no field is found in the subclass.
+      def fieldAccess(accessor: Symbol): Symbol =
+        afterOwnPhase { clazz.info.decl(accessor.localName) }
+
+      def getterBody(getter: Symbol): Tree =
         // accessor created by newMatchingModuleAccessor for a static module that does need an accessor
         // (because there's a matching member in a super class)
-        if (getter.asTerm.referenced.isModule) {
-          List(gen.mkAttributedRef(clazz.thisType, getter.asTerm.referenced))
-        } else {
+        if (getter.asTerm.referenced.isModule)
+          mkAccessor(getter)(cast(Select(This(clazz), getter.asTerm.referenced), getter.info.resultType))
+        else {
           val fieldMemoization = fieldMemoizationIn(getter, clazz)
-          if (fieldMemoization.constantTyped) List(gen.mkAttributedQualifier(fieldMemoization.tp)) // TODO: drop when we no longer care about producing identical bytecode
-          else fieldAccess(getter)
+          // TODO: drop getter for constant? (when we no longer care about producing identical bytecode?)
+          if (fieldMemoization.constantTyped) mkAccessor(getter)(gen.mkAttributedQualifier(fieldMemoization.tp))
+          else fieldAccess(getter) match {
+            case NoSymbol => EmptyTree
+            case fieldSel => mkAccessor(getter)(cast(Select(This(clazz), fieldSel), getter.info.resultType))
+          }
         }
-      }
 
       //      println(s"accessorsAndFieldsNeedingTrees for $templateSym: $accessorsAndFieldsNeedingTrees")
-      def setterBody(setter: Symbol): List[Tree] = {
+      def setterBody(setter: Symbol): Tree =
         // trait setter in trait
-        if (clazz.isTrait) List(EmptyTree)
+        if (clazz.isTrait) mkAccessor(setter)(EmptyTree)
         // trait setter for overridden val in class
-        else if (checkAndClearOverriddenTraitSetter(setter)) List(mkTypedUnit(setter.pos))
+        else if (checkAndClearOverriddenTraitSetter(setter)) mkAccessor(setter)(mkTypedUnit(setter.pos))
         // trait val/var setter mixed into class
-        else fieldAccess(setter) map (fieldSel => Assign(fieldSel, Ident(setter.firstParam)))
-      }
+        else fieldAccess(setter) match {
+          case NoSymbol => EmptyTree
+          case fieldSel => afterOwnPhase { // the assign only type checks after our phase (assignment to val)
+            mkAccessor(setter)(Assign(Select(This(clazz), fieldSel), cast(Ident(setter.firstParam), fieldSel.info)))
+          }
+        }
 
-      def moduleAccessorBody(module: Symbol): List[Tree] = List(
+      def moduleAccessorBody(module: Symbol): Tree =
         // added during synthFieldsAndAccessors using newModuleAccessor
         // a module defined in a trait by definition can't be static (it's a member of the trait and thus gets a new instance for every outer instance)
-        if (clazz.isTrait) EmptyTree
+        if (clazz.isTrait) mkAccessor(module)(EmptyTree)
         // symbol created by newModuleAccessor for a (non-trait) class
-        else moduleInit(module)
-      )
+        else {
+          mkAccessor(module)(moduleInit(module, moduleOrLazyVarOf(module)))
+        }
 
       val synthAccessorInClass = new SynthLazyAccessorsIn(clazz)
-      def superLazy(getter: Symbol): List[ValOrDefDef] = {
+      def superLazy(getter: Symbol): Tree = {
         assert(!clazz.isTrait)
-        // this contortion was the only way I can get the super select to be type checked correctly.. TODO: why does SelectSuper not work?
-        val rhs = Apply(Select(Super(This(clazz), tpnme.EMPTY), getter.name), Nil)
-        explodeThicket(synthAccessorInClass.expandLazyClassMember(lazyVarOf(getter), getter, rhs, Map.empty)).asInstanceOf[List[ValOrDefDef]]
+        // this contortion was the only way I can get the super select to be type checked correctly..
+        // TODO: why does SelectSuper not work?
+        val selectSuper = Select(Super(This(clazz), tpnme.EMPTY), getter.name)
+
+        val lazyVar = lazyVarOf(getter)
+        val rhs = cast(Apply(selectSuper, Nil), lazyVar.info)
+
+        synthAccessorInClass.expandLazyClassMember(lazyVar, getter, rhs, Map.empty)
       }
 
-      clazz.info.decls.toList.filter(checkAndClearNeedsTrees) flatMap {
-        case module if module hasAllFlags (MODULE | METHOD) => moduleAccessorBody(module) map mkAccessor(module)
+      (afterOwnPhase { clazz.info.decls } toList) filter checkAndClearNeedsTrees map {
+        case module if module hasAllFlags (MODULE | METHOD) => moduleAccessorBody(module)
         case getter if getter hasAllFlags (LAZY | METHOD)   => superLazy(getter)
-        case setter if setter.isSetter                      => setterBody(setter) map mkAccessor(setter)
-        case getter if getter.hasFlag(ACCESSOR)             => getterBody(getter) map mkAccessor(getter)
-        case field  if !(field hasFlag METHOD)              => Some(mkTypedValDef(field)) // vals/vars and module vars (cannot have flags PACKAGE | JAVA since those never receive NEEDS_TREES)
-        case _ => None
-      }
+        case setter if setter.isSetter                      => setterBody(setter)
+        case getter if getter.hasFlag(ACCESSOR)             => getterBody(getter)
+        case field  if !(field hasFlag METHOD)              => mkTypedValDef(field) // vals/vars and module vars (cannot have flags PACKAGE | JAVA since those never receive NEEDS_TREES)
+        case _ => EmptyTree
+      } filterNot (_ == EmptyTree) // there will likely be many EmptyTrees, but perhaps no thicket blocks that need expanding
     }
 
     def rhsAtOwner(stat: ValOrDefDef, newOwner: Symbol): Tree =
@@ -694,7 +720,7 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
 
         // drop the val for (a) constant (pure & not-stored) and (b) not-stored (but still effectful) fields
         case ValDef(mods, _, _, rhs) if (rhs ne EmptyTree) && !excludedAccessorOrFieldByFlags(statSym)
-                                        && fieldMemoizationIn(statSym, currOwner).constantTyped =>
+                                        && currOwner.isClass && fieldMemoizationIn(statSym, currOwner).constantTyped =>
           EmptyThicket
 
         case ModuleDef(_, _, impl) =>
@@ -702,8 +728,9 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
           val cd = super.transform(ClassDef(statSym.moduleClass, impl) setType NoType)
           if (currOwner.isClass) cd
           else { // local module -- symbols cannot be generated by info transformer, so do it all here
-            val moduleVar = newModuleVarSymbol(currOwner, statSym, statSym.info.resultType)
-            Thicket(cd :: mkTypedValDef(moduleVar) :: mkAccessor(statSym)(moduleInit(statSym)) :: Nil)
+            val Block(stats, _) = mkLazyLocalDef(statSym, gen.newModule(statSym, statSym.info.resultType))
+
+            Thicket(cd :: stats)
           }
 
         case tree =>
@@ -721,8 +748,13 @@ abstract class Fields extends InfoTransform with ast.TreeDSL with TypingTransfor
 
     override def transformStats(stats: List[Tree], exprOwner: Symbol): List[Tree] = {
       val addedStats =
-        if (!currentOwner.isClass) Nil // TODO: || currentOwner.isPackageClass
-        else afterOwnPhase { fieldsAndAccessors(currentOwner) }
+        if (!currentOwner.isClass || currentOwner.isPackageClass) Nil
+        else {
+          val thickets = fieldsAndAccessors(currentOwner)
+          if (thickets exists mustExplodeThicket)
+            thickets flatMap explodeThicket
+          else thickets
+        }
 
       val inRealClass = currentOwner.isClass && !(currentOwner.isPackageClass || currentOwner.isTrait)
       if (inRealClass)
diff --git a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
index 74e6c58388..798cfcd072 100644
--- a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
+++ b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
@@ -104,8 +104,31 @@ abstract class LambdaLift extends InfoTransform {
     /** Buffers for lifted out classes and methods */
     private val liftedDefs = new LinkedHashMap[Symbol, List[Tree]]
 
+    val delayedInitDummies = new mutable.HashMap[Symbol, Symbol]
+
+    /**
+     * For classes capturing locals, LambdaLift uses `local.logicallyEnclosingMember` to decide
+     * whether an access to the local is re-written to the field or constructor parameter. If the
+     * access is in a constructor statement, the constructor parameter is used.
+     *
+     * For DelayedInit subclasses, constructor statements end up in the synthetic init method
+     * instead of the constructor itself, so the access should go to the field. This method changes
+     * `logicallyEnclosingMember` in this case to return a temprorary symbol corresponding to that
+     * method.
+     */
+    private def logicallyEnclosingMember(sym: Symbol): Symbol = {
+      if (sym.isLocalDummy) {
+        val enclClass = sym.enclClass
+        if (enclClass.isSubClass(DelayedInitClass))
+          delayedInitDummies.getOrElseUpdate(enclClass, enclClass.newMethod(nme.delayedInit))
+        else
+          enclClass.primaryConstructor
+      } else if (sym.isMethod || sym.isClass || sym == NoSymbol) sym
+      else logicallyEnclosingMember(sym.owner)
+    }
+
     private def isSameOwnerEnclosure(sym: Symbol) =
-      sym.owner.logicallyEnclosingMember == currentOwner.logicallyEnclosingMember
+      logicallyEnclosingMember(sym.owner) == logicallyEnclosingMember(currentOwner)
 
     /** Mark symbol `sym` as being free in `enclosure`, unless `sym`
      *  is defined in `enclosure` or there is a class between `enclosure`s owner
@@ -139,9 +162,9 @@ abstract class LambdaLift extends InfoTransform {
      */
     private def markFree(sym: Symbol, enclosure: Symbol): Boolean = {
 //      println(s"mark free: ${sym.fullLocationString} marked free in $enclosure")
-      (enclosure == sym.owner.logicallyEnclosingMember) || {
-        debuglog("%s != %s".format(enclosure, sym.owner.logicallyEnclosingMember))
-        if (enclosure.isPackageClass || !markFree(sym, enclosure.skipConstructor.owner.logicallyEnclosingMember)) false
+      (enclosure == logicallyEnclosingMember(sym.owner)) || {
+        debuglog("%s != %s".format(enclosure, logicallyEnclosingMember(sym.owner)))
+        if (enclosure.isPackageClass || !markFree(sym, logicallyEnclosingMember(enclosure.skipConstructor.owner))) false
         else {
           val ss = symSet(free, enclosure)
           if (!ss(sym)) {
@@ -184,14 +207,14 @@ abstract class LambdaLift extends InfoTransform {
             if (sym == NoSymbol) {
               assert(name == nme.WILDCARD)
             } else if (sym.isLocalToBlock) {
-              val owner = currentOwner.logicallyEnclosingMember
+              val owner = logicallyEnclosingMember(currentOwner)
               if (sym.isTerm && !sym.isMethod) markFree(sym, owner)
               else if (sym.isMethod) markCalled(sym, owner)
                 //symSet(called, owner) += sym
             }
           case Select(_, _) =>
             if (sym.isConstructor && sym.owner.isLocalToBlock)
-              markCalled(sym, currentOwner.logicallyEnclosingMember)
+              markCalled(sym, logicallyEnclosingMember(currentOwner))
           case _ =>
         }
         super.traverse(tree)
@@ -283,17 +306,18 @@ abstract class LambdaLift extends InfoTransform {
 
     private def proxy(sym: Symbol) = {
       def searchIn(enclosure: Symbol): Symbol = {
-        if (enclosure eq NoSymbol) throw new IllegalArgumentException("Could not find proxy for "+ sym.defString +" in "+ sym.ownerChain +" (currentOwner= "+ currentOwner +" )")
-        debuglog("searching for " + sym + "(" + sym.owner + ") in " + enclosure + " " + enclosure.logicallyEnclosingMember)
+        if (enclosure eq NoSymbol)
+          throw new IllegalArgumentException("Could not find proxy for "+ sym.defString +" in "+ sym.ownerChain +" (currentOwner= "+ currentOwner +" )")
+        debuglog("searching for " + sym + "(" + sym.owner + ") in " + enclosure + " " + logicallyEnclosingMember(enclosure))
 
         val proxyName = proxyNames.getOrElse(sym, sym.name)
-        val ps = (proxies get enclosure.logicallyEnclosingMember).toList.flatten find (_.name == proxyName)
+        val ps = (proxies get logicallyEnclosingMember(enclosure)).toList.flatten find (_.name == proxyName)
         ps getOrElse searchIn(enclosure.skipConstructor.owner)
       }
       debuglog("proxy %s from %s has logical enclosure %s".format(
         sym.debugLocationString,
         currentOwner.debugLocationString,
-        sym.owner.logicallyEnclosingMember.debugLocationString)
+        logicallyEnclosingMember(sym.owner).debugLocationString)
       )
 
       if (isSameOwnerEnclosure(sym)) sym
@@ -319,7 +343,14 @@ abstract class LambdaLift extends InfoTransform {
           else if (clazz.isStaticOwner) gen.mkAttributedQualifier(clazz.thisType)
           else outerValue match {
             case EmptyTree => prematureSelfReference()
-            case o         => outerPath(o, currentClass.outerClass, clazz)
+            case o         =>
+              val path = outerPath(o, currentClass.outerClass, clazz)
+              if (path.tpe <:< clazz.tpeHK) path
+              else {
+                // SI-9920 The outer accessor might have an erased type of the self type of a trait,
+                //         rather than the trait itself. Add a cast if necessary.
+                gen.mkAttributedCast(path, clazz.tpeHK)
+              }
           }
         }
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
index 8034d056d7..106b076eef 100644
--- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
@@ -95,6 +95,15 @@ abstract class RefChecks extends Transform {
       )
   }
 
+  private val separatelyCompiledScalaSuperclass = perRunCaches.newAnyRefMap[Symbol, Unit]()
+  final def isSeparatelyCompiledScalaSuperclass(sym: Symbol) = if (globalPhase.refChecked){
+    separatelyCompiledScalaSuperclass.contains(sym)
+  } else {
+    // conservative approximation in case someone in pre-refchecks phase asks for `exitingFields(someClass.info)`
+    // and we haven't run the refchecks tree transform which populates `separatelyCompiledScalaSuperclass`
+    false
+  }
+
   class RefCheckTransformer(unit: CompilationUnit) extends Transformer {
 
     var localTyper: analyzer.Typer = typer
@@ -854,6 +863,8 @@ abstract class RefChecks extends Transform {
 //            println("validate base type "+tp)
         val baseClass = tp.typeSymbol
         if (baseClass.isClass) {
+          if (!baseClass.isTrait && !baseClass.isJavaDefined && !currentRun.compiles(baseClass) && !separatelyCompiledScalaSuperclass.contains(baseClass))
+            separatelyCompiledScalaSuperclass.update(baseClass, ())
           val index = clazz.info.baseTypeIndex(baseClass)
           if (index >= 0) {
             if (seenTypes(index) forall (tp1 => !(tp1 <:< tp)))
diff --git a/src/ensime/.ensime.SAMPLE b/src/ensime/.ensime.SAMPLE
deleted file mode 100644
index 10801816b7..0000000000
--- a/src/ensime/.ensime.SAMPLE
+++ /dev/null
@@ -1,17 +0,0 @@
-(
-  :disable-source-load-on-startup t
-  :disable-scala-jars-on-classpath t
-  :root-dir "c:/Projects/Kepler"
-  :sources (
-    "c:/Projects/Kepler/src/library"
-    "c:/Projects/Kepler/src/reflect"
-    "c:/Projects/Kepler/src/compiler"
-  )
-  :compile-deps (
-    "c:/Projects/Kepler/build/asm/classes"
-    "c:/Projects/Kepler/build/locker/classes/library"
-    "c:/Projects/Kepler/build/locker/classes/reflect"
-    "c:/Projects/Kepler/build/locker/classes/compiler"
-  )
-  :target "c:/Projects/Kepler/build/classes"
-)
\ No newline at end of file
diff --git a/src/ensime/README.md b/src/ensime/README.md
deleted file mode 100644
index 302d47b8a7..0000000000
--- a/src/ensime/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
-Ensime project files
-=====================
-
-Rename .ensime.SAMPLE to .ensime and replace sample paths with real paths to your sources and build results.
-After that you're good to go with one of the ENSIME-enabled text editors.
-
-Editors that know how to talk to ENSIME servers:
-1) Emacs via https://github.com/aemoncannon/ensime
-2) jEdit via https://github.com/djspiewak/ensime-sidekick
-3) TextMate via https://github.com/mads379/ensime.tmbundle
-4) Sublime Text 2 via https://github.com/sublimescala/sublime-ensime
diff --git a/src/library/scala/reflect/NameTransformer.scala b/src/library/scala/reflect/NameTransformer.scala
index ae36f5edc2..bdf5165df5 100644
--- a/src/library/scala/reflect/NameTransformer.scala
+++ b/src/library/scala/reflect/NameTransformer.scala
@@ -13,15 +13,16 @@ package reflect
  *  Also provides some constants.
  */
 object NameTransformer {
-  // XXX Short term: providing a way to alter these without having to recompile
-  // the compiler before recompiling the compiler.
-  val MODULE_SUFFIX_STRING          = sys.props.getOrElse("SCALA_MODULE_SUFFIX_STRING", "$")
-  val NAME_JOIN_STRING              = sys.props.getOrElse("SCALA_NAME_JOIN_STRING", "$")
-  val MODULE_INSTANCE_NAME          = "MODULE$"
-  val LOCAL_SUFFIX_STRING           = " "
-  val LAZY_LOCAL_SUFFIX_STRING      = "$lzy"
-  val SETTER_SUFFIX_STRING          = "_$eq"
-  val TRAIT_SETTER_SEPARATOR_STRING = "$_setter_$"
+  // TODO: reduce duplication with and in StdNames
+  // I made these constants because we cannot change them without bumping our major version anyway.
+  final val NAME_JOIN_STRING              = "$"
+  final val MODULE_SUFFIX_STRING          = "$"
+  final val MODULE_INSTANCE_NAME          = "MODULE$"
+  final val LOCAL_SUFFIX_STRING           = " "
+  final val LAZY_LOCAL_SUFFIX_STRING      = "$lzy"
+  final val MODULE_VAR_SUFFIX_STRING      = "$module"
+  final val SETTER_SUFFIX_STRING          = "_$eq"
+  final val TRAIT_SETTER_SEPARATOR_STRING = "$_setter_$"
 
   private val nops = 128
   private val ncodes = 26 * 26
diff --git a/src/library/scala/util/Either.scala b/src/library/scala/util/Either.scala
index 169786d31b..c332f18295 100644
--- a/src/library/scala/util/Either.scala
+++ b/src/library/scala/util/Either.scala
@@ -95,13 +95,15 @@ sealed abstract class Either[+A, +B] extends Product with Serializable {
   /**
    * Projects this `Either` as a `Left`.
    */
-  @deprecated("use swap instead", "2.12.0")
   def left = Either.LeftProjection(this)
 
   /**
    * Projects this `Either` as a `Right`.
+   *
+   * Because `Either` is right-biased, this method is not normally needed.
+   * (It is retained in the API for now for easy cross-compilation between Scala
+   * 2.11 and 2.12.)
    */
-  @deprecated("Either is now right-biased", "2.12.0")
   def right = Either.RightProjection(this)
 
   /**
@@ -245,7 +247,7 @@ sealed abstract class Either[+A, +B] extends Product with Serializable {
 
   /**
    * Returns `true` if `Left` or returns the result of the application of
-   * the given function to the `Right` value.
+   * the given predicate to the `Right` value.
    *
    * {{{
    * Right(12).forall(_ > 10) // true
@@ -260,7 +262,7 @@ sealed abstract class Either[+A, +B] extends Product with Serializable {
 
   /**
    * Returns `false` if `Left` or returns the result of the application of
-   * the given function to the `Right` value.
+   * the given predicate to the `Right` value.
    *
    * {{{
    * Right(12).exists(_ > 10) // true
@@ -426,7 +428,10 @@ object Either {
   /**
    * Projects an `Either` into a `Left`.
    *
-   * This allows for-comprehensions over Either instances - for example {{{
+   * This allows for-comprehensions over the left side of Either instances,
+   * reversing Either's usual right-bias.
+   *
+   * For example {{{
    * for (s <- Left("flower").left) yield s.length // Left(6)
    * }}}
    *
@@ -472,7 +477,6 @@ object Either {
    * @author <a href="mailto:research@workingmouse.com">Tony Morris</a>, Workingmouse
    * @version 1.0, 11/10/2008
    */
-  @deprecated("use swap instead", "2.12.0")
   final case class LeftProjection[+A, +B](e: Either[A, B]) {
     /**
      * Returns the value from this `Left` or throws `java.util.NoSuchElementException`
@@ -624,19 +628,13 @@ object Either {
   /**
    * Projects an `Either` into a `Right`.
    *
-   * This allows for-comprehensions over Either instances - for example {{{
-   * for (s <- Right("flower").right) yield s.length // Right(6)
-   * }}}
-   *
-   * Continuing the analogy with [[scala.Option]], a `RightProjection` declares
-   * that `Right` should be analogous to `Some` in some code.
-   *
-   * Analogous to `LeftProjection`, see example usage in its documentation above.
+   * Because `Either` is already right-biased, this class is not normally needed.
+   * (It is retained in the library for now for easy cross-compilation between Scala
+   * 2.11 and 2.12.)
    *
    * @author <a href="mailto:research@workingmouse.com">Tony Morris</a>, Workingmouse
    * @version 1.0, 11/10/2008
    */
-  @deprecated("Either is now right-biased", "2.12.0")
   final case class RightProjection[+A, +B](e: Either[A, B]) {
 
     /**
diff --git a/src/library/scala/util/Properties.scala b/src/library/scala/util/Properties.scala
index a176748cd6..fc2302d148 100644
--- a/src/library/scala/util/Properties.scala
+++ b/src/library/scala/util/Properties.scala
@@ -105,7 +105,7 @@ private[scala] trait PropertiesTrait {
    *  or "version (unknown)" if it cannot be determined.
    */
   val versionString         = "version " + scalaPropOrElse("version.number", "(unknown)")
-  val copyrightString       = scalaPropOrElse("copyright.string", "Copyright 2002-2016, LAMP/EPFL")
+  val copyrightString       = scalaPropOrElse("copyright.string", "Copyright 2002-2016, LAMP/EPFL and Lightbend, Inc.")
 
   /** This is the encoding to use reading in source files, overridden with -encoding.
    *  Note that it uses "prop" i.e. looks in the scala jar, not the system properties.
diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala
index 1a6c84b19e..2e820a68e0 100644
--- a/src/reflect/scala/reflect/internal/StdNames.scala
+++ b/src/reflect/scala/reflect/internal/StdNames.scala
@@ -92,14 +92,15 @@ trait StdNames {
     def flattenedName(segments: Name*): NameType =
       compactify(segments mkString NAME_JOIN_STRING)
 
-    val NAME_JOIN_STRING: String              = NameTransformer.NAME_JOIN_STRING
-    val MODULE_SUFFIX_STRING: String          = NameTransformer.MODULE_SUFFIX_STRING
-    val LOCAL_SUFFIX_STRING: String           = NameTransformer.LOCAL_SUFFIX_STRING
-    val LAZY_LOCAL_SUFFIX_STRING: String      = NameTransformer.LAZY_LOCAL_SUFFIX_STRING
-
-    val TRAIT_SETTER_SEPARATOR_STRING: String = NameTransformer.TRAIT_SETTER_SEPARATOR_STRING
-
-    val SINGLETON_SUFFIX: String     = ".type"
+    // TODO: what is the purpose of all this duplication!?!?!
+    // I made these constants because we cannot change them without bumping our major version anyway.
+    final val NAME_JOIN_STRING                 = NameTransformer.NAME_JOIN_STRING
+    final val MODULE_SUFFIX_STRING             = NameTransformer.MODULE_SUFFIX_STRING
+    final val MODULE_VAR_SUFFIX_STRING         = NameTransformer.MODULE_VAR_SUFFIX_STRING
+    final val LOCAL_SUFFIX_STRING              = NameTransformer.LOCAL_SUFFIX_STRING
+    final val LAZY_LOCAL_SUFFIX_STRING         = NameTransformer.LAZY_LOCAL_SUFFIX_STRING
+    final val TRAIT_SETTER_SEPARATOR_STRING    = NameTransformer.TRAIT_SETTER_SEPARATOR_STRING
+    final val SINGLETON_SUFFIX                 = ".type"
 
     val ANON_CLASS_NAME: NameType              = "$anon"
     val DELAMBDAFY_LAMBDA_CLASS_NAME: NameType = "$lambda"
@@ -108,7 +109,7 @@ trait StdNames {
     val EMPTY_PACKAGE_NAME: NameType           = "<empty>"
     val IMPORT: NameType                       = "<import>"
     val MODULE_SUFFIX_NAME: NameType           = MODULE_SUFFIX_STRING
-    val MODULE_VAR_SUFFIX: NameType            = "$module"
+    val MODULE_VAR_SUFFIX: NameType            = MODULE_VAR_SUFFIX_STRING
     val PACKAGE: NameType                      = "package"
     val ROOT: NameType                         = "<root>"
     val SPECIALIZED_SUFFIX: NameType           = "$sp"
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index ac025e50ae..f870ecfc15 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -2166,7 +2166,6 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     final def logicallyEnclosingMember: Symbol =
       if (isLocalDummy) enclClass.primaryConstructor
       else if (isMethod || isClass || this == NoSymbol) this
-      else if (this == NoSymbol) { devWarningDumpStack("NoSymbol.logicallyEnclosingMember", 15); this }
       else owner.logicallyEnclosingMember
 
     /** The top-level class containing this symbol. */
diff --git a/test/files/pos/sd219.scala b/test/files/pos/sd219.scala
new file mode 100644
index 0000000000..3c3f4962f0
--- /dev/null
+++ b/test/files/pos/sd219.scala
@@ -0,0 +1,11 @@
+class Global { class Name }
+
+trait CommonPrintUtils {
+  val global: Global 
+  
+  lazy val precedence: global.Name => Int = ???
+}
+
+trait CompilerProvider {  val global: Global = ??? }
+    
+class AbstractPrinter extends CommonPrintUtils with CompilerProvider 
\ No newline at end of file
diff --git a/test/files/pos/shapeless-regression.scala b/test/files/pos/shapeless-regression.scala
new file mode 100644
index 0000000000..f3a1ed1ba0
--- /dev/null
+++ b/test/files/pos/shapeless-regression.scala
@@ -0,0 +1,16 @@
+class W[T <: AnyRef](val t: T) {
+  val v: T {} = t
+}
+
+object W {
+  def apply[T <: AnyRef](t: T) = new W[t.type](t)
+}
+
+object RightAssoc {
+  def ra_:[T](t: T): Unit = ()
+}
+
+object Boom {
+  W("fooo").v ra_: RightAssoc
+}
+
diff --git a/test/files/pos/t9918/package.scala b/test/files/pos/t9918/package.scala
new file mode 100644
index 0000000000..9bd8ac9a69
--- /dev/null
+++ b/test/files/pos/t9918/package.scala
@@ -0,0 +1 @@
+package object pkg extends T
diff --git a/test/files/pos/t9918/t9918.scala b/test/files/pos/t9918/t9918.scala
new file mode 100644
index 0000000000..ec9a146579
--- /dev/null
+++ b/test/files/pos/t9918/t9918.scala
@@ -0,0 +1,3 @@
+package pkg
+
+trait T { object O }
diff --git a/test/files/pos/t9920.scala b/test/files/pos/t9920.scala
new file mode 100644
index 0000000000..8612618cc4
--- /dev/null
+++ b/test/files/pos/t9920.scala
@@ -0,0 +1,6 @@
+object Test {
+  def o = {
+    def i: Int = { i; 0 }
+    i
+  }
+}
diff --git a/test/files/run/SD-235.scala b/test/files/run/SD-235.scala
new file mode 100644
index 0000000000..eb79c6fe71
--- /dev/null
+++ b/test/files/run/SD-235.scala
@@ -0,0 +1,39 @@
+class C {
+  var ORef: Object = null
+  def test = {
+    object O {
+      assert(!Thread.holdsLock(C.this))
+      assert(Thread.holdsLock(ORef))
+    }
+    val captor = new { def oh = O }
+    val refField = captor.getClass.getDeclaredFields.last
+    refField.setAccessible(true)
+    assert(refField.getType.toString.contains("LazyRef"), refField)
+    ORef = refField.get(captor)
+    O
+  }
+}
+
+class D {
+  var ORef: Object = null
+  def test = {
+    lazy val O = {
+      assert(!Thread.holdsLock(D.this))
+      assert(Thread.holdsLock(ORef))
+      "O"
+    }
+    val captor = new { def oh = O }
+    val refField = captor.getClass.getDeclaredFields.last
+    refField.setAccessible(true)
+    assert(refField.getType.toString.contains("LazyRef"), refField)
+    ORef = refField.get(captor)
+    O
+  }
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    new C().test
+    new D().test
+  }
+}
diff --git a/test/files/run/delambdafy_t6028.check b/test/files/run/delambdafy_t6028.check
index eaba70ee1a..86cb1d5e97 100644
--- a/test/files/run/delambdafy_t6028.check
+++ b/test/files/run/delambdafy_t6028.check
@@ -15,7 +15,7 @@ package <empty> {
       }
     };
     def bar(barParam: String): Object = {
-      @volatile var MethodLocalObject$module: runtime.VolatileObjectRef = scala.runtime.VolatileObjectRef.zero();
+      lazy <artifact> val MethodLocalObject$module: scala.runtime.LazyRef = new scala.runtime.LazyRef();
       T.this.MethodLocalObject$1(barParam, MethodLocalObject$module)
     };
     def tryy(tryyParam: String): Function0 = {
@@ -42,12 +42,14 @@ package <empty> {
       <synthetic> <stable> <artifact> def $outer(): T = MethodLocalObject$2.this.$outer;
       <synthetic> <stable> <artifact> def $outer(): T = MethodLocalObject$2.this.$outer
     };
-    final <stable> private[this] def MethodLocalObject$1(barParam$1: String, MethodLocalObject$module$1: runtime.VolatileObjectRef): T#MethodLocalObject$2.type = {
-      if (MethodLocalObject$module$1.elem.$asInstanceOf[T#MethodLocalObject$2.type]().eq(null))
-        T.this.synchronized[Unit](if (MethodLocalObject$module$1.elem.$asInstanceOf[T#MethodLocalObject$2.type]().eq(null))
-          MethodLocalObject$module$1.elem = new T#MethodLocalObject$2.type(T.this, barParam$1));
-      MethodLocalObject$module$1.elem.$asInstanceOf[T#MethodLocalObject$2.type]()
-    };
+    final <artifact> private[this] def MethodLocalObject$lzycompute$1(barParam$1: String, MethodLocalObject$module$1: scala.runtime.LazyRef): T#MethodLocalObject$2.type = MethodLocalObject$module$1.synchronized[T#MethodLocalObject$2.type](if (MethodLocalObject$module$1.initialized())
+      MethodLocalObject$module$1.value().$asInstanceOf[T#MethodLocalObject$2.type]()
+    else
+      MethodLocalObject$module$1.initialize(new T#MethodLocalObject$2.type(T.this, barParam$1)).$asInstanceOf[T#MethodLocalObject$2.type]());
+    final private[this] def MethodLocalObject$1(barParam$1: String, MethodLocalObject$module$1: scala.runtime.LazyRef): T#MethodLocalObject$2.type = if (MethodLocalObject$module$1.initialized())
+      MethodLocalObject$module$1.value().$asInstanceOf[T#MethodLocalObject$2.type]()
+    else
+      T.this.MethodLocalObject$lzycompute$1(barParam$1, MethodLocalObject$module$1);
     final <artifact> private[this] def $anonfun$tryy$1(tryyParam$1: String, tryyLocal$1: runtime.ObjectRef): Unit = try {
       tryyLocal$1.elem = tryyParam$1
     } finally ()
diff --git a/test/files/run/local_obj.scala b/test/files/run/local_obj.scala
new file mode 100644
index 0000000000..25123f7078
--- /dev/null
+++ b/test/files/run/local_obj.scala
@@ -0,0 +1,9 @@
+class C {
+  val z = 2
+  def mod = { object x { val y = z } ; x.y }
+}
+
+object Test extends App {
+  val c = new C
+  assert(c.mod == c.z, s"${c.mod} != ${c.z}")
+}
diff --git a/test/files/run/t6028.check b/test/files/run/t6028.check
index d6cc452bbf..05634fa8eb 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 = scala.runtime.VolatileObjectRef.zero();
+      lazy <artifact> val MethodLocalObject$module: scala.runtime.LazyRef = new scala.runtime.LazyRef();
       T.this.MethodLocalObject$1(barParam, MethodLocalObject$module)
     };
     def tryy(tryyParam: Int): Function0 = {
@@ -54,12 +54,14 @@ package <empty> {
       <synthetic> <stable> <artifact> def $outer(): T = MethodLocalObject$2.this.$outer;
       <synthetic> <stable> <artifact> def $outer(): T = MethodLocalObject$2.this.$outer
     };
-    final <stable> private[this] def MethodLocalObject$1(barParam$1: Int, MethodLocalObject$module$1: runtime.VolatileObjectRef): T#MethodLocalObject$2.type = {
-      if (MethodLocalObject$module$1.elem.$asInstanceOf[T#MethodLocalObject$2.type]().eq(null))
-        T.this.synchronized[Unit](if (MethodLocalObject$module$1.elem.$asInstanceOf[T#MethodLocalObject$2.type]().eq(null))
-          MethodLocalObject$module$1.elem = new T#MethodLocalObject$2.type(T.this, barParam$1));
-      MethodLocalObject$module$1.elem.$asInstanceOf[T#MethodLocalObject$2.type]()
-    };
+    final <artifact> private[this] def MethodLocalObject$lzycompute$1(barParam$1: Int, MethodLocalObject$module$1: scala.runtime.LazyRef): T#MethodLocalObject$2.type = MethodLocalObject$module$1.synchronized[T#MethodLocalObject$2.type](if (MethodLocalObject$module$1.initialized())
+      MethodLocalObject$module$1.value().$asInstanceOf[T#MethodLocalObject$2.type]()
+    else
+      MethodLocalObject$module$1.initialize(new T#MethodLocalObject$2.type(T.this, barParam$1)).$asInstanceOf[T#MethodLocalObject$2.type]());
+    final private[this] def MethodLocalObject$1(barParam$1: Int, MethodLocalObject$module$1: scala.runtime.LazyRef): T#MethodLocalObject$2.type = if (MethodLocalObject$module$1.initialized())
+      MethodLocalObject$module$1.value().$asInstanceOf[T#MethodLocalObject$2.type]()
+    else
+      T.this.MethodLocalObject$lzycompute$1(barParam$1, MethodLocalObject$module$1);
     @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/t9697.check b/test/files/run/t9697.check
new file mode 100644
index 0000000000..2a4f01c14f
--- /dev/null
+++ b/test/files/run/t9697.check
@@ -0,0 +1 @@
+warning: there were 9 deprecation warnings (since 2.11.0); re-run with -deprecation for details
diff --git a/test/files/run/t9697.scala b/test/files/run/t9697.scala
new file mode 100644
index 0000000000..eb8e44f8fc
--- /dev/null
+++ b/test/files/run/t9697.scala
@@ -0,0 +1,204 @@
+object log {
+  val b = new collection.mutable.StringBuilder
+  def apply(s: Any): Unit = b.append(s)
+  def check(s: String) = {
+    val bs = b.toString
+    assert(s == bs, bs)
+    b.clear()
+  }
+}
+
+package t9697 {
+  abstract class WA extends DelayedInit {
+    override def delayedInit(x: => Unit): Unit = x
+    val waField = "4"
+  }
+
+  class C {
+    def b(s: String) = log(s)
+    val cField = "1"
+
+    {
+      val dummyLocal = "2"
+      new WA {
+        val anonField = "3"
+        b(cField)
+        b(dummyLocal)
+        b(anonField)
+        b(waField)
+      }
+    }
+  }
+}
+
+package sd229 {
+  class Broken {
+    def is(ee: AnyRef) = {
+      new Delayed {
+        log(ee)
+      }
+    }
+  }
+
+  class Delayed extends DelayedInit {
+    def delayedInit(x: => Unit): Unit = x
+  }
+}
+
+
+// already fixed in 2.11.8, crashes in 2.10.6
+package t4683a {
+  class A { log("a") }
+  class B { log("b") }
+  class Bug extends DelayedInit {
+    log("bug")
+    def foo(a: A): B = new B
+    def delayedInit(init: => Unit): Unit = init
+  }
+}
+
+// already fixed in 2.12.0-RC1, crashes in 2.11.8
+package t4683b {
+  class Entity extends DelayedInit {
+    def delayedInit(x: => Unit): Unit = x
+    
+    class Field
+    
+    protected def EntityField[T <: Entity: reflect.ClassTag] = new Field
+    
+    def find[T <: Entity: reflect.ClassTag] {
+      Nil.map(dbo => {
+        class EntityHolder extends Entity {
+          val entity = EntityField[T]
+        }
+      })
+      log("find")
+    }
+  }
+}
+
+package t4683c {
+  trait T extends DelayedInit {
+    def delayedInit(body: => Unit) = {
+      log("init")
+      body
+    }
+  }
+}
+
+package t4683d {
+  class C extends DelayedInit {
+    def delayedInit(body: => Unit): Unit = body
+  }
+  class Injector {
+    def test: Object = {
+      val name = "k"
+      class crash extends C {
+        log(name)
+      }
+      new crash()
+    }
+  }
+}
+
+package t4683e {
+  class DelayedInitTest {
+    def a = log("uh")
+    class B extends DelayedInit {
+      a
+      def delayedInit(body: => Unit): Unit = body
+    }
+  }
+}
+
+package t4683f {
+  class Foo extends DelayedInit {
+    log("fooInit")
+    def delayedInit(newBody: => Unit): Unit = {
+      log("delayedInit")
+      inits = {
+        val f = () => newBody
+        if (inits == null) {
+          log("initsNull")
+          List(f)
+        } else
+          f :: inits
+      }
+    }
+    def foo = log("foo")
+    var inits: List[() => Unit] = Nil
+  }
+  
+  class Bar extends Foo {
+    log("barInit")
+    def bar = foo
+    def newBaz: Foo = new Baz 
+    private class Baz extends Foo {
+      log("bazInit")
+      bar
+    }
+  }
+}
+
+package t4683g {
+  trait MatExpWorld { self =>
+    class T extends Runner { val expWorld: self.type = self }
+  }
+  
+  trait Runner extends DelayedInit {
+    def delayedInit(init: => Unit): Unit = init
+    val expWorld: MatExpWorld
+  }
+}
+
+
+object Test extends App {
+  new t9697.C()
+  log.check("1234")
+
+  new sd229.Broken().is("hi")
+  log.check("hi")
+
+  val a: t4683a.A = new t4683a.A
+  var b: t4683a.B = null
+  new t4683a.Bug {
+    val b = foo(a)
+  }
+  log.check("abugb")
+
+  new t4683b.Entity().find[t4683b.Entity]
+  log.check("find")
+
+  val f = (p1: Int) => new t4683c.T { log(p1) }
+  f(5)
+  log.check("init5")
+
+  new t4683d.Injector().test
+  log.check("k")
+
+  val dit = new t4683e.DelayedInitTest()
+  new dit.B()
+  log.check("uh")
+
+  val fuu = new t4683f.Foo
+  log.check("delayedInitinitsNull")
+  fuu.inits.foreach(_.apply())
+  log.check("fooInit")
+  assert(fuu.inits == Nil) // the (delayed) initializer of Foo sets the inits field to Nil
+
+  val brr = new t4683f.Bar
+  log.check("delayedInitinitsNulldelayedInit") // delayedInit is called once for each constructor
+  brr.inits.foreach(_.apply())
+  log.check("barInitfooInit")
+  assert(brr.inits == Nil)
+
+  val bzz = brr.newBaz
+  log.check("delayedInitinitsNulldelayedInit")
+  bzz.inits.foreach(_.apply())
+  log.check("bazInitfoofooInit")
+  assert(bzz.inits == Nil)
+
+  val mew = new t4683g.MatExpWorld { }
+  val mt = new mew.T
+  assert(mt.expWorld == mew)
+}
diff --git a/test/files/run/t9920.scala b/test/files/run/t9920.scala
new file mode 100644
index 0000000000..5dc32e99b7
--- /dev/null
+++ b/test/files/run/t9920.scala
@@ -0,0 +1,17 @@
+class C0
+trait T { self: C0 =>
+  def test = {
+    object Local
+
+    class C1 {
+      Local
+    }
+    new C1()
+  }
+}
+
+object Test extends C0 with T {
+  def main(args: Array[String]): Unit = {
+    test
+  }
+}
diff --git a/test/files/run/t9920b.scala b/test/files/run/t9920b.scala
new file mode 100644
index 0000000000..fab196b669
--- /dev/null
+++ b/test/files/run/t9920b.scala
@@ -0,0 +1,17 @@
+class C0
+trait T {
+  def test = {
+    object Local
+
+    class C1 {
+      Local
+    }
+    new C1()
+  }
+}
+
+object Test extends C0 with T {
+  def main(args: Array[String]): Unit = {
+    test
+  }
+}
diff --git a/test/files/run/t9920c.scala b/test/files/run/t9920c.scala
new file mode 100644
index 0000000000..9541dc650a
--- /dev/null
+++ b/test/files/run/t9920c.scala
@@ -0,0 +1,21 @@
+class C0
+trait T { self: C0 =>
+  def test = {
+    object Local
+
+    class C2 {
+      class C1 {
+        Local
+      }
+      T.this.toString
+      new C1
+    }
+    new C2()
+  }
+}
+
+object Test extends C0 with T {
+  def main(args: Array[String]): Unit = {
+    test
+  }
+}
diff --git a/test/files/run/t9920d.scala b/test/files/run/t9920d.scala
new file mode 100644
index 0000000000..debc99e199
--- /dev/null
+++ b/test/files/run/t9920d.scala
@@ -0,0 +1,14 @@
+class C { object O }
+trait T { _: C =>
+  def foo {
+    class D { O }
+    new D
+  }
+}
+
+
+object Test extends C with T {
+  def main(args: Array[String]): Unit = {
+    foo
+  }
+}
diff --git a/test/junit/scala/tools/nsc/backend/jvm/BytecodeTest.scala b/test/junit/scala/tools/nsc/backend/jvm/BytecodeTest.scala
index b09a41969e..00b6d1cc42 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/BytecodeTest.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/BytecodeTest.scala
@@ -187,4 +187,12 @@ class BytecodeTest extends BytecodeTesting {
       List(Label(0), LineNumber(2, Label(0)), VarOp(ALOAD, 0), Invoke(INVOKESPECIAL, "T", "t", "()V", true), Op(RETURN), Label(4))
     )
   }
+
+  @Test
+  def sd233(): Unit = {
+    val code = "def f = { println(1); synchronized(println(2)) }"
+    val m = compileMethod(code)
+    val List(ExceptionHandler(_, _, _, desc)) = m.handlers
+    assert(desc == None, desc)
+  }
 }
diff --git a/test/junit/scala/tools/nsc/backend/jvm/opt/InlineWarningTest.scala b/test/junit/scala/tools/nsc/backend/jvm/opt/InlineWarningTest.scala
index 85b44d9fa0..95b47f7d04 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/opt/InlineWarningTest.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/opt/InlineWarningTest.scala
@@ -198,7 +198,9 @@ class InlineWarningTest extends BytecodeTesting {
         |Note that class A is defined in a Java source (mixed compilation), no bytecode is available.""".stripMargin
     )
     var c = 0
-    compileClasses(sCode, javaCode = List((jCode, "A.java")), allowMessage = i => { c += 1; warns.exists(i.msg.contains)})
+    compileClasses(sCode, javaCode = List((jCode, "A.java")), allowMessage = i => { c += 1;
+      warns.exists(i.msg.contains)
+    })
     assert(c == 2)
   }
 }
diff --git a/test/junit/scala/tools/nsc/backend/jvm/opt/ScalaInlineInfoTest.scala b/test/junit/scala/tools/nsc/backend/jvm/opt/ScalaInlineInfoTest.scala
index eae5385147..5cedc483cd 100644
--- a/test/junit/scala/tools/nsc/backend/jvm/opt/ScalaInlineInfoTest.scala
+++ b/test/junit/scala/tools/nsc/backend/jvm/opt/ScalaInlineInfoTest.scala
@@ -105,9 +105,11 @@ class ScalaInlineInfoTest extends BytecodeTesting {
         ("x4$(LT;)I",                                                  MethodInlineInfo(true ,false,false)),
         ("x5()I",                                                     MethodInlineInfo(true, false,false)),
         ("x5$(LT;)I",                                                  MethodInlineInfo(true ,false,false)),
-        ("L$1(Lscala/runtime/VolatileObjectRef;)LT$L$2$;",            MethodInlineInfo(true, false,false)),
+        ("L$1(Lscala/runtime/LazyRef;)LT$L$2$;",                      MethodInlineInfo(true, false,false)),
         ("nest$1()I",                                                 MethodInlineInfo(true, false,false)),
-        ("$init$(LT;)V",                                              MethodInlineInfo(true,false,false))),
+        ("$init$(LT;)V",                                              MethodInlineInfo(true,false,false)),
+        ("L$lzycompute$1(Lscala/runtime/LazyRef;)LT$L$2$;",           MethodInlineInfo(true,false,false))
+      ),
       None // warning
     )
 
@@ -128,7 +130,9 @@ class ScalaInlineInfoTest extends BytecodeTesting {
       "x4()I"                                 -> MethodInlineInfo(false,false,false),
 //      "x5()I"                                 -> MethodInlineInfo(true ,false,false), -- there is no x5 in the class as it's implemented fully in the interface
       "T$$super$toString()Ljava/lang/String;" -> MethodInlineInfo(true ,false,false),
-      "<init>()V"                             -> MethodInlineInfo(false,false,false)),
+      "<init>()V"                             -> MethodInlineInfo(false,false,false),
+      "O$lzycompute$1()V"                     -> MethodInlineInfo(true,false,false)
+    ),
       None)
 
     assert(infoC == expectC, mapDiff(expectC.methodInfos, infoC.methodInfos) + infoC)
@@ -179,6 +183,7 @@ class ScalaInlineInfoTest extends BytecodeTesting {
     val infoC = inlineInfo(c)
     val expected = Map(
       "<init>()V"            -> MethodInlineInfo(false,false,false),
+      "O$lzycompute$1()V"    -> MethodInlineInfo(true,false,false),
       "O()LC$O$;"            -> MethodInlineInfo(true,false,false))
     assert(infoC.methodInfos == expected, mapDiff(infoC.methodInfos, expected))
     assertSameMethods(c, expected.keySet)
diff --git a/tools/get-scala-commit-date b/tools/get-scala-commit-date
index b2e4e10770..6511ed98ca 100755
--- a/tools/get-scala-commit-date
+++ b/tools/get-scala-commit-date
@@ -10,8 +10,13 @@
 
 [[ $# -eq 0 ]] || cd "$1"
 
-lastcommitdate=$(git log --format="%ci" HEAD | head -n 1 | cut -d ' ' -f 1)
-lastcommithours=$(git log --format="%ci" HEAD | head -n 1 | cut -d ' ' -f 2)
+if git rev-parse --is-inside-work-tree > /dev/null 2>&1; then
+	lastcommitdate=$(git log --format="%ci" HEAD | head -n 1 | cut -d ' ' -f 1)
+	lastcommithours=$(git log --format="%ci" HEAD | head -n 1 | cut -d ' ' -f 2)
+else
+	lastcommitdate=$(date +%Y-%m-%d)
+	lastcommithours=$(date +%H:%M:%S)
+fi
 
 # 20120324
 echo "${lastcommitdate//-/}-${lastcommithours//:/}"
diff --git a/tools/get-scala-commit-sha b/tools/get-scala-commit-sha
index eab90a4215..18289c7ca8 100755
--- a/tools/get-scala-commit-sha
+++ b/tools/get-scala-commit-sha
@@ -10,9 +10,13 @@
 
 [[ $# -eq 0 ]] || cd "$1"
 
-# printf %016s is not portable for 0-padding, has to be a digit.
-# so we're stuck disassembling it.
-hash=$(git log -1 --format="%H" HEAD)
-hash=${hash#g}
-hash=${hash:0:10}
+if git rev-parse --is-inside-work-tree > /dev/null 2>&1; then
+	# printf %016s is not portable for 0-padding, has to be a digit.
+	# so we're stuck disassembling it.
+	hash=$(git log -1 --format="%H" HEAD)
+	hash=${hash#g}
+	hash=${hash:0:10}
+else
+	hash="unknown"
+fi
 echo "$hash"
diff --git a/versions.properties b/versions.properties
index e75ec61f64..7c357f7fa7 100644
--- a/versions.properties
+++ b/versions.properties
@@ -8,7 +8,7 @@
 # The scala version used for bootstrapping. This has no impact on the final classfiles:
 # there are two stages (locker and quick), so compiler and library are always built
 # with themselves. Stability is ensured by building a third stage (strap).
-starr.version=2.12.0-RC1
+starr.version=2.12.0-RC1-ceaf419
 
 # These are the versions of the modules that go with this release.
 # These properties are used during PR validation and in dbuild builds.