Drop all code under !newScheme

Author: odersky

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

@@ -710,10 +710,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
     /** A select node with the given selector name and signature and a computed type */
     def selectWithSig(name: Name, sig: Signature)(implicit ctx: Context): Tree =
-      untpd.SelectWithSig(tree, name, sig)
-        .withType(
-          if (config.Config.newScheme) tree.tpe.select(name.asTermName, sig)
-          else TermRef(tree.tpe, name.asTermName.withSig(sig)))
+      untpd.SelectWithSig(tree, name, sig).withType(tree.tpe.select(name.asTermName, sig))
 
     /** A select node with selector name and signature taken from `sym`.
      *  Note: Use this method instead of select(sym) if the referenced symbol

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

@@ -9,7 +9,6 @@ import Texts.Text
 import Decorators._
 import Contexts.Context
 import StdNames.str
-import Designators._
 import util.Chars.isIdentifierStart
 import collection.IndexedSeqOptimized
 import collection.immutable
@@ -30,6 +29,11 @@ object Names {
 
   implicit def eqName: Eq[Name, Name] = Eq
 
+  /** A common superclass of Name and Symbol. After bootstrap, this should be
+   *  just the type alias Name | Symbol
+   */
+  abstract class Designator extends util.DotClass
+
   /** A name if either a term name or a type name. Term names can be simple
    *  or derived. A simple term name is essentially an interned string stored
    *  in a name table. A derived term name adds a tag, and possibly a number
@@ -151,12 +155,6 @@ object Names {
     /** Does (the last part of) this name end with `str`? */
     def endsWith(str: String): Boolean = lastPart.endsWith(str)
 
-    /** Designator overrides */
-    override def isTerm(implicit ctx: Context) = isTermName
-    override def isType(implicit ctx: Context) = isTypeName
-    override def asTerm(implicit ctx: Context) = asTermName
-    override def asType(implicit ctx: Context) = asTypeName
-
     override def hashCode = System.identityHashCode(this)
     override def equals(that: Any) = this eq that.asInstanceOf[AnyRef]
   }

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

@@ -1130,12 +1130,10 @@ object SymDenotations {
     def thisType(implicit ctx: Context): Type = NoPrefix
 
     override def typeRef(implicit ctx: Context): TypeRef =
-      if (Config.newScheme) TypeRef.withSym(owner.thisType, symbol.asType)
-      else TypeRef(owner.thisType, name.asTypeName, this)
+      TypeRef(owner.thisType, symbol)
 
     override def termRef(implicit ctx: Context): TermRef =
-      if (Config.newScheme) TermRef.withSym(owner.thisType, symbol.asTerm)
-      else TermRef(owner.thisType, name.asTermName, this)
+      TermRef(owner.thisType, symbol)
 
     /** The variance of this type parameter or type member as an Int, with
      *  +1 = Covariant, -1 = Contravariant, 0 = Nonvariant, or not a type parameter
@@ -1436,10 +1434,9 @@ object SymDenotations {
       if (classParents.isEmpty && !emptyParentsExpected)
         onBehalf.signalProvisional()
       val builder = new BaseDataBuilder
-      for (p <- classParents) {
-        assert(p.typeSymbol.isClass, s"$this has $p")
+      for (p <- classParents)
         builder.addAll(p.typeSymbol.asClass.baseClasses)
-      }
+
       (classSymbol :: builder.baseClasses, builder.baseClassSet)
     }
 

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

@@ -10,7 +10,6 @@ import java.lang.AssertionError
 import Decorators._
 import Symbols._
 import Contexts._
-import Designators._
 import SymDenotations._
 import printing.Texts._
 import printing.Printer
@@ -154,9 +153,7 @@ trait Symbols { this: Context =>
         infoFn(module, modcls), privateWithin)
     val mdenot = SymDenotation(
         module, owner, name, modFlags | ModuleValCreationFlags,
-        if (cdenot.isCompleted)
-          if (config.Config.newScheme) TypeRef.withSym(owner.thisType, modcls)
-          else TypeRef.withSymOLD(owner.thisType, modcls, modclsName)
+        if (cdenot.isCompleted) TypeRef(owner.thisType, modcls)
         else new ModuleCompleter(modcls))
     module.denot = mdenot
     modcls.denot = cdenot
@@ -181,9 +178,7 @@ trait Symbols { this: Context =>
     newModuleSymbol(
         owner, name, modFlags, clsFlags,
         (module, modcls) => ClassInfo(
-          owner.thisType, modcls, parents, decls,
-          if (config.Config.newScheme) TermRef.withSym(owner.thisType, module)
-          else TermRef.withSymOLD(owner.thisType, module, name)),
+          owner.thisType, modcls, parents, decls, TermRef(owner.thisType, module)),
         privateWithin, coord, assocFile)
 
   val companionMethodFlags = Flags.Synthetic | Flags.Private | Flags.Method
@@ -291,10 +286,7 @@ trait Symbols { this: Context =>
     for (name <- names) {
       val tparam = newNakedSymbol[TypeName](NoCoord)
       tparamBuf += tparam
-      trefBuf += (
-        if (config.Config.newScheme) TypeRef.withSym(owner.thisType, tparam)
-        else TypeRef.withSymOLD(owner.thisType, tparam, name)
-      )
+      trefBuf += TypeRef(owner.thisType, tparam)
     }
     val tparams = tparamBuf.toList
     val bounds = boundsFn(trefBuf.toList)
@@ -459,16 +451,15 @@ object Symbols {
         // 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.
 
-    /** Designator overrides */
-    final override def isTerm(implicit ctx: Context): Boolean =
+    final def isTerm(implicit ctx: Context): Boolean =
       (if (defRunId == ctx.runId) lastDenot else denot).isTerm
-    final override def isType(implicit ctx: Context): Boolean =
+    final def isType(implicit ctx: Context): Boolean =
       (if (defRunId == ctx.runId) lastDenot else denot).isType
-    final override def asTerm(implicit ctx: Context): TermSymbol = {
+    final def asTerm(implicit ctx: Context): TermSymbol = {
       assert(isTerm, s"asTerm called on not-a-Term $this" );
       asInstanceOf[TermSymbol]
     }
-    final override def asType(implicit ctx: Context): TypeSymbol = {
+    final def asType(implicit ctx: Context): TypeSymbol = {
       assert(isType, s"isType called on not-a-Type $this");
       asInstanceOf[TypeSymbol]
     }