Drop ClassDenotation.appliedRef and ClassInfo.typeRef

 - keep typeRef in ClassDenotaton, since we need it before info is completed
 - keep appliedRef in ClassInfo, since it depends on prefix.

Author: odersky

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

@@ -1412,20 +1412,15 @@ object SymDenotations {
         else ThisType.raw(TypeRef(pre, symbol.asType))
       }
 */
-    private[this] var myAppliedRef: Type = null // @!!!: Use classInfo.appliedRef instead?
-    private[this] var myTypeRef: TypeRef = null // @!!!: Use classInfo.appliedRef instead?
-
-    override def appliedRef(implicit ctx: Context): Type = {
-      if (myAppliedRef == null) myAppliedRef = super.appliedRef
-      if (ctx.erasedTypes) myAppliedRef.typeConstructor
-      else myAppliedRef
-    }
+    private[this] var myTypeRef: TypeRef = null   
 
     override def typeRef(implicit ctx: Context): TypeRef = {
       if (myTypeRef == null) myTypeRef = super.typeRef
       myTypeRef
     }
 
+    override def appliedRef(implicit ctx: Context): Type = classInfo.appliedRef
+
     private def baseData(implicit onBehalf: BaseData, ctx: Context): (List[ClassSymbol], BaseClassSet) = {
       if (!baseDataCache.isValid) baseDataCache = BaseData.newCache()
       baseDataCache(this)

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

@@ -470,10 +470,8 @@ object Types {
     final def memberExcluding(name: Name, excluding: FlagSet)(implicit ctx: Context): Denotation = {
       // We need a valid prefix for `asSeenFrom`
       val pre = this match {
-        case tp: ClassInfo =>
-          tp.typeRef // @!!! appliedRef
-        case _ =>
-          widenIfUnstable
+        case tp: ClassInfo => tp.appliedRef
+        case _ => widenIfUnstable
       }
       findMember(name, pre, excluding)
     }
@@ -3432,48 +3430,25 @@ object Types {
       decls: Scope,
       selfInfo: DotClass /* should be: Type | Symbol */) extends CachedGroundType with TypeType {
 
+    private var selfTypeCache: Type = null
+    private var appliedRefCache: Type = null
+
     /** The self type of a class is the conjunction of
      *   - the explicit self type if given (or the info of a given self symbol), and
      *   - the fully applied reference to the class itself.
      */
     def selfType(implicit ctx: Context): Type = {
       if (selfTypeCache == null)
         selfTypeCache = {
-          def fullRef = fullyAppliedRef
           val given = cls.givenSelfType
-          val raw =
-            if (!given.exists) fullRef
-            else if (cls is Module) given
-            else if (ctx.erasedTypes) fullRef
-            else AndType(given, fullRef)
-          raw//.asSeenFrom(prefix, cls.owner)
+          if (!given.exists) appliedRef
+          else if (cls is Module) given
+          else if (ctx.erasedTypes) appliedRef
+          else AndType(given, appliedRef)
         }
       selfTypeCache
     }
 
-    private var selfTypeCache: Type = null
-
-    //private def fullyAppliedRef(base: Type, tparams: List[TypeSymbol])(implicit ctx: Context): Type =
-    //  base.appliedTo(tparams.map(_.typeRef))
-
-    /** The class type with all type parameters */
-    def fullyAppliedRef(implicit ctx: Context): Type = // @!!! eliminate
-      //if (true)
-        cls.appliedRef
-      //else fullyAppliedRef(cls.typeRef, cls.typeParams)
-
-    private var appliedRefCache: Type = null
-    private var typeRefCache: TypeRef = null
-
-    def typeRef(implicit ctx: Context): TypeRef = {
-      def clsDenot = if (prefix eq cls.owner.thisType) cls.denot else cls.denot.copySymDenotation(info = this)
-      if (typeRefCache == null)
-        typeRefCache =
-          if ((cls is PackageClass) || cls.owner.isTerm) symbolicTypeRef
-          else TypeRef(prefix, cls.name, clsDenot)
-      typeRefCache
-    }
-
     def appliedRef(implicit ctx: Context): Type = {
       def clsDenot = if (prefix eq cls.owner.thisType) cls.denot else cls.denot.copySymDenotation(info = this)
       if (appliedRefCache == null) {

compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -234,7 +234,7 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
   }
 
   def linearizedAncestorTypes(info: ClassInfo): List[Type] = {
-    val ref = info.fullyAppliedRef
+    val ref = info.appliedRef
     // Note that the ordering of classes in `baseClasses` is important.
     info.baseClasses.tail.map(ref.baseType)
   }