Make desigantors of WithFixedSym classes symbols

Thsi will be cleaned up further in next commit.

Author: odersky

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -431,11 +431,11 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     var found = desugared.get(i.tpe)
     if (found == null) {
       i.tpe match {
-        case TermRef(prefix: TermRef, name) =>
+        case TermRef(prefix: TermRef, _) =>
           found = tpd.ref(prefix).select(i.symbol)
-        case TermRef(prefix: ThisType, name) =>
+        case TermRef(prefix: ThisType, _) =>
           found = tpd.This(prefix.cls).select(i.symbol)
-        case TermRef(NoPrefix, name) =>
+        case TermRef(NoPrefix, _) =>
           if (i.symbol is Flags.Method) found = This(i.symbol.topLevelClass).select(i.symbol) // workaround #342 todo: remove after fixed
         case _ =>
       }

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

@@ -164,9 +164,9 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
                 ctx.typeComparer.lubArgs(args1, args2, tycon1.typeParams))
             case _ => fail
           }
-        case tp1 @ TypeRef(pre1, name1) =>
+        case tp1 @ TypeRef(pre1, _) =>
           tp2 match {
-            case tp2 @ TypeRef(pre2, `name1`) =>
+            case tp2 @ TypeRef(pre2, _) if tp1.name eq tp2.name =>
               tp1.derivedSelect(pre1 | pre2)
             case _ => fail
           }

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

@@ -1746,12 +1746,11 @@ object Types {
     def reloadDenot()(implicit ctx: Context) = setDenot(loadDenot)
 
     protected def asMemberOf(prefix: Type, allowPrivate: Boolean)(implicit ctx: Context): Denotation = {
-      def recur(desig: Name): Denotation =
-        if (desig.is(SignedName)) recur(name)
-        else if (desig.is(ShadowedName)) prefix.nonPrivateMember(desig.exclude(ShadowedName))
-        else if (!allowPrivate) prefix.nonPrivateMember(desig)
-        else prefix.member(desig)
-      recur(designatorName)
+      def recur(name: Name): Denotation =
+        if (name.is(ShadowedName)) prefix.nonPrivateMember(name.exclude(ShadowedName))
+        else if (!allowPrivate) prefix.nonPrivateMember(name)
+        else prefix.member(name)
+      recur(name)
     }
 
     /** (1) Reduce a type-ref `W # X` or `W { ... } # U`, where `W` is a wildcard type
@@ -2006,7 +2005,8 @@ object Types {
 
 
   trait WithFixedSym extends NamedType {
-    def fixedSym: Symbol
+    def fixedSym: Symbol = designator.asInstanceOf[Symbol]
+    assert(fixedSym ne null)
     assert(fixedSym ne NoSymbol)
     uncheckedSetSym(fixedSym)
 
@@ -2027,6 +2027,13 @@ object Types {
       case _ => false
     }
     override def computeHash = unsupported("computeHash")
+
+    def checkInst(n: Name, sym: Symbol)(implicit ctx: Context): this.type = {
+      //assert(name == n, i"bad name: ${name.debugString}, expected: ${n.debugString}, ${System.identityHashCode(name)}, ${System.identityHashCode(n)}")
+      //assert(fixedSym eq sym)
+      //assert(symbol eq sym)
+      this
+    }
   }
 
   final class CachedTermRef(prefix: Type, designator: TermDesignator, hc: Int) extends TermRef(prefix, designator) {
@@ -2042,10 +2049,10 @@ object Types {
   }
 
   // Those classes are non final as Linker extends them.
-  class TermRefWithFixedSym(prefix: Type, designator: TermName, val fixedSym: TermSymbol, hc: Int) extends TermRef(prefix, designator) with WithFixedSym {
+  class TermRefWithFixedSym(prefix: Type, d: Name, designator: TermSymbol, hc: Int) extends TermRef(prefix, designator) with WithFixedSym {
     myHash = hc
   }
-  class TypeRefWithFixedSym(prefix: Type, designator: TypeName, val fixedSym: TypeSymbol, hc: Int) extends TypeRef(prefix, designator) with WithFixedSym {
+  class TypeRefWithFixedSym(prefix: Type, d: Name, designator: TypeSymbol, hc: Int) extends TypeRef(prefix, designator) with WithFixedSym {
     myHash = hc
   }
 
@@ -2103,7 +2110,7 @@ object Types {
      *  with given prefix, name, and signature
      */
     def withFixedSym(prefix: Type, name: TermName, sym: TermSymbol)(implicit ctx: Context): TermRef =
-      ctx.uniqueWithFixedSyms.enterIfNew(prefix, name, sym).asInstanceOf[TermRef]
+      ctx.uniqueWithFixedSyms.enterIfNew(prefix, name, sym).asInstanceOf[TermRefWithFixedSym].checkInst(name, sym)
 
     /** Create a term ref referring to given symbol with given name, taking the signature
      *  from the symbol if it is completed, or creating a term ref without
@@ -2157,7 +2164,7 @@ object Types {
      *  with given prefix, name, and symbol.
      */
     def withFixedSym(prefix: Type, name: TypeName, sym: TypeSymbol)(implicit ctx: Context): TypeRef =
-      ctx.uniqueWithFixedSyms.enterIfNew(prefix, name, sym).asInstanceOf[TypeRef]
+      ctx.uniqueWithFixedSyms.enterIfNew(prefix, name, sym).asInstanceOf[TypeRefWithFixedSym].checkInst(name, sym)
 
     /** Create a type ref referring to given symbol with given name.
      *  This is very similar to TypeRef(Type, Symbol),
@@ -2374,7 +2381,7 @@ object Types {
           normalize(tp.parent.substRecThis(tp, rt.recThis))
         case tp @ RefinedType(parent, rname, rinfo) =>
           val rinfo1 = rinfo match {
-            case TypeAlias(TypeRef(RecThis(`rt`), `rname`)) => TypeBounds.empty
+            case TypeAlias(ref @ TypeRef(RecThis(`rt`), _)) if ref.name == rname => TypeBounds.empty
             case _ => rinfo
           }
           tp.derivedRefinedType(normalize(parent), rname, rinfo1)
@@ -2682,7 +2689,7 @@ object Types {
       if (dependencyStatus == FalseDeps) { // dealias all false dependencies
         val dealiasMap = new TypeMap {
           def apply(tp: Type) = tp match {
-            case tp @ TypeRef(pre, name) =>
+            case tp @ TypeRef(pre, _) =>
               tp.info match {
                 case TypeAlias(alias) if depStatus(NoDeps, pre) == TrueDeps => apply(alias)
                 case _ => mapOver(tp)
@@ -4432,7 +4439,7 @@ object Types {
   ) map (_.toTypeName)
 
   def isWatched(tp: Type) = tp match {
-    case TypeRef(_, name) => watchList contains name
+    case ref: TypeRef => watchList contains ref.name
     case _ => false
   }
 

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -630,7 +630,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
     // unless names match up.
     val isBound = (tp: Type) => {
       def refersTo(tp: Type, sym: Symbol): Boolean = tp match {
-        case tp @ TypeRef(_, name) => sym.name == name && sym == tp.symbol
+        case tp: TypeRef => sym.name == tp.name && sym == tp.symbol
         case tp: TypeVar => refersTo(tp.underlying, sym)
         case tp : LazyRef => refersTo(tp.ref, sym)
         case _ => false

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

@@ -757,7 +757,7 @@ object PatternMatcher {
             // See the test for SI-7214 for motivation for dealias. Later `treeCondStrategy#outerTest`
             // generates an outer test based on `patType.prefix` with automatically dealises.
             expectedTp.dealias match {
-              case tref @ TypeRef(pre: SingletonType, name) =>
+              case tref @ TypeRef(pre: SingletonType, _) =>
                 tref.symbol.isClass &&
                 ExplicitOuter.needsOuterIfReferenced(tref.symbol.asClass)
               case _ =>

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

@@ -799,7 +799,7 @@ class PatternMatcherOld extends MiniPhaseTransform with DenotTransformer {
         // See the test for SI-7214 for motivation for dealias. Later `treeCondStrategy#outerTest`
         // generates an outer test based on `patType.prefix` with automatically dealises.
         expectedTp.dealias match {
-          case tref @ TypeRef(pre: SingletonType, name) =>
+          case tref @ TypeRef(pre: SingletonType, _) =>
             val s = tref
             s.symbol.isClass &&
             ExplicitOuter.needsOuterIfReferenced(s.symbol.asClass)

compiler/src/dotty/tools/dotc/transform/localopt/Simplify.scala

@@ -148,9 +148,9 @@ object Simplify {
   // TODO: This function is duplicated in jvm/DottyBackendInterface.scala, let's factor these out!
   def desugarIdent(i: Ident)(implicit ctx: Context): Option[Select] = {
     i.tpe match {
-      case TermRef(prefix: TermRef, name) =>
+      case TermRef(prefix: TermRef, _) =>
         Some(ref(prefix).select(i.symbol))
-      case TermRef(prefix: ThisType, name) =>
+      case TermRef(prefix: ThisType, _) =>
         Some(This(prefix.cls).select(i.symbol))
       case _ => None
     }

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

@@ -219,7 +219,7 @@ object Checking {
         tp.derivedRefinedType(this(parent), name, this(rinfo, nestedCycleOK, nestedCycleOK))
       case tp: RecType =>
         tp.rebind(this(tp.parent))
-      case tp @ TypeRef(pre, name) =>
+      case tp @ TypeRef(pre, _) =>
         try {
           // A prefix is interesting if it might contain (transitively) a reference
           // to symbol `sym` itself. We only check references with interesting

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

@@ -924,9 +924,9 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val indexPattern = new TreeMap {
       val elimWildcardSym = new TypeMap {
         def apply(t: Type) = t match {
-          case ref @ TypeRef(_, tpnme.WILDCARD) if ctx.gadt.bounds.contains(ref.symbol) =>
+          case ref: TypeRef if ref.name == tpnme.WILDCARD && ctx.gadt.bounds.contains(ref.symbol) =>
             ctx.gadt.bounds(ref.symbol)
-          case TypeAlias(ref @ TypeRef(_, tpnme.WILDCARD)) if ctx.gadt.bounds.contains(ref.symbol) =>
+          case TypeAlias(ref: TypeRef) if ref.name == tpnme.WILDCARD && ctx.gadt.bounds.contains(ref.symbol) =>
             ctx.gadt.bounds(ref.symbol)
           case _ =>
             mapOver(t)