Revert changes related to #1591. no review.

17 files changed, 58 insertions, 188 deletions

diff --git a/src/compiler/scala/tools/nsc/ast/TreeGen.scala b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
index 611780e776..a886e7468f 100644
--- a/src/compiler/scala/tools/nsc/ast/TreeGen.scala
+++ b/src/compiler/scala/tools/nsc/ast/TreeGen.scala
@@ -259,18 +259,30 @@ abstract class TreeGen {
     )
   }
 
-  def mkModuleVarDef(accessor: Symbol) = {
-    val mval = accessor.owner.newVariable(accessor.pos.focus, nme.moduleVarName(accessor.name))
+  // var m$: T = null; or, if class member: local var m$: T = _;
+  /*!!!
+  def mkModuleValDef(accessor: Symbol) = {
+    val mval = accessor.owner.newValue(accessor.pos.focus, nme.moduleVarName(accessor.name))
       .setInfo(accessor.tpe.finalResultType)
-      .setFlag(LAZY)
-      .setFlag(MODULEVAR)
-    mval.setLazyAccessor(accessor)
+      .setFlag(LAZY);
     if (mval.owner.isClass) {
       mval setFlag (PRIVATE | LOCAL | SYNTHETIC)
       mval.owner.info.decls.enter(mval)
     }
-    ValDef(mval, EmptyTree)
-    //ValDef(mval, newModule(accessor, mval.tpe))
+    ValDef(mval, New(TypeTree(mval.tpe), List(List())))
+  }
+  */
+
+  // var m$: T = null; or, if class member: local var m$: T = _;
+  def mkModuleVarDef(accessor: Symbol) = {
+    val mvar = accessor.owner.newVariable(accessor.pos.focus, nme.moduleVarName(accessor.name))
+      .setInfo(accessor.tpe.finalResultType)
+      .setFlag(MODULEVAR);
+    if (mvar.owner.isClass) {
+      mvar setFlag (PRIVATE | LOCAL | SYNTHETIC)
+      mvar.owner.info.decls.enter(mvar)
+    }
+    ValDef(mvar, if (mvar.owner.isClass) EmptyTree else Literal(Constant(null)))
   }
 
   // def m: T = { if (m$ eq null) m$ = new m$class(...) m$ }
@@ -283,7 +295,7 @@ abstract class TreeGen {
   def mkModuleAccessDef(accessor: Symbol, tpe: Type) =
     DefDef(accessor, newModule(accessor, tpe))
 
-  def newModule(accessor: Symbol, tpe: Type) =
+  private def newModule(accessor: Symbol, tpe: Type) =
     New(TypeTree(tpe),
         List(for (pt <- tpe.typeSymbol.primaryConstructor.info.paramTypes)
              yield This(accessor.owner.enclClass)))
diff --git a/src/compiler/scala/tools/nsc/doc/model/Entity.scala b/src/compiler/scala/tools/nsc/doc/model/Entity.scala
index 3b6323525f..6d81b8271e 100644
--- a/src/compiler/scala/tools/nsc/doc/model/Entity.scala
+++ b/src/compiler/scala/tools/nsc/doc/model/Entity.scala
@@ -97,9 +97,7 @@ trait Class extends Trait with HigherKinded {
 }
 
 /** A ''documentable'' object. */
-trait Object extends DocTemplateEntity {
-  def isNested: Boolean = false
-}
+trait Object extends DocTemplateEntity
 
 /** A package that contains at least one ''documentable'' class, trait,
   * object or package. */
diff --git a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
index 885da06a09..f7c5c5d724 100644
--- a/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
+++ b/src/compiler/scala/tools/nsc/doc/model/ModelFactory.scala
@@ -298,16 +298,12 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { thisFactory
       val pack =
         if (bSym == RootPackage)
           new RootPackageImpl(bSym) {
-            // run this: println("Constructing root package. It's symbol is package? " + bSym.isPackage)
-            // RootPackage symbol package flag is set to false for some reason
-            // to circumvent this behaviour - isPackage is overridden below
             override val name = "root"
             override def inTemplate = this
             override def toRoot = this :: Nil
             override def qualifiedName = "_root_"
             override def inheritedFrom = Nil
             override def isRootPackage = true
-            override def isPackage = true
             override protected lazy val memberSyms =
               (bSym.info.members ++ EmptyPackage.info.members) filter { s =>
                 s != EmptyPackage && s != RootPackage
@@ -370,12 +366,6 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { thisFactory
           members collect { case d: Constructor => d }
         def primaryConstructor = constructors find { _.isPrimary }
       }
-    else if (isNestedObjectLazyVal(bSym))
-      new DocTemplateImpl(bSym, minimumInTpl) with Object {
-        override def isNested = true
-        override def isObject = true
-        override def isLazyVal = false
-      }
     else
       throw new Error("'" + bSym + "' that isn't a class, trait or object cannot be built as a documentable template")
   }
@@ -385,13 +375,9 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { thisFactory
 
     def makeMember0(bSym: Symbol): Option[MemberImpl] = {
       if (bSym.isGetter && bSym.isLazy)
-          Some(
-            if (isNestedObjectLazyVal(bSym))
-              makeDocTemplate(bSym, inTpl)
-            else
-              new NonTemplateMemberImpl(bSym, inTpl) with Val {
-                override def isLazyVal = true
-              })
+        Some(new NonTemplateMemberImpl(bSym, inTpl) with Val {
+          override def isLazyVal = true
+        })
       else if (bSym.isGetter && bSym.accessed.isMutable)
         Some(new NonTemplateMemberImpl(bSym, inTpl) with Val {
           override def isVar = true
@@ -575,16 +561,12 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { thisFactory
     ( aSym.owner == NoSymbol || templateShouldDocument(aSym.owner) ) && !isEmptyJavaObject(aSym)
   }
 
-  def isNestedObjectLazyVal(aSym: Symbol): Boolean = {
-    aSym.isLazy && !aSym.isRootPackage && !aSym.owner.isPackageClass && (aSym.lazyAccessor != NoSymbol)
-  }
-
   def isEmptyJavaObject(aSym: Symbol): Boolean = {
     def hasMembers = aSym.info.members.exists(s => localShouldDocument(s) && (!s.isConstructor || s.owner == aSym))
     aSym.isModule && aSym.hasFlag(Flags.JAVA) && !hasMembers
   }
 
   def localShouldDocument(aSym: Symbol): Boolean = {
-    !aSym.isPrivate && (aSym.isProtected || aSym.privateWithin == NoSymbol) && (!aSym.isSynthetic || isNestedObjectLazyVal(aSym))
+    !aSym.isPrivate && (aSym.isProtected || aSym.privateWithin == NoSymbol) && !aSym.isSynthetic
   }
 }
diff --git a/src/compiler/scala/tools/nsc/symtab/StdNames.scala b/src/compiler/scala/tools/nsc/symtab/StdNames.scala
index bcd1ac0627..aa47441a1a 100644
--- a/src/compiler/scala/tools/nsc/symtab/StdNames.scala
+++ b/src/compiler/scala/tools/nsc/symtab/StdNames.scala
@@ -89,6 +89,7 @@ trait StdNames extends reflect.generic.StdNames { self: SymbolTable =>
     val LOCAL_SUFFIX = newTermName(LOCAL_SUFFIX_STRING)
     val SETTER_SUFFIX = encode("_=")
     val IMPL_CLASS_SUFFIX = newTermName("$class")
+    val MODULE_SUFFIX = newTermName("$module")
     val LOCALDUMMY_PREFIX = newTermName(LOCALDUMMY_PREFIX_STRING)
     val SELECTOR_DUMMY = newTermName("<unapply-selector>")
 
@@ -174,6 +175,9 @@ trait StdNames extends reflect.generic.StdNames { self: SymbolTable =>
     def interfaceName(implname: Name): Name =
       implname.subName(0, implname.length - IMPL_CLASS_SUFFIX.length)
 
+    def moduleVarName(name: Name): Name =
+      newTermName(name.toString() + MODULE_SUFFIX)
+
     def superName(name: Name) = newTermName("super$" + name)
 
     val PROTECTED_PREFIX = "protected$"
diff --git a/src/compiler/scala/tools/nsc/symtab/Types.scala b/src/compiler/scala/tools/nsc/symtab/Types.scala
index c853efb725..f014dfde9c 100644
--- a/src/compiler/scala/tools/nsc/symtab/Types.scala
+++ b/src/compiler/scala/tools/nsc/symtab/Types.scala
@@ -3706,10 +3706,7 @@ A type's typeSymbol should never be inspected directly.
   object adaptToNewRunMap extends TypeMap {
     private def adaptToNewRun(pre: Type, sym: Symbol): Symbol = {
       if (sym.isModuleClass && !phase.flatClasses) {
-        if (!sym.owner.isPackageClass)
-          sym // Nested lazy object
-        else
-          adaptToNewRun(pre, sym.sourceModule).moduleClass
+        adaptToNewRun(pre, sym.sourceModule).moduleClass
       } else if ((pre eq NoPrefix) || (pre eq NoType) || sym.owner.isPackageClass) {
         sym
       } else {
@@ -4587,7 +4584,7 @@ A type's typeSymbol should never be inspected directly.
   def specializesSym(tp: Type, sym: Symbol): Boolean =
     tp.typeSymbol == NothingClass ||
     tp.typeSymbol == NullClass && (sym.owner isSubClass ObjectClass) ||
-    (tp.member(sym.name).alternatives exists
+    (tp.nonPrivateMember(sym.name).alternatives exists
       (alt => sym == alt || specializesSym(tp.narrow, alt, sym.owner.thisType, sym)))
 
   /** Does member `sym1' of `tp1' have a stronger type
diff --git a/src/compiler/scala/tools/nsc/transform/Flatten.scala b/src/compiler/scala/tools/nsc/transform/Flatten.scala
index 96c050b51f..1bee37bfe6 100644
--- a/src/compiler/scala/tools/nsc/transform/Flatten.scala
+++ b/src/compiler/scala/tools/nsc/transform/Flatten.scala
@@ -48,9 +48,7 @@ abstract class Flatten extends InfoTransform {
           for (sym <- decls.toList) {
             if (sym.isTerm && !sym.isStaticModule) {
               decls1 enter sym
-              if (sym.isModule) sym.moduleClass setFlag LIFTED  // Only top modules
-              // Nested modules (MODULE flag is reset so we access through lazy):
-              if (sym.isModuleVar && sym.hasFlag(LAZY)) sym.lazyAccessor.lazyAccessor setFlag LIFTED
+              if (sym.isModule) sym.moduleClass setFlag LIFTED
             } else if (sym.isClass) {
               liftClass(sym)
               if (sym.needsImplClass) liftClass(erasure.implClass(sym))
diff --git a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
index ecf68fa922..342106697d 100644
--- a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
+++ b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala
@@ -153,7 +153,7 @@ abstract class LambdaLift extends InfoTransform {
           }
           changedFreeVars = true
           if (settings.debug.value) log("" + sym + " is free in " + owner);
-          if ((sym.isVariable || (sym.isValue && sym.isLazy)) && !sym.hasFlag(CAPTURED)) {
+          if (sym.isVariable && !(sym hasFlag CAPTURED)) {
             sym setFlag CAPTURED
             val symClass = sym.tpe.typeSymbol;
             atPhase(phase.next) {
diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala
index 41dc812fd0..9cd1a68dd0 100644
--- a/src/compiler/scala/tools/nsc/transform/Mixin.scala
+++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala
@@ -396,7 +396,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
    *  Each field has to be private and defined in the enclosing class, and there must
    *  be exactly one lazy value using it.
    *
-   *  Such fields will be nulled after the initializer has memorized the lazy value.
+   *  Such fields will be nulled after the initializer has memoized the lazy value.
    */
   def singleUseFields(templ: Template): collection.Map[Symbol, List[Symbol]] = {
     val usedIn = new mutable.HashMap[Symbol, List[Symbol]] {
@@ -415,7 +415,6 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
                   && !(currentOwner.isGetter && currentOwner.accessed == sym) // getter
                   && !definitions.isValueClass(sym.tpe.resultType.typeSymbol)
                   && sym.owner == templ.symbol.owner
-                  && !sym.hasFlag(LAZY)
                   && !tree.isDef) {
                 log("added use in: " + currentOwner + " -- " + tree)
                 usedIn(sym) ::= currentOwner
@@ -443,7 +442,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
   class MixinTransformer(unit : CompilationUnit) extends Transformer {
 
     /** Within a static implementation method: the parameter referring to the
-     *  current object undefined everywhere else.
+     *  current object undefined evrywhere else.
      */
     private var self: Symbol = _
 
@@ -733,7 +732,6 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
        *  the class constructor is changed to set the initialized bits.
        */
       def addCheckedGetters(clazz: Symbol, stats: List[Tree]): List[Tree] = {
-        // TODO: not used?
         def findLazyAssignment(stats: List[Tree]): Tree = (
           for (s @ Assign(lhs, _) <- stats ; if lhs.symbol hasFlag LAZY) yield s
         ) head // if there's no assignment then it's a bug and we crash
@@ -920,6 +918,11 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
                 } else
                   gen.mkCheckInit(accessedRef)
               })
+            } else if (sym.isModule && !(sym hasFlag LIFTED | BRIDGE)) {
+              // add modules
+              val vdef = gen.mkModuleVarDef(sym)
+              addDef(position(sym), vdef)
+              addDef(position(sym), gen.mkCachedModuleAccessDef(sym, vdef.symbol))
             } else if (!sym.isMethod) {
               // add fields
               addDef(position(sym), ValDef(sym))
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)
         }
diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
index b28b92357f..896ceb5bb6 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala
@@ -228,13 +228,6 @@ trait SyntheticMethods extends ast.TreeDSL {
         result
     }
 
-    def needsReadResolve = (
-      // only nested objects inside objects should get readResolve automatically
-      // otherwise after de-serialization we get null references for lazy accessors (nested object -> lazy val + class def)
-      clazz.isSerializable &&
-      ((!clazz.owner.isPackageClass && clazz.owner.isModuleClass) || clazz.owner.isPackageClass)
-    )
-
     // A buffer collecting additional methods for the template body
     val ts = new ListBuffer[Tree]
 
@@ -309,7 +302,7 @@ trait SyntheticMethods extends ast.TreeDSL {
          *  the readResolve() method (see http://www.javaworld.com/javaworld/
          *  jw-04-2003/jw-0425-designpatterns_p.html)
          */
-        if (!hasReadResolve && needsReadResolve){
+        if (clazz.isSerializable && !hasReadResolve) {
           // PP: To this day I really can't figure out what this next comment is getting at:
           // the !!! normally means there is something broken, but if so, what is it?
           //
diff --git a/src/library/scala/reflect/generic/StdNames.scala b/src/library/scala/reflect/generic/StdNames.scala
index 03cee8c909..7a3b9169d8 100755
--- a/src/library/scala/reflect/generic/StdNames.scala
+++ b/src/library/scala/reflect/generic/StdNames.scala
@@ -17,14 +17,10 @@ trait StdNames { self: Universe =>
     val ROOT               = newTermName("<root>")
     val ROOTPKG            = newTermName("_root_")
     val EMPTY              = newTermName("")
-    val MODULE_SUFFIX      = newTermName("$module")
 
     /** The expanded name of `name' relative to this class `base` with given `separator`
      */
     def expandedName(name: Name, base: Symbol, separator: String = EXPAND_SEPARATOR_STRING): Name =
       newTermName(base.fullName('$') + separator + name)
-
-    def moduleVarName(name: Name): Name =
-      newTermName(name.toString() + MODULE_SUFFIX)
   }
 }
diff --git a/src/library/scala/reflect/generic/Symbols.scala b/src/library/scala/reflect/generic/Symbols.scala
index a1c9a0c18d..f1226c7e19 100755
--- a/src/library/scala/reflect/generic/Symbols.scala
+++ b/src/library/scala/reflect/generic/Symbols.scala
@@ -107,11 +107,6 @@ trait Symbols { self: Universe =>
      */
     def moduleClass: Symbol
 
-    /**
-     *  If symbol is a lazy val, it's lazy accessor
-     */
-    def lazyAccessor: Symbol
-
 // flags and kind tests
 
     def isTerm         = false  // to be overridden
diff --git a/src/library/scala/reflect/generic/UnPickler.scala b/src/library/scala/reflect/generic/UnPickler.scala
index b01ff6a567..54ac1acc3d 100755
--- a/src/library/scala/reflect/generic/UnPickler.scala
+++ b/src/library/scala/reflect/generic/UnPickler.scala
@@ -191,23 +191,7 @@ abstract class UnPickler {
           // right member => return NoSymbol. This can only happen when unpickling a tree.
           // the "case Apply" in readTree() takes care of selecting the correct alternative
           //  after parsing the arguments.
-          if (sym == NoSymbol && !owner.isOverloaded) {
-            // Possibly a nested object symbol
-            tag match {
-              case EXTMODCLASSref =>
-                val moduleVar = owner.info.decl(nme.moduleVarName(name))
-                if (moduleVar.hasFlag(LAZY)) {
-                  val lazyAcc = moduleVar.lazyAccessor
-                  // TODO: Necessary check?
-                  if (lazyAcc != NoSymbol)
-                    sym = lazyAcc.lazyAccessor
-                  }
-                case _ =>
-            }
-
-            if (sym == NoSymbol)
-              errorMissingRequirement(name, owner)
-          }
+          if (sym == NoSymbol && !owner.isOverloaded) errorMissingRequirement(name, owner)
 
         case NONEsym =>
           sym = NoSymbol
diff --git a/test/files/jvm/serialization.scala b/test/files/jvm/serialization.scala
index b8656888c6..06086f4038 100644
--- a/test/files/jvm/serialization.scala
+++ b/test/files/jvm/serialization.scala
@@ -532,31 +532,6 @@ object Test6 {
 }
 
 //############################################################################
-// Nested objects cannot get readresolve automatically because after deserialization
-// they would be null (they are treated as lazy vals)
-@serializable
-class Outer {
-
-    @serializable
-    object Inner
-}
-
-object Test7 {
-  val x = new Outer
-  x.Inner // initialize
-  try {
-    val y:Outer = read(write(x))
-    if (y.Inner == null)
-      println("Inner object is null")
-  }
-  catch {
-  case e: Exception =>
-    println("Error in Test7: " + e)
-  }
-
-}
-
-//############################################################################
 // Test code
 
 object Test {
@@ -567,7 +542,6 @@ object Test {
     Test4_xml
     Test5
     Test6
-    Test7
   }
 }
 
diff --git a/test/files/pos/t1591_pos.scala b/test/files/pos/t1591_pos.scala
deleted file mode 100644
index 4f55d7ce19..0000000000
--- a/test/files/pos/t1591_pos.scala
+++ /dev/null
@@ -1,7 +0,0 @@
-trait A
-
-object Test {
-    lazy val a = new A {
-        object Zenek
-    }
-}
diff --git a/test/files/run/t1591.check b/test/files/run/t1591.check
deleted file mode 100644
index 48082f72f0..0000000000
--- a/test/files/run/t1591.check
+++ /dev/null
@@ -1 +0,0 @@
-12
diff --git a/test/files/run/t1591.scala b/test/files/run/t1591.scala
deleted file mode 100644
index 434064a5dd..0000000000
--- a/test/files/run/t1591.scala
+++ /dev/null
@@ -1,14 +0,0 @@
-abstract class A {
-
-    lazy val lazyBar = bar
-
-    object bar {
-        val foo = 12
-    }
-
-}
-
-object Test extends Application {
-    val a = new A{}
-    println(a.lazyBar.foo)
-}