Avoid referring to stale package object member symbols

Author: retronym

src/compiler/scala/tools/nsc/Global.scala

@@ -390,7 +390,9 @@ class Global(var currentSettings: Settings, reporter0: Reporter)
 
 // ------------ Phases -------------------------------------------}
 
-  var globalPhase: Phase = NoPhase
+  private[this] var _globalPhase: Phase = NoPhase
+  override final def globalPhase: Phase = _globalPhase
+  final def globalPhase_=(ph: Phase): Unit = _globalPhase = ph
 
   abstract class GlobalPhase(prev: Phase) extends Phase(prev) {
     phaseWithId(id) = this

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

@@ -47,9 +47,13 @@ abstract class SymbolLoaders {
   protected def compileLate(srcfile: AbstractFile): Unit
 
   protected def enterIfNew(owner: Symbol, member: Symbol, completer: SymbolLoader): Symbol = {
-    assert(owner.info.decls.lookup(member.name) == NoSymbol, owner.fullName + "." + member.name)
-    owner.info.decls enter member
-    member
+    owner.info.decls.lookup(member.name) match {
+      case NoSymbol =>
+        owner.info.decls enter member
+        member
+      case member =>
+        member
+    }
   }
 
   protected def signalError(root: Symbol, ex: Throwable) {
@@ -280,10 +284,11 @@ abstract class SymbolLoaders {
       val shownPackageName = if (packageName == ClassPath.RootPackage) "<root package>" else packageName
       s"package loader $shownPackageName"
     }
+    override val decls = newScope
 
     protected def doComplete(root: Symbol) {
       assert(root.isPackageClass, root)
-      root.setInfo(new PackageClassInfoType(newScope, root))
+      root.setInfo(new PackageClassInfoType(decls, root))
 
       val classPathEntries = classPath.list(packageName)
 

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

@@ -762,7 +762,8 @@ trait Namers extends MethodSynthesis {
     def enterPackage(tree: PackageDef) {
       val sym = createPackageSymbol(tree.pos, tree.pid)
       tree.symbol = sym
-      newNamer(context.make(tree, sym.moduleClass, sym.info.decls)) enterSyms tree.stats
+      val scope = sym.rawInfo.typeSymbolDirect.rawInfo.decls
+      newNamer(context.make(tree, sym.moduleClass, scope)) enterSyms tree.stats
     }
 
     private def enterImport(tree: Import) = {
@@ -2161,7 +2162,7 @@ trait Namers extends MethodSynthesis {
     // scala/bug#7264 Force the info of owners from previous compilation runs.
     //         Doing this generally would trigger cycles; that's what we also
     //         use the lower-level scan through the current Context as a fall back.
-    if (!currentRun.compiles(owner)) owner.initialize
+    if (!owner.isPackageClass && !currentRun.compiles(owner)) owner.initialize
 
     if (original.isModuleClass) original.sourceModule
     else if (!owner.isTerm && owner.hasCompleteInfo)

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

@@ -1863,9 +1863,14 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
     def typedModuleDef(mdef: ModuleDef): Tree = {
       // initialize all constructors of the linked class: the type completer (Namer.methodSig)
       // might add default getters to this object. example: "object T; class T(x: Int = 1)"
-      val linkedClass = companionSymbolOf(mdef.symbol, context)
-      if (linkedClass != NoSymbol)
+      val linkedClass = companionSymbolOf(mdef.symbol, context).suchThat { sym =>
+        val isStale = sym.rawInfo.isInstanceOf[loaders.ClassfileLoader]
+        if (isStale) sym.owner.info.decls.unlink(sym)
+        !isStale
+      }
+      if (linkedClass != NoSymbol) {
         linkedClass.info.decl(nme.CONSTRUCTOR).alternatives foreach (_.initialize)
+      }
 
       val clazz = mdef.symbol.moduleClass
       currentRun.profiler.beforeTypedImplDef(clazz)

src/reflect/scala/reflect/internal/SymbolTable.scala

@@ -244,6 +244,7 @@ abstract class SymbolTable extends macros.Universe
   final def phase: Phase = {
     ph
   }
+  def globalPhase: Phase = phase
 
   def atPhaseStackMessage = atPhaseStack match {
     case Nil    => ""
@@ -352,6 +353,7 @@ abstract class SymbolTable extends macros.Universe
 
   def openPackageModule(container: Symbol, dest: Symbol) {
     // unlink existing symbols in the package
+    assert(globalPhase.name != "namer")
     for (member <- container.info.decls.iterator) {
       if (!member.isPrivate && !member.isConstructor) {
         // todo: handle overlapping definitions in some way: mark as errors

src/reflect/scala/reflect/internal/Types.scala

@@ -3541,7 +3541,7 @@ trait Types
 // Creators ---------------------------------------------------------------
 
   /** Rebind symbol `sym` to an overriding member in type `pre`. */
-  private def rebind(pre: Type, sym: Symbol): Symbol = {
+  private[scala] def rebind(pre: Type, sym: Symbol): Symbol = {
     if (!sym.isOverridableMember || sym.owner == pre.typeSymbol) sym
     else pre.nonPrivateMember(sym.name).suchThat { sym =>
       // scala/bug#7928 `isModuleNotMethod` is here to avoid crashing with spuriously "overloaded" module accessor and module symbols.

test/junit/scala/tools/nsc/DeterminismTest.scala

@@ -1,8 +1,11 @@
 package scala.tools.nsc
 
-import org.junit.Test
+import java.nio.file.{Files, Path, Paths}
+
+import org.junit.{Ignore, Test}
 
 import scala.reflect.internal.util.{BatchSourceFile, SourceFile}
+import scala.reflect.io.AbstractFile
 
 class DeterminismTest {
   private val tester = new DeterminismTester
@@ -309,5 +312,14 @@ class DeterminismTest {
     test(List(code))
   }
 
+  @Test def testPackageObjectUserLand(): Unit = {
+    def code = List[SourceFile](
+      source("package.scala", "package userland; object `package` { type Throwy = java.lang.Throwable }"),
+      source("th.scala", "package userland; class th[T <: Throwy](cause: T = null)")
+    )
+    test(code :: Nil, permuter = _.reverse :: Nil)
+  }
+
   def source(name: String, code: String): SourceFile = new BatchSourceFile(name, code)
+  def source(path: Path): SourceFile = new BatchSourceFile(AbstractFile.getFile(path.toFile))
 }

test/junit/scala/tools/nsc/DeterminismTester.scala

@@ -31,18 +31,19 @@ object DeterminismTester extends DeterminismTester {
       else path :: Nil
     }
     val sourceFiles = sourceFilesPaths.map(Paths.get(_)).flatMap(expand).map(path => new BatchSourceFile(AbstractFile.getFile(path.toFile)))
-    test(scalacOpts, sourceFiles :: Nil)
+    test(sourceFiles :: Nil, scalacOpts)
   }
 }
 
 class DeterminismTester {
 
-  def test(groups: List[List[SourceFile]]): Unit = test(Nil, groups)
-  def test(scalacOptions: List[String], groups: List[List[SourceFile]]): Unit = {
+  def test(groups: List[List[SourceFile]]): Unit = test(groups, Nil)
+  def test(groups: List[List[SourceFile]], scalacOptions: List[String] = Nil,
+           permuter: List[SourceFile] => List[List[SourceFile]] = defaultPermuter(_)): Unit = {
     val referenceOutput = Files.createTempDirectory("reference")
 
     def compile(output: Path, files: List[SourceFile]): Unit = {
-      // println("compile: " + files)
+       println("====== compile: " + files.map(_.file.absolute).map("\"" + _ + "\"").mkString(",\n"))
       val g = new Global(new Settings)
       g.settings.usejavacp.value = true
       g.settings.classpath.value = output.toAbsolutePath.toString
@@ -88,9 +89,7 @@ class DeterminismTester {
         super.visitFile(file, attrs)
       }
     }
-    val permutations: List[List[SourceFile]] = if (groups.last.size > 32) {
-      groups.last.reverse :: groups.last.map(_ :: Nil)
-    } else permutationsWithSubsets(groups.last)
+    val permutations: List[List[SourceFile]] = permuter(groups.last)
     for (permutation <- permutations) {
       val recompileOutput = Files.createTempDirectory("recompileOutput")
       copyRecursive(referenceOutput, recompileOutput)
@@ -99,7 +98,11 @@ class DeterminismTester {
       deleteRecursive(recompileOutput)
     }
     deleteRecursive(referenceOutput)
-
+  }
+  def defaultPermuter(sources: List[SourceFile]): List[List[SourceFile]] = {
+    if (sources.size > 32) {
+      sources.reverse :: sources.map(_ :: Nil)
+    } else permutationsWithSubsets(sources)
   }
   def permutationsWithSubsets[A](as: List[A]): List[List[A]] =
     as.permutations.toList.flatMap(_.inits.filter(_.nonEmpty)).distinct