Polishings

Author: odersky

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

@@ -148,7 +148,7 @@ object Config {
   final val showCompletions = false
 
   /** If set, enables tracing */
-  final val tracingEnabled = true
+  final val tracingEnabled = false
 
   /** Initial capacity of uniques HashMap.
    *  Note: This MUST BE a power of two to work with util.HashSet

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

@@ -321,7 +321,6 @@ object Phases {
     private[this] var myErasedTypes = false
     private[this] var myFlatClasses = false
     private[this] var myRefChecked = false
-    private[this] var mySymbolicRefs = false
     private[this] var myLabelsReordered = false
 
     private[this] var mySameMembersStartId = NoPhaseId
@@ -340,7 +339,6 @@ object Phases {
     final def erasedTypes = myErasedTypes   // Phase is after erasure
     final def flatClasses = myFlatClasses   // Phase is after flatten
     final def refChecked = myRefChecked     // Phase is after RefChecks
-    final def symbolicRefs = mySymbolicRefs // Phase is after ResolveSuper, newly generated TermRefs should be symbolic
     final def labelsReordered = myLabelsReordered // Phase is after LabelDefs, labels are flattened and owner chains don't mirror this
 
     final def sameMembersStartId = mySameMembersStartId
@@ -357,7 +355,6 @@ object Phases {
       myErasedTypes  = prev.getClass == classOf[Erasure]      || prev.erasedTypes
       myFlatClasses  = prev.getClass == classOf[Flatten]      || prev.flatClasses
       myRefChecked   = prev.getClass == classOf[RefChecks]    || prev.refChecked
-      mySymbolicRefs = getClass == classOf[Erasure] || prev.symbolicRefs
       myLabelsReordered = prev.getClass == classOf[LabelDefs] || prev.labelsReordered
       mySameMembersStartId = if (changesMembers) id else prev.sameMembersStartId
       mySameParentsStartId = if (changesParents) id else prev.sameMembersStartId

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

@@ -1437,9 +1437,10 @@ object SymDenotations {
       if (classParents.isEmpty && !emptyParentsExpected)
         onBehalf.signalProvisional()
       val builder = new BaseDataBuilder
-      for (p <- classParents)
+      for (p <- classParents) {
+        assert(p.typeSymbol.isClass, s"$this has non-class parent: $p")
         builder.addAll(p.typeSymbol.asClass.baseClasses)
-
+      }
       (classSymbol :: builder.baseClasses, builder.baseClassSet)
     }
 
@@ -1851,20 +1852,18 @@ object SymDenotations {
     }
   }
 
-  class NoDenotation(sym: Symbol, name: Name, override val exists: Boolean)
-  extends SymDenotation(sym, NoSymbol, name, Permanent, NoType) {
+  @sharable object NoDenotation
+  extends SymDenotation(NoSymbol, NoSymbol, "<none>".toTermName, Permanent, NoType) {
     override def isType = false
-    override def isTerm = exists
+    override def isTerm = false
+    override def exists = false
     override def owner: Symbol = throw new AssertionError("NoDenotation.owner")
     override def computeAsSeenFrom(pre: Type)(implicit ctx: Context): SingleDenotation = this
     override def mapInfo(f: Type => Type)(implicit ctx: Context): SingleDenotation = this
-    sym.denot = this
+    NoSymbol.denot = this
     validFor = Period.allInRun(NoRunId)
   }
 
-  @sharable val NoDenotation: NoDenotation =
-    new NoDenotation(NoSymbol, "<none>".toTermName, exists = false)
-
   // ---- Completion --------------------------------------------------------
 
   /** Instances of LazyType are carried by uncompleted symbols.

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

@@ -451,9 +451,10 @@ object Symbols {
     final def isValidInCurrentRun(implicit ctx: Context): Boolean =
       (lastDenot.validFor.runId == ctx.runId || ctx.stillValid(lastDenot)) &&
       (lastDenot.symbol eq this)
-        // the last condition is needed because overwritten package members keep
-        // denotations pointing to the new symbol, so the validity periods check out OK.
-        // But once a package member is overridden it is not longerr valid.
+        // the last condition is needed because under option -Yupdate-stale overwritten
+        // package members keep denotations pointing to the new symbol, so the validity
+        // periods check out OK. But once a package member is overridden it is not longer
+        // valid. If the option would be removed, the check would be no longer needed.
 
     final def isTerm(implicit ctx: Context): Boolean =
       (if (defRunId == ctx.runId) lastDenot else denot).isTerm
@@ -471,14 +472,6 @@ object Symbols {
     final def isClass: Boolean = isInstanceOf[ClassSymbol]
     final def asClass: ClassSymbol = asInstanceOf[ClassSymbol]
 
-    /** Test whether symbol is referenced symbolically. This
-     *  conservatively returns `false` if symbol does not yet have a denotation
-     */
-    final def isReferencedSymbolically(implicit ctx: Context) = {
-      val d = lastDenot
-      d != null && (d.is(NonMember) || ctx.phase.symbolicRefs)
-    }
-
     /** Test whether symbol is private. This
      *  conservatively returns `false` if symbol does not yet have a denotation, or denotation
      *  is a class that is not yet read.

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

@@ -1686,10 +1686,8 @@ object Types {
 
     private def loadDenot(name: Name, allowPrivate: Boolean)(implicit ctx: Context): Denotation = {
       var d = memberDenot(prefix, name, allowPrivate)
-      if (!d.exists) {
-        val d1 = memberDenot(prefix, name, true)
-        assert(!d1.exists, i"bad allow private $this $name $d1 at ${ctx.phase}")
-      }
+      if (!d.exists && ctx.mode.is(Mode.Interactive))
+        d = memberDenot(prefix, name, true)
       if (!d.exists && ctx.phaseId > FirstPhaseId && lastDenotation.isInstanceOf[SymDenotation])
         // name has changed; try load in earlier phase and make current
         d = loadDenot(name, allowPrivate)(ctx.withPhase(ctx.phaseId - 1)).current
@@ -1698,6 +1696,9 @@ object Types {
       d
     }
 
+    /** Reload denotation by computing the member with the reference's name as seen
+     *  from the reference's prefix.
+     */
     def reloadDenot()(implicit ctx: Context) =
       setDenot(loadDenot(name, allowPrivate = !symbol.exists || symbol.is(Private)))
 
@@ -1706,7 +1707,7 @@ object Types {
 
     private def disambiguate(d: Denotation)(implicit ctx: Context): Denotation = {
       val sig = currentSignature
-      //if (ctx.isAfterTyper) println(i"overloaded $this / $d / sig = $sig")
+      //if (ctx.isAfterTyper) println(i"overloaded $this / $d / sig = $sig") // DEBUG
       if (sig != null)
         d.atSignature(sig, relaxed = !ctx.erasedTypes) match {
           case d1: SingleDenotation => d1
@@ -1900,10 +1901,12 @@ object Types {
         case _ => withPrefix(prefix)
       }
 
+    /** A reference like this one, but with the given symbol, if it exists */
     final def withSym(sym: Symbol)(implicit ctx: Context): ThisType =
       if ((designator ne sym) && sym.exists) NamedType(prefix, sym).asInstanceOf[ThisType]
       else this
 
+    /** A reference like this one, but with the given denotation, if it exists */
     final def withDenot(denot: Denotation)(implicit ctx: Context): ThisType =
       if (denot.exists) {
         val adapted = withSym(denot.symbol)
@@ -1916,8 +1919,7 @@ object Types {
       else // don't assign NoDenotation, we might need to recover later. Test case is pos/avoid.scala.
         this
 
-    /** Create a NamedType of the same kind as this type, but with a new prefix.
-     */
+    /** A reference like this one, but with the given prefix. */
     final def withPrefix(prefix: Type)(implicit ctx: Context): NamedType = {
       def reload(): NamedType = {
         val allowPrivate = !lastSymbol.exists || lastSymbol.is(Private) && prefix.classSymbol == this.prefix.classSymbol
@@ -1930,7 +1932,8 @@ object Types {
         }
         NamedType(prefix, name, d)
       }
-      if (lastDenotation == null) NamedType(prefix, designator)
+      if (prefix eq this.prefix) this
+      else if (lastDenotation == null) NamedType(prefix, designator)
       else designator match {
         case sym: Symbol =>
           if (infoDependsOnPrefix(sym, prefix)) {

compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala

@@ -86,7 +86,7 @@ class ElimErasedValueType extends MiniPhase with InfoTransformer {
       val site = root.thisType
       val info1 = site.memberInfo(sym1)
       val info2 = site.memberInfo(sym2)
-      def isDefined(sym: Symbol) = sym.lastKnownDenotation.initial.validFor.firstPhaseId <= ctx.phaseId
+      def isDefined(sym: Symbol) = sym.originDenotation.validFor.firstPhaseId <= ctx.phaseId
       if (isDefined(sym1) && isDefined(sym2) && !info1.matchesLoosely(info2))
         // The reason for the `isDefined` condition is that we need to exclude mixin forwarders
         // from the tests. For instance, in compileStdLib, compiling scala.immutable.SetProxy, line 29:

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -244,7 +244,7 @@ object Checking {
             locked += tp
             try checkInfo(tp.info)
             finally locked -= tp
-            if (pre1 eq pre) tp else tp.withPrefix(pre1)
+            tp.withPrefix(pre1)
           }
           else tp
         } catch {