From 8ab0305de71c63d8dcdba023fdb305202da57edd Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Tue, 16 May 2006 20:34:26 +0000 Subject: bug fixes --- src/compiler/scala/tools/nsc/ast/parser/Parsers.scala | 9 --------- .../scala/tools/nsc/ast/parser/TreeBuilder.scala | 17 +++++++++++------ src/compiler/scala/tools/nsc/symtab/Definitions.scala | 5 +++++ src/compiler/scala/tools/nsc/symtab/StdNames.scala | 1 + src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala | 7 ++++--- src/compiler/scala/tools/nsc/symtab/Symbols.scala | 2 +- src/compiler/scala/tools/nsc/typechecker/Namers.scala | 4 +++- src/compiler/scala/tools/nsc/typechecker/Typers.scala | 11 +++++++++-- 8 files changed, 34 insertions(+), 22 deletions(-) diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index f63ebed3a4..cc9f077d0a 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -192,15 +192,6 @@ trait Parsers requires SyntaxAnalyzer { /////// TREE CONSTRUCTION //////////////////////////////////////////////////// - def scalaDot(name: Name): Tree = - Select(Ident(nme.scala_), name); - def scalaAnyRefConstr: Tree = - scalaDot(nme.AnyRef.toTypeName); - def scalaScalaObjectConstr: Tree = - scalaDot(nme.ScalaObject.toTypeName); - def caseClassConstr: Tree = - scalaDot(nme.CaseClass.toTypeName); - /** Convert tree to formal parameter list */ def convertToParams(t: Tree): List[ValDef] = t match { diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala index b00a4875ab..db8b695b39 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala @@ -18,6 +18,15 @@ abstract class TreeBuilder { def freshName(): Name = freshName("x$"); + def scalaDot(name: Name): Tree = + Select(Ident(nme.scala_) setSymbol definitions.ScalaPackage, name) + def scalaAnyRefConstr: Tree = + scalaDot(nme.AnyRef.toTypeName); + def scalaScalaObjectConstr: Tree = + scalaDot(nme.ScalaObject.toTypeName); + def caseClassConstr: Tree = + scalaDot(nme.CaseClass.toTypeName); + /** Convert all occurrences of (lower-case) variables in a pattern as follows: * x becomes x @ _ * x: T becomes x @ (_: T) @@ -63,9 +72,7 @@ abstract class TreeBuilder { private def makeTuple(trees: List[Tree], isType: boolean): Tree = { val tupString = "Tuple" + trees.length; - Apply( - Select(Ident(nme.scala_), if (isType) newTypeName(tupString) else newTermName(tupString)), - trees) + Apply(scalaDot(if (isType) newTypeName(tupString) else newTermName(tupString)), trees) } private def makeTupleTerm(trees: List[Tree]): Tree = trees match { @@ -369,9 +376,7 @@ abstract class TreeBuilder { /** Create a tree representing a function type */ def makeFunctionTypeTree(argtpes: List[Tree], restpe: Tree): Tree = - AppliedTypeTree( - Select(Ident(nme.scala_), newTypeName("Function" + argtpes.length)), - argtpes ::: List(restpe)); + AppliedTypeTree(scalaDot(newTypeName("Function" + argtpes.length)), argtpes ::: List(restpe)) /** Append implicit view section if for `implicitViews' if nonempty */ def addImplicitViews(owner: Name, vparamss: List[List[ValDef]], implicitViews: List[Tree]): List[List[ValDef]] = { diff --git a/src/compiler/scala/tools/nsc/symtab/Definitions.scala b/src/compiler/scala/tools/nsc/symtab/Definitions.scala index ec055b0614..dabbc842ae 100644 --- a/src/compiler/scala/tools/nsc/symtab/Definitions.scala +++ b/src/compiler/scala/tools/nsc/symtab/Definitions.scala @@ -15,6 +15,7 @@ trait Definitions requires SymbolTable { def isDefinitionsInitialized = isInitialized; // root packages and classes + var RootPackage: Symbol = _; var RootClass: Symbol = _; var EmptyPackage: Symbol = _; var EmptyPackageClass: Symbol = _; @@ -411,6 +412,9 @@ trait Definitions requires SymbolTable { RootClass = NoSymbol.newClass(Position.NOPOS, nme.ROOT.toTypeName) .setFlag(FINAL | MODULE | PACKAGE | JAVA).setInfo(rootLoader); + RootPackage = NoSymbol.newValue(Position.NOPOS, nme.ROOTPKG) + .setFlag(FINAL | MODULE | PACKAGE | JAVA) + .setInfo(PolyType(List(), RootClass.tpe)); EmptyPackage = RootClass.newPackage(Position.NOPOS, nme.EMPTY_PACKAGE_NAME).setFlag(FINAL); @@ -419,6 +423,7 @@ trait Definitions requires SymbolTable { EmptyPackage.setInfo(EmptyPackageClass.tpe); RootClass.info.decls.enter(EmptyPackage); + RootClass.info.decls.enter(RootPackage); JavaPackage = getModule("java"); JavaLangPackage = getModule("java.lang"); diff --git a/src/compiler/scala/tools/nsc/symtab/StdNames.scala b/src/compiler/scala/tools/nsc/symtab/StdNames.scala index 1d64005f58..549d2dac23 100644 --- a/src/compiler/scala/tools/nsc/symtab/StdNames.scala +++ b/src/compiler/scala/tools/nsc/symtab/StdNames.scala @@ -148,6 +148,7 @@ trait StdNames requires SymbolTable { val ZERO = newTermName(""); val STAR = newTermName("*"); val ROOT = newTermName(""); + val ROOTPKG = newTermName("_root_"); val REPEATED_PARAM_CLASS_NAME = newTermName(""); val BYNAME_PARAM_CLASS_NAME = newTermName(""); val SELF = newTermName("$this"); diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala index 0df3271bb8..1d64ad6026 100644 --- a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala +++ b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala @@ -93,7 +93,8 @@ abstract class SymbolLoaders { protected def doComplete(root: Symbol): unit = { assert(root.isPackageClass, root); - root.setInfo(new PackageClassInfoType(new Scope(), root)); + val scope = new Scope() + root.setInfo(new PackageClassInfoType(scope, root)); /** Is the given name a valid input file base name? */ def isValid(name: String): boolean = @@ -107,8 +108,8 @@ abstract class SymbolLoaders { } def enterClassAndModule(str: String, completer: SymbolLoader): unit = { - val owner = if (root.isRoot) definitions.EmptyPackageClass else root; - val name = newTermName(str); + val owner = if (root.isRoot) definitions.EmptyPackageClass else root; + val name = newTermName(str); val clazz = owner.newClass(Position.NOPOS, name.toTypeName); val module = owner.newModule(Position.NOPOS, name); clazz.setInfo(completer); diff --git a/src/compiler/scala/tools/nsc/symtab/Symbols.scala b/src/compiler/scala/tools/nsc/symtab/Symbols.scala index 613470c975..38f94f9eca 100644 --- a/src/compiler/scala/tools/nsc/symtab/Symbols.scala +++ b/src/compiler/scala/tools/nsc/symtab/Symbols.scala @@ -95,7 +95,7 @@ trait Symbols requires SymbolTable { m.setModuleClass(new ModuleClassSymbol(m)) } final def newPackage(pos: int, name: Name) = { - assert(isPackageClass); + assert(name == nme.ROOT || isPackageClass); val m = newModule(pos, name).setFlag(JAVA | PACKAGE); m.moduleClass.setFlag(JAVA | PACKAGE); m diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala index a74c7f20b9..8ce72b46ce 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala @@ -88,7 +88,9 @@ trait Namers requires Analyzer { if (!(sym.isSourceMethod && sym.owner.isClass && !sym.owner.isPackageClass)) { val prev = context.scope.lookupEntry(sym.name); if (prev != null && prev.owner == context.scope && - (!prev.sym.isSourceMethod || sym.owner.isPackageClass)) { + (!prev.sym.isSourceMethod || + nme.isSetterName(sym.name) || + sym.owner.isPackageClass)) { /* if (sym.sourceFile == null && prev.sym.sourceFile == null) {} diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index d7390fd053..81ac6b0458 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -654,7 +654,12 @@ trait Typers requires Analyzer { result } def setterDef: DefDef = { - val setter = value.owner.info.decl(nme.getterToSetter(getter.name)).suchThat(.isSetter) + var setter = value.owner.info.decl(nme.getterToSetter(getter.name)).filter( + .tpe.=:=(MethodType(List(value.tpe.resultType), UnitClass.tpe))); + // note can't use .suchThat(.isSetter) above, + // because generated setters of abstract variables are not setters in this sense. + if (setter hasFlag OVERLOADED) setter = setter.alternatives.head; + // we will get a double definition error later anyway! assert(setter != NoSymbol, getter);//debug @@ -1564,7 +1569,9 @@ trait Typers requires Analyzer { if (util.Statistics.enabled) selcnt = selcnt + 1 var qual1 = typedQualifier(qual) if (name.isTypeName) qual1 = checkStable(qual1) - typedSelect(qual1, name) + val tree1 = typedSelect(qual1, name) + if (qual1.symbol == RootPackage) copy.Ident(tree1, name) + else tree1 case Ident(name) => idcnt = idcnt + 1 -- cgit v1.2.3