Separate reload logic from WithFixedSym

Author: odersky

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -453,6 +453,12 @@ object SymDenotations {
       (this is (ModuleVal, butNot = Package)) && moduleClass.isAbsent
     }
 
+    final def isValidInCurrentRun(implicit ctx: Context): Boolean =
+      validFor.runId == ctx.runId || ctx.stillValid(this)
+
+    final def isReferencedSymbolically(implicit ctx: Context) =
+      (this is NonMember) || isTerm && ctx.phase.symbolicRefs
+
     /** Is this symbol the root class or its companion object? */
     final def isRoot: Boolean =
       (name.toTermName == nme.ROOT || name == nme.ROOTPKG) && (owner eq NoSymbol)

compiler/src/dotty/tools/dotc/core/Symbols.scala

@@ -425,7 +425,7 @@ object Symbols {
     }
 
     final def isValidInCurrentRun(implicit ctx: Context): Boolean =
-      lastDenot.validFor.runId == ctx.runId || ctx.stillValid(lastDenot)
+      lastDenot.isValidInCurrentRun
 
     /** Subclass tests and casts */
     final def isTerm(implicit ctx: Context): Boolean =
@@ -440,10 +440,8 @@ object Symbols {
     final def asType(implicit ctx: Context): TypeSymbol = { assert(isType, s"isType called on not-a-Type $this"); asInstanceOf[TypeSymbol] }
     final def asClass: ClassSymbol = asInstanceOf[ClassSymbol]
 
-    final def isReferencedSymbolically(implicit ctx: Context) = {
-      val sym = lastDenot
-      sym != null && ((sym is NonMember) || sym.isTerm && ctx.phase.symbolicRefs)
-    }
+    final def isReferencedSymbolically(implicit ctx: Context) =
+      lastDenot != null && lastDenot.isReferencedSymbolically
 
     /** Special cased here, because it may be used on naked symbols in substituters */
     final def isStatic(implicit ctx: Context): Boolean =

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -1562,6 +1562,12 @@ object Types {
         }
     }
 
+    private def keepSymbol(d: SymDenotation)(implicit ctx: Context) =
+      d.is(Private) ||
+      d.isConstructor ||
+      d.isReferencedSymbolically ||
+      d.exists && (d.owner.isTerm || prefix.isTightPrefix(d.owner))
+
     /** A second fallback to recompute the denotation if necessary */
     private def computeDenot(implicit ctx: Context): Denotation = {
       val savedEphemeral = ctx.typerState.ephemeral
@@ -1572,9 +1578,8 @@ object Types {
             val sym = lastSymbol
             if (sym != null && sym.isValidInCurrentRun) denotOfSym(sym) else loadDenot
           case d: SymDenotation =>
-            if (this.isInstanceOf[WithFixedSym]) d.current
-            else if (d.validFor.runId == ctx.runId || ctx.stillValid(d))
-              if (d.exists && prefix.isTightPrefix(d.owner) || d.isConstructor) d.current
+            if (d.isValidInCurrentRun)
+              if (keepSymbol(d)) d.current
               else recomputeMember(d) // symbol could have been overridden, recompute membership
             else {
               val newd = loadDenot