refinement of sbaz fix; fixed scala#419

Author: odersky

src/compiler/scala/tools/nsc/CompilationUnits.scala

@@ -8,7 +8,7 @@ package scala.tools.nsc
 
 import scala.tools.nsc.util.{FreshNameCreator,OffsetPosition,Position,SourceFile}
 import scala.tools.nsc.io.AbstractFile
-import scala.collection.mutable.HashSet
+import scala.collection.mutable.{HashSet, HashMap}
 
 trait CompilationUnits { self: Global =>
 
@@ -27,6 +27,10 @@ trait CompilationUnits { self: Global =>
      */
     val depends = new HashSet[Symbol]
 
+    /** Synthetic definitions generated by namer, eliminated by typer.
+     */
+    val synthetics = new HashMap[Symbol, Tree]
+
     /** used to track changes in a signature */
     var pickleHash : Long = 0
 

src/compiler/scala/tools/nsc/symtab/Symbols.scala

@@ -861,12 +861,27 @@ trait Symbols {
         if (isClass) this else moduleClass
       } else owner.toplevelClass
 
+    /** Is this symbol defined in the same scope and compilation unit as `that' symbol?
+     */
+    def isCoDefinedWith(that: Symbol) =
+      (this.rawInfo ne NoType) && {
+        val res =
+          !this.owner.isPackageClass ||
+          (this.sourceFile eq null) ||
+          (that.sourceFile eq null) ||
+          (this.sourceFile eq that.sourceFile)
+        if (!res) {
+          println("strange linked: "+this+" "+this.locationString+";"+this.sourceFile+"/"+that+that.locationString+";"+that.sourceFile+";"+that.moduleClass.sourceFile)
+        }
+        res
+      }
+
     /** The class with the same name in the same package as this module or
      *  case class factory
      */
     final def linkedClassOfModule: Symbol = {
       if (this != NoSymbol)
-        owner.info.decl(name.toTypeName).suchThat(sym => sym.rawInfo ne NoType)
+        owner.info.decl(name.toTypeName).suchThat(_ isCoDefinedWith this)
       else NoSymbol
     }
 
@@ -876,15 +891,15 @@ trait Symbols {
     final def linkedModuleOfClass: Symbol =
       if (this.isClass && !this.isAnonymousClass && !this.isRefinementClass) {
         owner.rawInfo.decl(name.toTermName).suchThat(
-          sym => (sym hasFlag MODULE) && (sym.rawInfo ne NoType))
+          sym => (sym hasFlag MODULE) && (sym isCoDefinedWith this))
       } else NoSymbol
 
     /** For a module its linked class, for a class its linked module or case
      *  factory otherwise.
      */
     final def linkedSym: Symbol =
       if (isTerm) linkedClassOfModule
-      else if (isClass) owner.info.decl(name.toTermName).suchThat(sym => sym.rawInfo ne NoType)
+      else if (isClass) owner.info.decl(name.toTermName).suchThat(_ isCoDefinedWith this)
       else NoSymbol
 
     /** For a module class its linked class, for a plain class

src/compiler/scala/tools/nsc/typechecker/Namers.scala

@@ -230,7 +230,7 @@ trait Namers { self: Analyzer =>
           (!currentRun.compiles(m) || (m hasFlag SYNTHETIC))) {
         updatePosFlags(m, tree.pos, moduleFlags)
         setPrivateWithin(tree, m, tree.mods)
-        synthetics -= m
+        context.unit.synthetics -= m
       } else {
         m = context.owner.newModule(tree.pos, tree.name)
         m.setFlag(moduleFlags)
@@ -392,7 +392,7 @@ trait Namers { self: Analyzer =>
 
     def enterSyntheticSym(tree: Tree): Symbol = {
       enterSym(tree)
-      synthetics(tree.symbol) = (tree, context.unit.source)
+      context.unit.synthetics(tree.symbol) = tree
       tree.symbol
     }
 

src/compiler/scala/tools/nsc/typechecker/Typers.scala

@@ -38,14 +38,11 @@ trait Typers { self: Analyzer =>
 
   private val superDefs = new HashMap[Symbol, ListBuffer[Tree]]
 
-  val synthetics = new HashMap[Symbol, (Tree, SourceFile)]
-
   def resetTyper() {
     resetContexts
     resetNamer()
     transformed.clear
     superDefs.clear
-    synthetics.clear
   }
 
   object UnTyper extends Traverser {
@@ -1548,10 +1545,10 @@ trait Typers { self: Analyzer =>
           }
 
           // add synthetics
-          synthetics get e.sym match {
-            case Some((tree, source)) if (source eq context.unit.source) =>
+          context.unit.synthetics get e.sym match {
+            case Some(tree) =>
               newStats += tree
-              synthetics -= e.sym
+              context.unit.synthetics -= e.sym
             case _ =>
           }