Revert changes related to #1591. no review.

1 files changed, 16 insertions, 60 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
index dbbc9ed3e5..5c90a69c94 100644
--- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
@@ -51,23 +51,11 @@ abstract class RefChecks extends InfoTransform {
     new RefCheckTransformer(unit)
   override def changesBaseClasses = false
 
-  def transformInfo(sym: Symbol, tp: Type): Type = {
-    def isNestedModule = sym.isModule && !sym.isRootPackage && !sym.owner.isPackageClass
-
+  def transformInfo(sym: Symbol, tp: Type): Type =
     if (sym.isModule && !sym.isStatic) {
-
       sym setFlag (lateMETHOD | STABLE)
-      if (isNestedModule) {
-        val moduleVar = sym.owner.info.decl(nme.moduleVarName(sym.name))
-        if (moduleVar == NoSymbol) {
-          gen.mkModuleVarDef(sym).symbol.setInfo(tp)
-          sym.resetFlag(MODULE)
-          sym.setFlag(LAZY | ACCESSOR)
-        }
-      }
       PolyType(List(), tp)
     } else tp
-  }
 
   val toJavaRepeatedParam = new TypeMap {
     def apply(tp: Type) = tp match {
@@ -920,12 +908,11 @@ abstract class RefChecks extends InfoTransform {
     def transformStat(tree: Tree, index: Int): List[Tree] = tree match {
       case ModuleDef(mods, name, impl) =>
         val sym = tree.symbol
+        val cdef = ClassDef(mods | MODULE, name, List(), impl)
+          .setPos(tree.pos)
+          .setSymbol(sym.moduleClass)
+          .setType(NoType)
         if (sym.isStatic) {
-          val cdef = ClassDef(mods | MODULE, name, List(), impl)
-            .setPos(tree.pos)
-            .setSymbol(sym.moduleClass)
-            .setType(NoType)
-
           if (!sym.allOverriddenSymbols.isEmpty) {
             val factory = sym.owner.newMethod(sym.pos, sym.name)
               .setFlag(sym.flags | STABLE).resetFlag(MODULE)
@@ -942,48 +929,17 @@ abstract class RefChecks extends InfoTransform {
             List(transform(cdef))
           }
         } else {
-          def lazyNestedObjectTrees(transformedInfo: Boolean) = {
-            val cdef = ClassDef(mods | MODULE, name, List(), impl)
-              .setPos(tree.pos)
-              .setSymbol(if (!transformedInfo) sym.moduleClass else sym.lazyAccessor)
-              .setType(NoType)
-
-            val vdef = localTyper.typedPos(tree.pos){
-              if (!transformedInfo)
-                gen.mkModuleVarDef(sym)
-              else {
-                val vsym = sym.owner.info.decl(nme.moduleVarName(sym.name))
-                assert(vsym != NoSymbol, "Nested object after transformInfo set module variable")
-                ValDef(vsym, EmptyTree)
-              }
-            }
-            val vsym = vdef.symbol
-
-            val ddef = atPhase(phase.next) {
+          val vdef = localTyper.typedPos(tree.pos) { gen.mkModuleVarDef(sym) }
+          val ddef =
+            atPhase(phase.next) {
               localTyper.typed {
-                val rhs = gen.newModule(sym, vsym.tpe)
-                if (!transformedInfo) {
-                  sym.resetFlag(MODULE | FINAL | CASE)
-                  sym.setFlag(LAZY | ACCESSOR | SYNTHETIC)
-
-                  sym.setInfo(PolyType(List(), sym.tpe))
-                  sym setFlag (lateMETHOD | STABLE)
-                }
-
-                val ownerTransformer = new ChangeOwnerTraverser(vsym, sym)
-                val lazyDef = atPos(tree.pos)(
-                  DefDef(sym, ownerTransformer(
-                    if (sym.owner.isTrait) rhs
-                    else Block(List(
-                            Assign(gen.mkAttributedRef(vsym), rhs)),
-                            gen.mkAttributedRef(vsym)))
-                       ))
-                lazyDef
+                if (sym.owner.isTrait) gen.mkModuleAccessDcl(sym)
+                else gen.mkCachedModuleAccessDef(sym, vdef.symbol)
               }
             }
-            transformTrees(List(cdef, vdef, ddef))
-          }
-          lazyNestedObjectTrees(sym.hasFlag(LAZY))
+
+          if (sym.owner.isTrait) transformTrees(List(cdef, ddef))
+          else transformTrees(List(cdef, vdef, ddef))
         }
 
       case ValDef(_, _, _, _) =>
@@ -1007,11 +963,11 @@ abstract class RefChecks extends InfoTransform {
           if (hasUnitType)
             typed(lazyDef) :: Nil
           else
-            typed(ValDef(vsym, EmptyTree)) :: atPhase(phase.next) { typed(lazyDef) } :: Nil
+            typed(ValDef(vsym, EmptyTree)) :: typed(lazyDef) :: Nil
         } else {
-          if (tree.symbol.isLocal && index <= currentLevel.maxindex) {
+          if (tree.symbol.isLocal && index <= currentLevel.maxindex && !tree.symbol.hasFlag(LAZY)) {
             if (settings.debug.value) Console.println(currentLevel.refsym);
-            unit.error(currentLevel.refpos, "forward reference extends over definition of " + tree.symbol)
+            unit.error(currentLevel.refpos, "forward reference extends over definition of " + tree.symbol);
           }
           List(tree1)
         }