Desugar module var and accessor in refchecks/lazyvals

Rather than leaving it until mixin.

The broader motivation is to simplify the mixin phase of the
compiler before we get rid of implementatation classes in
favour of using JDK8 default interface methods.

The current code in mixin is used for both lazy val and modules,
and puts the "slow path" code that uses the monitor into a
dedicated method (`moduleName$lzyCompute`). I tracked this
back to a3d4d17b77. I can't tell from that commit whether the
performance sensititivity was related to modules or lazy vals,
from the commit message I'd say the latter.

As the initialization code for a module is just a constructor call,
rather than an arbitraryly large chunk of code for a lazy initializer,
this commit opts to inline the `lzycompute` method.

During refchecks, mixin module accessors are added to classes, so
that mixed in and defined modules are translated uniformly. Trait
owned modules get an accessor method with an empty body (that shares
the module symbol), but no module var.

Defer synthesis of the double checked locking idiom to the lazyvals
phase, which gets us a step closer to a unified translation of
modules and lazy vals.

I had to change the `atOwner` methods to to avoid using the
non-existent module class of a module accessor method as the
current owner. This fixes a latent bug. Without this change,
retypechecking of the module accessor method during erasure crashes
with an accessibility error selecting the module var.

In the process, I've tweaked a tree generation utility method
to wvoid synthesizing redundant blocks in module desugaring.

1 files changed, 29 insertions, 10 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
index 7252cae0b5..915ffcc7d0 100644
--- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
@@ -1188,14 +1188,6 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
       // set NoType so it will be ignored.
       val cdef          = ClassDef(module.moduleClass, impl) setType NoType
 
-      def newInnerObject() = {
-        val moduleVar = site newModuleVarSymbol module
-        val rhs       = gen.newModule(module, moduleVar.tpe)
-        val body      = if (site.isTrait) rhs else gen.mkAssignAndReturn(moduleVar, rhs)
-        val accessor  = DefDef(module, body.changeOwner(moduleVar -> module))
-
-        ValDef(moduleVar) :: accessor :: Nil
-      }
       def matchingInnerObject() = {
         val newFlags = (module.flags | STABLE) & ~MODULE
         val newInfo  = NullaryMethodType(module.moduleClass.tpe)
@@ -1208,10 +1200,36 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
           // trait T { def f: Object }; object O extends T { object f }. Need to generate method f in O.
           if (module.isOverridingSymbol) matchingInnerObject() else Nil
         else
-          newInnerObject()
+          newInnerObject(site, module)
       )
       transformTrees(newTrees map localTyper.typedPos(moduleDef.pos))
     }
+    def newInnerObject(site: Symbol, module: Symbol): List[Tree] = {
+      if (site.isTrait)
+        DefDef(module, EmptyTree) :: Nil
+      else {
+        val moduleVar = site newModuleVarSymbol module
+        // used for the mixin case: need a new symbol owned by the subclass for the accessor, rather than repurposing the module symbol
+        def mkAccessorSymbol =
+          site.newMethod(module.name.toTermName, site.pos, STABLE | MODULE | MIXEDIN)
+            .setInfo(moduleVar.tpe)
+            .andAlso(self => if (module.isPrivate) self.expandName(module.owner))
+
+        val accessor = if (module.owner == site) module else mkAccessorSymbol
+        val accessorDef = DefDef(accessor, gen.mkAssignAndReturn(moduleVar, gen.newModule(module, moduleVar.tpe)).changeOwner(moduleVar -> accessor))
+
+        ValDef(moduleVar) :: accessorDef :: Nil
+      }
+    }
+
+    def mixinModuleDefs(clazz: Symbol): List[Tree] = {
+      val res = for {
+        mixinClass <- clazz.mixinClasses.iterator
+        module     <- mixinClass.info.decls.iterator.filter(_.isModule)
+        newMember  <- newInnerObject(clazz, module)
+      } yield transform(localTyper.typedPos(clazz.pos)(newMember))
+      res.toList
+    }
 
     def transformStat(tree: Tree, index: Int): List[Tree] = tree match {
       case t if treeInfo.isSelfConstrCall(t) =>
@@ -1643,11 +1661,12 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
             // SI-7870 default getters for constructors live in the companion module
             checkOverloadedRestrictions(currentOwner, currentOwner.companionModule)
             val bridges = addVarargBridges(currentOwner)
+            val moduleDesugared = if (currentOwner.isTrait) Nil else mixinModuleDefs(currentOwner)
             checkAllOverrides(currentOwner)
             checkAnyValSubclass(currentOwner)
             if (currentOwner.isDerivedValueClass)
               currentOwner.primaryConstructor makeNotPrivate NoSymbol // SI-6601, must be done *after* pickler!
-            if (bridges.nonEmpty) deriveTemplate(tree)(_ ::: bridges) else tree
+            if (bridges.nonEmpty || moduleDesugared.nonEmpty) deriveTemplate(tree)(_ ::: bridges ::: moduleDesugared) else tree
 
           case dc@TypeTreeWithDeferredRefCheck() => abort("adapt should have turned dc: TypeTreeWithDeferredRefCheck into tpt: TypeTree, with tpt.original == dc")
           case tpt@TypeTree() =>