Optionally make NamedTypes symbolic

For now it's controlled under a config option.

Author: odersky

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

@@ -700,7 +700,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       val tp =
         if (sym.isType) {
           assert(!sym.is(TypeParam))
-          TypeRef(tree.tpe, sym.name.asTypeName)
+          if (config.Config.newScheme) TypeRef.withSym(tree.tpe, sym.asType)
+          else TypeRef.applyOLD(tree.tpe, sym.name.asTypeName)
         }
         else
           TermRef(tree.tpe, sym.name.asTermName, sym.denot.asSeenFrom(tree.tpe))
@@ -710,7 +711,9 @@ 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(TermRef(tree.tpe, name.asTermName.withSig(sig)))
+        .withType(
+          if (config.Config.newScheme) tree.tpe.select(name.asTermName, sig)
+          else TermRef.applyOLD(tree.tpe, name.asTermName.withSig(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/config/Config.scala

@@ -148,7 +148,7 @@ object Config {
   final val showCompletions = false
 
   /** If set, enables tracing */
-  final val tracingEnabled = false
+  final val tracingEnabled = true
 
   /** Initial capacity of uniques HashMap.
    *  Note: This MUST BE a power of two to work with util.HashSet
@@ -179,4 +179,6 @@ object Config {
 
   /** When in IDE, turn StaleSymbol errors into warnings instead of crashing */
   final val ignoreStaleInIDE = true
+
+  val newScheme = false
 }

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

@@ -1130,10 +1130,12 @@ object SymDenotations {
     def thisType(implicit ctx: Context): Type = NoPrefix
 
     override def typeRef(implicit ctx: Context): TypeRef =
-      TypeRef(owner.thisType, name.asTypeName, this)
+      if (Config.newScheme) TypeRef.withSym(owner.thisType, symbol.asType)
+      else TypeRef(owner.thisType, name.asTypeName, this)
 
     override def termRef(implicit ctx: Context): TermRef =
-      TermRef(owner.thisType, name.asTermName, this)
+      if (Config.newScheme) TermRef.withSym(owner.thisType, symbol.asTerm)
+      else TermRef(owner.thisType, name.asTermName, this)
 
     /** The variance of this type parameter or type member as an Int, with
      *  +1 = Covariant, -1 = Contravariant, 0 = Nonvariant, or not a type parameter
@@ -1848,21 +1850,21 @@ object SymDenotations {
     }
   }
 
-  class NoDenotation(sym: Symbol, name: Name, override val isTerm: Boolean)
+  class NoDenotation(sym: Symbol, name: Name, override val exists: Boolean)
   extends SymDenotation(sym, NoSymbol, name, Permanent, NoType) {
-    override def exists = false
     override def isType = false
+    override def isTerm = exists
     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
     validFor = Period.allInRun(NoRunId)
   }
 
   @sharable val NoDenotation =
-    new NoDenotation(NoSymbol, "<none>".toTermName, isTerm = false)
+    new NoDenotation(NoSymbol, "<none>".toTermName, exists = false)
 
   @sharable val OverloadedDenotation =
-    new NoDenotation(OverloadedSymbol, "<overloaded>".toTermName, isTerm = true)
+    new NoDenotation(OverloadedSymbol, "<overloaded>".toTermName, exists = true)
 
   // ---- Completion --------------------------------------------------------
 

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

@@ -154,7 +154,9 @@ trait Symbols { this: Context =>
         infoFn(module, modcls), privateWithin)
     val mdenot = SymDenotation(
         module, owner, name, modFlags | ModuleCreationFlags,
-        if (cdenot.isCompleted) TypeRef.withSym(owner.thisType, modcls, modclsName)
+        if (cdenot.isCompleted)
+          if (config.Config.newScheme) TypeRef.withSym(owner.thisType, modcls)
+          else TypeRef.withSymOLD(owner.thisType, modcls, modclsName)
         else new ModuleCompleter(modcls))
     module.denot = mdenot
     modcls.denot = cdenot
@@ -179,7 +181,9 @@ trait Symbols { this: Context =>
     newModuleSymbol(
         owner, name, modFlags, clsFlags,
         (module, modcls) => ClassInfo(
-          owner.thisType, modcls, parents, decls, TermRef.withSym(owner.thisType, module, name)),
+          owner.thisType, modcls, parents, decls,
+          if (config.Config.newScheme) TermRef.withSym(owner.thisType, module)
+          else TermRef.withSymOLD(owner.thisType, module, name)),
         privateWithin, coord, assocFile)
 
   val companionMethodFlags = Flags.Synthetic | Flags.Private | Flags.Method
@@ -287,7 +291,10 @@ trait Symbols { this: Context =>
     for (name <- names) {
       val tparam = newNakedSymbol[TypeName](NoCoord)
       tparamBuf += tparam
-      trefBuf += TypeRef.withSym(owner.thisType, tparam, name)
+      trefBuf += (
+        if (config.Config.newScheme) TypeRef.withSym(owner.thisType, tparam)
+        else TypeRef.withSymOLD(owner.thisType, tparam, name)
+      )
     }
     val tparams = tparamBuf.toList
     val bounds = boundsFn(trefBuf.toList)
@@ -465,7 +472,7 @@ object Symbols {
      */
     final def isReferencedSymbolically(implicit ctx: Context) = {
       val d = lastDenot
-      d != null && (d.is(NonMember) || d.isTerm && ctx.phase.symbolicRefs)
+      d != null && (d.is(NonMember) || ctx.phase.symbolicRefs)
     }
 
     /** Test whether symbol is private. This

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

@@ -1128,11 +1128,21 @@ object Types {
 
     /** The type <this . name> , reduced if possible */
     def select(name: Name)(implicit ctx: Context): Type =
-      NamedType(this, name).reduceProjection
+      if (Config.newScheme) NamedType.withDenot(this, member(name)).reduceProjection
+      else NamedType.applyOLD(this, name).reduceProjection
+
+    def select(name: TermName)(implicit ctx: Context): TermRef =
+      if (Config.newScheme) TermRef.withDenot(this, member(name))
+      else TermRef.applyOLD(this, name)
+
+    def select(name: TermName, sig: Signature)(implicit ctx: Context): TermRef = {
+      assert(Config.newScheme)
+      TermRef.withDenot(this, member(name).atSignature(sig))
+    }
 
     /** The type <this . name> , reduced if possible, with given denotation if unreduced */
-    def select(name: Name, denot: Denotation)(implicit ctx: Context): Type =
-      NamedType(this, name, denot).reduceProjection
+    def select(name: Name, denot: Denotation)(implicit ctx: Context): Type = // ### drop name
+      NamedType.apply(this, name, denot).reduceProjection
 
     /** The type <this . name> with either `sym` or its signed name as designator, reduced if possible */
     def select(sym: Symbol)(implicit ctx: Context): Type =
@@ -1616,7 +1626,11 @@ object Types {
         val d = lastDenotation match {
           case null =>
             val sym = lastSymbol
-            if (sym != null && sym.isValidInCurrentRun) denotOfSym(sym) else loadDenot
+            if (sym != null && sym.isValidInCurrentRun &&
+                (!Config.newScheme ||
+                 (prefix eq NoPrefix) || (prefix eq sym.owner.thisType) || sym.isReferencedSymbolically))
+              denotOfSym(sym)
+            else loadDenot
           case d: SymDenotation =>
             if (d.validFor.runId == ctx.runId || ctx.stillValid(d))
               if (hasFixedSym)
@@ -1724,8 +1738,10 @@ object Types {
       	  this
       	else if (signature != denot.signature)
           withSig(denot.signature)
-        else if (denot.symbol.isPrivate)
-          withNameSpace(denot.symbol.owner.typeRef)
+        else if (denot.symbol.isPrivate) {
+          assert(!Config.newScheme)
+          withNameSpaceOLD(denot.symbol.owner.typeRef)
+        }
         else
           this
       if (adapted ne this) adapted.withDenot(denot).asInstanceOf[ThisType]
@@ -1766,11 +1782,13 @@ object Types {
       checkedPeriod = Nowhere
     }
 
-    private def withSig(sig: Signature)(implicit ctx: Context): NamedType =
-      TermRef(prefix, designator.withSig(sig))
+    private def withSig(sig: Signature)(implicit ctx: Context): NamedType = {
+      assert(!Config.newScheme)
+      TermRef.applyOLD(prefix, designator.withSig(sig))
+    }
 
     protected def loadDenot(implicit ctx: Context): Denotation = {
-      val d = asMemberOf(prefix, allowPrivate = false)
+      val d = asMemberOf(prefix, allowPrivate = Config.newScheme && hasFixedSym)
       def atSig(sig: Signature): Denotation =
         if (sig.ne(Signature.OverloadedSignature)) d.atSignature(sig).checkUnique
         else d
@@ -1945,9 +1963,9 @@ object Types {
 
     /** Create a NamedType of the same kind as this type, but with a new namespace.
      */
-    def withNameSpace(nameSpace: NameSpace)(implicit ctx: Context): NamedType =
+    def withNameSpaceOLD(nameSpace: NameSpace)(implicit ctx: Context): NamedType =
       if (nameSpace == this.nameSpace) this
-      else NamedType(prefix, designator.withNameSpace(nameSpace))
+      else NamedType.applyOLD(prefix, designator.withNameSpace(nameSpace))
 
     override def equals(that: Any) = that match {
       case that: NamedType =>
@@ -1985,7 +2003,8 @@ object Types {
     override def isOverloaded(implicit ctx: Context) = denot.isOverloaded
 
     private def rewrap(sd: SingleDenotation)(implicit ctx: Context) =
-      TermRef(prefix, name, sd)
+      if (Config.newScheme) TermRef.withDenot(prefix, sd)
+      else TermRef.apply(prefix, name, sd)
 
     def alternatives(implicit ctx: Context): List[TermRef] =
       denot.alternatives map rewrap
@@ -2019,7 +2038,8 @@ object Types {
             designator.withSig(newSig)
           }
           else designator
-        fixDenot(TermRef(prefix, designator1), prefix)
+        assert(!Config.newScheme)
+        fixDenot(TermRef.applyOLD(prefix, designator1), prefix)
     }
   }
 
@@ -2031,7 +2051,8 @@ object Types {
     override def underlying(implicit ctx: Context): Type = info
 
     def withPrefix(prefix: Type)(implicit ctx: Context): NamedType =
-      TypeRef(prefix, designator)
+      if (Config.newScheme) TypeRef(prefix, designator.asInstanceOf[TypeSymbol])
+      else TypeRef.applyOLD(prefix, designator)
   }
 
   final class CachedTermRef(prefix: Type, designator: TermDesignator, hc: Int) extends TermRef(prefix, designator) {
@@ -2049,12 +2070,19 @@ object Types {
     if (Config.checkUnerased) assert(!ctx.phase.erasedTypes)
 
   object NamedType {
-    def apply(prefix: Type, designator: Designator)(implicit ctx: Context) =
+    def applyOLD(prefix: Type, designator: Designator)(implicit ctx: Context) =
+      if (designator.isType) TypeRef.applyOLD(prefix, designator.asType)
+      else TermRef.applyOLD(prefix, designator.asTerm)
+    def apply(prefix: Type, designator: Symbol)(implicit ctx: Context) =
       if (designator.isType) TypeRef(prefix, designator.asType)
       else TermRef(prefix, designator.asTerm)
+    def withDenot(prefix: Type, denot: Denotation)(implicit ctx: Context) =
+      if (denot.isTerm) TermRef.withDenot(prefix, denot)
+      else TypeRef.withDenot(prefix, denot)
     def apply(prefix: Type, designator: Name, denot: Denotation)(implicit ctx: Context) =
-      if (designator.isTermName) TermRef(prefix, designator.asTermName, denot)
-      else TypeRef(prefix, designator.asTypeName, denot)
+      if (Config.newScheme) withDenot(prefix, denot)
+      else if (designator.isTermName) TermRef.apply(prefix, designator.asTermName, denot)
+      else TypeRef.apply(prefix, designator.asTypeName, denot)
     def withSym(prefix: Type, sym: Symbol)(implicit ctx: Context): NamedType =
       if (sym.isType) TypeRef.withSym(prefix, sym.asType)
       else TermRef.withSym(prefix, sym.asTerm)
@@ -2066,58 +2094,73 @@ object Types {
      *  Its meaning is the (potentially multi-) denotation of the member(s)
      *  of prefix with given name.
      */
-    def apply(prefix: Type, designator: TermDesignator)(implicit ctx: Context): TermRef =
+    def applyOLD(prefix: Type, designator: TermDesignator)(implicit ctx: Context): TermRef =
+      ctx.uniqueNamedTypes.enterIfNew(prefix, designator, isTerm = true).asInstanceOf[TermRef]
+
+    def apply(prefix: Type, designator: TermSymbol)(implicit ctx: Context): TermRef =
       ctx.uniqueNamedTypes.enterIfNew(prefix, designator, isTerm = true).asInstanceOf[TermRef]
 
     /** Create term ref to given initial denotation, taking the signature
      *  from the denotation if it is completed, or creating a term ref without
      *  signature, if denotation is not yet completed.
      */
     def apply(prefix: Type, name: TermName, denot: Denotation)(implicit ctx: Context): TermRef = {
-      if ((prefix eq NoPrefix) || denot.symbol.isReferencedSymbolically) apply(prefix, denot.symbol.asTerm)
+      if (Config.newScheme) withDenot(prefix, denot)
+      else if ((prefix eq NoPrefix) || denot.symbol.isReferencedSymbolically) apply(prefix, denot.symbol.asTerm)
       else denot match {
         case denot: SingleDenotation =>
-          apply(prefix, name.withSig(denot.signature).localizeIfPrivate(denot.symbol))
-        case _ => apply(prefix, name)
+          applyOLD(prefix, name.withSig(denot.signature).localizeIfPrivate(denot.symbol))
+        case _ => applyOLD(prefix, name)
       }
     } withDenot denot
 
+    def withDenot(prefix: Type, denot: Denotation)(implicit ctx: Context): TermRef =
+      apply(prefix, denot.symbol.asTerm).withDenot(denot)
+
     /** Create a term ref referring to given symbol with given name.
      *  This is similar to TermRef(Type, Symbol), except:
      *  (1) the symbol might not yet have a denotation, so the name needs to be given explicitly.
      *  (2) the designator of the TermRef is either the symbol or its name & unforced signature.
      */
-    def withSym(prefix: Type, sym: TermSymbol, name: TermName)(implicit ctx: Context): TermRef =
+    def withSymOLD(prefix: Type, sym: TermSymbol, name: TermName)(implicit ctx: Context): TermRef =
       if ((prefix eq NoPrefix) || sym.isReferencedSymbolically) apply(prefix, sym)
-      else apply(prefix, name.withSig(sym.signature).localizeIfPrivate(sym)).withSym(sym)
+      else applyOLD(prefix, name.withSig(sym.signature).localizeIfPrivate(sym)).withSym(sym)
 
     def withSym(prefix: Type, sym: TermSymbol)(implicit ctx: Context): TermRef =
-      withSym(prefix, sym, sym.name)
+      if (Config.newScheme) apply(prefix, sym) else withSymOLD(prefix, sym, sym.name)
   }
 
   object TypeRef {
 
     /** Create type ref with given prefix and name */
-    def apply(prefix: Type, desig: TypeDesignator)(implicit ctx: Context): TypeRef =
+    def applyOLD(prefix: Type, desig: TypeDesignator)(implicit ctx: Context): TypeRef =
+      ctx.uniqueNamedTypes.enterIfNew(prefix, desig, isTerm = false).asInstanceOf[TypeRef]
+
+    /** Create type ref with given prefix and name */
+    def apply(prefix: Type, desig: TypeSymbol)(implicit ctx: Context): TypeRef =
       ctx.uniqueNamedTypes.enterIfNew(prefix, desig, isTerm = false).asInstanceOf[TypeRef]
 
     /** Create a type ref with given name and initial denotation */
     def apply(prefix: Type, name: TypeName, denot: Denotation)(implicit ctx: Context): TypeRef = {
-      if ((prefix eq NoPrefix) || denot.symbol.isReferencedSymbolically) apply(prefix, denot.symbol.asType)
-      else apply(prefix, name.localizeIfPrivate(denot.symbol))
+      if (Config.newScheme) withDenot(prefix, denot)
+      else if ((prefix eq NoPrefix) || denot.symbol.isReferencedSymbolically) apply(prefix, denot.symbol.asType)
+      else applyOLD(prefix, name.localizeIfPrivate(denot.symbol))
     } withDenot denot
 
+    def withDenot(prefix: Type, denot: Denotation)(implicit ctx: Context): TypeRef =
+      apply(prefix, denot.symbol.asType).withDenot(denot)
+
     /** Create a type ref referring to either a given symbol or its name.
      *  This is similar to TypeRef(prefix, sym), except:
      *  (1) the symbol might not yet have a denotation, so the name needs to be given explicitly.
      *  (2) the designator of the TypeRef is either the symbol or its name
      */
-    def withSym(prefix: Type, sym: TypeSymbol, name: TypeName)(implicit ctx: Context): TypeRef =
+    def withSymOLD(prefix: Type, sym: TypeSymbol, name: TypeName)(implicit ctx: Context): TypeRef =
       if ((prefix eq NoPrefix) || sym.isReferencedSymbolically) apply(prefix, sym)
-      else apply(prefix, name.localizeIfPrivate(sym)).withSym(sym)
+      else applyOLD(prefix, name.localizeIfPrivate(sym)).withSym(sym)
 
     def withSym(prefix: Type, sym: TypeSymbol)(implicit ctx: Context): TypeRef =
-      withSym(prefix, sym, sym.name)
+      if (Config.newScheme) apply(prefix, sym) else withSymOLD(prefix, sym, sym.name)
   }
 
   // --- Other SingletonTypes: ThisType/SuperType/ConstantType ---------------------------
@@ -3445,7 +3488,8 @@ object Types {
       if (appliedRefCache == null) {
         val tref =
           if ((cls is PackageClass) || cls.owner.isTerm) symbolicTypeRef // ??? not always symbolicRef
-          else TypeRef(prefix, cls.name, clsDenot)
+          else if (Config.newScheme) TypeRef.withDenot(prefix, clsDenot)
+          else TypeRef.apply(prefix, cls.name, clsDenot)
         appliedRefCache =
           tref.appliedTo(cls.typeParams.map(_.typeRef))
       }
@@ -3527,7 +3571,20 @@ object Types {
       case tp: ClassInfo =>
         // Note: Taking a normal typeRef does not work here. A normal ref might contain
         // also other information about the named type (e.g. bounds).
-        contains(tp.symbolicTypeRef) // ??? not clear
+        if (Config.newScheme) {
+        val loOK =
+          lo.isRef(tp.cls) ||
+          lo.isRef(defn.NothingClass) ||
+          lo.isRef(defn.NullClass) && !tp.cls.isValueClass
+        val hiOK =
+          hi.isRef(tp.cls) ||
+          tp.parents.exists(p => p <:< hi)
+        loOK && hiOK || {
+          println(i"NOT CONTAINS: $this / $tp")
+          false
+        }
+        }
+        else contains(tp.symbolicTypeRef)
       case _ => lo <:< tp && tp <:< hi
     }
 

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -319,7 +319,10 @@ class ClassfileParser(
         case 'L' =>
           def processInner(tp: Type): Type = tp match {
             case tp: TypeRef if !(tp.symbol.owner is Flags.ModuleClass) =>
-              TypeRef.withSym(processInner(tp.prefix.widen), tp.symbol.asType, tp.name)
+              if (config.Config.newScheme)
+                TypeRef.withSym(processInner(tp.prefix.widen), tp.symbol.asType)
+              else
+                TypeRef.withSymOLD(processInner(tp.prefix.widen), tp.symbol.asType, tp.name)
             case _ =>
               tp
           }