Get rid of referenced to WithFixedSym

 - simplify Substituters
 - use sym.isOverridable as a test instead of checking whether
   the reference is a WithFixedSym.

Author: odersky

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -85,10 +85,8 @@ object Trees {
      *  which implements copy-on-write. Another use-case is in method interpolateAndAdapt in Typer,
      *  where we overwrite with a simplified version of the type itself.
      */
-    private[dotc] def overwriteType(tpe: T) = {
-      if (this.isInstanceOf[Template[_]]) assert(tpe.isInstanceOf[WithFixedSym], s"$this <--- $tpe")
+    private[dotc] def overwriteType(tpe: T) =
       myTpe = tpe
-    }
 
     /** The type of the tree. In case of an untyped tree,
      *   an UnAssignedTypeException is thrown. (Overridden by empty trees)

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

@@ -130,10 +130,7 @@ trait Substituters { this: Context =>
         var ts = to
         while (fs.nonEmpty) {
           if (fs.head eq sym)
-            return tp match {
-              case tp: WithFixedSym => NamedType.withFixedSym(tp.prefix, ts.head)
-              case _ => substSym(tp.prefix, from, to, theMap) select ts.head
-            }
+            return substSym(tp.prefix, from, to, theMap) select ts.head
           fs = fs.tail
           ts = ts.tail
         }

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

@@ -457,7 +457,10 @@ object SymDenotations {
       validFor.runId == ctx.runId || ctx.stillValid(this)
 
     final def isReferencedSymbolically(implicit ctx: Context) =
-      (this is NonMember) || isTerm && ctx.phase.symbolicRefs
+      is(NonMember) || isTerm && ctx.phase.symbolicRefs
+
+    final def isOverridable(implicit ctx: Context) =
+      !(isReferencedSymbolically || is(Private) || isConstructor || maybeOwner.isTerm)
 
     /** Is this symbol the root class or its companion object? */
     final def isRoot: Boolean =

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

@@ -189,7 +189,8 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
                   tp1.symbol.companionModule
                 else
                   tp1.symbol
-              if ((sym1 ne NoSymbol) && (sym1 eq tp2.symbol))
+              val sym2 = tp2.symbol
+              if ((sym1 ne NoSymbol) && (sym1 eq sym2))
                 ctx.erasedTypes ||
                 sym1.isStaticOwner ||
                 isSubType(tp1.prefix, tp2.prefix) ||
@@ -198,8 +199,8 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
                 (  (tp1.name eq tp2.name)
                 && isSubType(tp1.prefix, tp2.prefix)
                 && tp1.signature == tp2.signature
-                && !tp1.isInstanceOf[WithFixedSym]
-                && !tp2.isInstanceOf[WithFixedSym]
+                && sym1.isOverridable
+                && sym2.isOverridable
                 ) ||
                 thirdTryNamed(tp1, tp2)
             case _ =>

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

@@ -1562,12 +1562,6 @@ 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
@@ -1579,7 +1573,7 @@ object Types {
             if (sym != null && sym.isValidInCurrentRun) denotOfSym(sym) else loadDenot
           case d: SymDenotation =>
             if (d.isValidInCurrentRun)
-              if (keepSymbol(d)) d.current
+              if (!d.isOverridable || d.exists && prefix.isTightPrefix(d.owner)) d.current
               else recomputeMember(d) // symbol could have been overridden, recompute membership
             else {
               val newd = loadDenot

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

@@ -320,8 +320,7 @@ class TreeChecker extends Phase with SymTransformer {
       assert(tree.isTerm || !ctx.isAfterTyper, tree.show + " at " + ctx.phase)
       val tpe = tree.typeOpt
       val sym = tree.symbol
-      if (!tpe.isInstanceOf[WithFixedSym] &&
-          sym.exists && !sym.is(Private) &&
+      if (sym.exists && sym.isOverridable &&
           !tree.name.is(OuterSelectName) // outer selects have effectively fixed symbols
           ) {
         val qualTpe = tree.qualifier.typeOpt