Fail on all stale references by default

Update stale references only if -Yupdate-state is set, fail with a StaleSymbol
error otherwise.

This required some fixes to the way ScalaShadowing was treated. If we compile a
ScalaShadowing (as is done in tasty-bootstrap) we need to also overwrite the
mirrored symbol in the scala package. Otherwise we would get a stale reference
when looking up the latter.

Author: odersky

compiler/src/dotty/tools/dotc/config/Config.scala

@@ -144,11 +144,6 @@ object Config {
    */
   final val simplifyApplications = true
 
-  /** If this flag is on, automatically being forward no-longer valid package members.
-   *  If it is off, raise a StaleSymbol error instead.
-   */
-  final val autoUpdatePackageMembers = true
-
   /** If set, prints a trace of all symbol completions */
   final val showCompletions = false
 

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -102,6 +102,7 @@ class ScalaSettings extends Settings.SettingGroup {
   val YkeepComments = BooleanSetting("-Ykeep-comments", "Keep comments when scanning source files.")
   val YforceSbtPhases = BooleanSetting("-Yforce-sbt-phases", "Run the phases used by sbt for incremental compilation (ExtractDependencies and ExtractAPI) even if the compiler is ran outside of sbt, for debugging.")
   val YdumpSbtInc = BooleanSetting("-Ydump-sbt-inc", "For every compiled foo.scala, output the API representation and dependencies used for sbt incremental compilation in foo.inc, implies -Yforce-sbt-phases.")
+  val YupdateStale = BooleanSetting("-Yupdate-stale", "Automically update stale top-level classes and objects to latest version")
   val YcheckAllPatmat = BooleanSetting("-Ycheck-all-patmat", "Check exhaustivity and redundancy of all pattern matching (used for testing the algorithm)")
   val YretainTrees = BooleanSetting("-Yretain-trees", "Retain trees for top-level classes, accessible from ClassSymbol#tree")
   val YshowTreeIds = BooleanSetting("-Yshow-tree-ids", "Uniquely tag all tree nodes in debugging output.")

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

@@ -209,7 +209,7 @@ class Definitions {
    *  members at runtime.
    */
   lazy val ScalaShadowingPackageVal = ctx.requiredPackage(nme.scalaShadowing)
-  lazy val ScalaShadowingPackageClass = ScalaShadowingPackageVal.moduleClass.asClass
+  def ScalaShadowingPackageClass(implicit ctx: Context) = ScalaShadowingPackageVal.moduleClass.asClass
 
   /** Note: We cannot have same named methods defined in Object and Any (and AnyVal, for that matter)
    *  because after erasure the Any and AnyVal references get remapped to the Object methods
@@ -828,6 +828,9 @@ class Definitions {
   def isTupleClass(cls: Symbol) = isVarArityClass(cls, str.Tuple)
   def isProductClass(cls: Symbol) = isVarArityClass(cls, str.Product)
 
+  def isScalaShadowingPackageClass(cls: Symbol) =
+    cls.name == tpnme.scalaShadowing && cls.owner == RootClass
+
   /** Returns the erased class of the function class `cls`
    *    - FunctionN for N > 22 becomes FunctionXXL
    *    - FunctionN for 22 > N >= 0 remains as FunctionN

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

@@ -774,16 +774,26 @@ object Denotations {
 
     /** Move validity period of this denotation to a new run. Throw a StaleSymbol error
      *  if denotation is no longer valid.
+     *  However, StaleSymbol error is not thrown in the following situations:
+     *
+     *   - If the symbol is a toplevel class or object and -Yupdate-stale is set.
+     *     update the denotation to the new symbol with the same name instead.
+     *   - If ctx.acceptStale returns true (because we are in the IDE),
+     *     update the symbol to the new version if it exists, or return
+     *     the old version otherwise.
+     *   - If the symbol did not have a denotation that was defined at the current phase
+     *     return a NoDenotation instead.
      */
     private def bringForward()(implicit ctx: Context): SingleDenotation = {
       this match {
         case symd: SymDenotation =>
           if (ctx.stillValid(symd)) return updateValidity()
-          if (Config.autoUpdatePackageMembers && symd.owner.is(Package)) {
+          lazy val staleOK = ctx.acceptStale(symd)
+          if (ctx.settings.YupdateStale.value && symd.owner.is(Package) || staleOK) {
             val newd = symd.owner.info.decls.lookup(symd.name)
             if (newd.exists) return newd
+            else if (staleOK) return updateValidity()
           }
-          if (ctx.acceptStale(symd)) return updateValidity()
         case _ =>
       }
       if (!symbol.exists) return updateValidity()

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

@@ -1486,6 +1486,8 @@ object SymDenotations {
         if (nxt.validFor.code > this.validFor.code) {
           this.nextInRun.asSymDenotation.asClass.enter(sym)
         }
+        if (defn.isScalaShadowingPackageClass(sym.owner))
+          defn.ScalaPackageClass.enter(sym)  // ScalaShadowing members are mirrored in ScalaPackage
       }
     }
 
@@ -1843,6 +1845,7 @@ object SymDenotations {
       if (entry != null) {
         if (entry.sym == sym) return false
         mscope.unlink(entry)
+        if (sym.owner == defn.ScalaShadowingPackageClass)
         if (sym.name == nme.PACKAGE) packageObjRunId = NoRunId
       }
       true