From e1eb91714d2129ea460e8c4da4ff65074acb736a Mon Sep 17 00:00:00 2001 From: Hubert Plociniczak Date: Wed, 29 Sep 2010 09:47:54 +0000 Subject: Revert changes related to #1591. no review. --- src/compiler/scala/tools/nsc/ast/TreeGen.scala | 28 +++++--- .../scala/tools/nsc/doc/model/Entity.scala | 4 +- .../scala/tools/nsc/doc/model/ModelFactory.scala | 26 ++------ src/compiler/scala/tools/nsc/symtab/StdNames.scala | 4 ++ src/compiler/scala/tools/nsc/symtab/Types.scala | 7 +- .../scala/tools/nsc/transform/Flatten.scala | 4 +- .../scala/tools/nsc/transform/LambdaLift.scala | 2 +- src/compiler/scala/tools/nsc/transform/Mixin.scala | 11 ++-- .../scala/tools/nsc/typechecker/RefChecks.scala | 76 +++++----------------- .../tools/nsc/typechecker/SyntheticMethods.scala | 9 +-- src/library/scala/reflect/generic/StdNames.scala | 4 -- src/library/scala/reflect/generic/Symbols.scala | 5 -- src/library/scala/reflect/generic/UnPickler.scala | 18 +---- test/files/jvm/serialization.scala | 26 -------- test/files/pos/t1591_pos.scala | 7 -- test/files/run/t1591.check | 1 - test/files/run/t1591.scala | 14 ---- 17 files changed, 58 insertions(+), 188 deletions(-) delete mode 100644 test/files/pos/t1591_pos.scala delete mode 100644 test/files/run/t1591.check delete mode 100644 test/files/run/t1591.scala 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("") @@ -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("") 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 @@ -531,31 +531,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 @@ -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) -} -- cgit v1.2.3