bug fixes

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("<zero>");
     val STAR = newTermName("*");
     val ROOT = newTermName("<root>");
+    val ROOTPKG = newTermName("_root_");
     val REPEATED_PARAM_CLASS_NAME = newTermName("<repeated>");
     val BYNAME_PARAM_CLASS_NAME = newTermName("<byname>");
     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