Adapt operations in Types

So far, everything up to parents is adapted to new scheme. Parents is half done;
needs more work once we change layour of ClassInfo.

Author: odersky

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

@@ -213,7 +213,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     ta.assignType(untpd.TypeDef(sym.name, TypeTree(sym.info)), sym)
 
   def ClassDef(cls: ClassSymbol, constr: DefDef, body: List[Tree], superArgs: List[Tree] = Nil)(implicit ctx: Context): TypeDef = {
-    val firstParentRef :: otherParentRefs = cls.info.parents
+    val firstParentRef :: otherParentRefs = cls.info.parentRefs
     val firstParent = cls.typeRef.baseTypeWithArgs(firstParentRef.symbol)
     val superRef =
       if (cls is Trait) TypeTree(firstParent)
@@ -261,7 +261,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def AnonClass(parents: List[Type], fns: List[TermSymbol], methNames: List[TermName])(implicit ctx: Context): Block = {
     val owner = fns.head.owner
     val parents1 =
-      if (parents.head.classSymbol.is(Trait)) parents.head.parents.head :: parents
+      if (parents.head.classSymbol.is(Trait)) parents.head.parentRefs.head :: parents
       else parents
     val cls = ctx.newNormalizedClassSymbol(owner, tpnme.ANON_FUN, Synthetic, parents1,
         coord = fns.map(_.pos).reduceLeft(_ union _))

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

@@ -1620,7 +1620,7 @@ object SymDenotations {
               tp
             else subcls.denot match {
               case cdenot: ClassDenotation =>
-                if (cdenot.baseClassSet contains symbol) foldGlb(NoType, tp.parents)
+                if (cdenot.baseClassSet contains symbol) foldGlb(NoType, tp.parentsNEW) // !!! change to parents
                 else NoType
               case _ =>
                 baseTypeOf(tp.superType)

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

@@ -129,9 +129,10 @@ object Types {
           case TypeAlias(tp) =>
             assert((tp ne this) && (tp ne this1), s"$tp / $this")
             tp.isRef(sym)
-          case _ =>  this1.symbol eq sym
+          case _ => this1.symbol eq sym
         }
       case this1: RefinedOrRecType => this1.parent.isRef(sym)
+      case this1: AppliedType => this1.underlying.isRef(sym)
       case this1: HKApply => this1.superType.isRef(sym)
       case _ => false
     }
@@ -210,7 +211,7 @@ object Types {
       */
     private final def phantomLatticeType(implicit ctx: Context): Type = widen match {
       case tp: ClassInfo if defn.isPhantomTerminalClass(tp.classSymbol) => tp.prefix
-      case tp: TypeProxy if tp.superType ne this => tp.underlying.phantomLatticeType
+      case tp: TypeProxy if tp.superType ne this => tp.underlying.phantomLatticeType // ??? guard needed ???
       case tp: AndOrType => tp.tp1.phantomLatticeType
       case _ => NoType
     }
@@ -483,6 +484,8 @@ object Types {
           })
         case tp: TypeRef =>
           tp.denot.findMember(name, pre, excluded)
+        case tp: AppliedType =>
+          goApplied(tp)
         case tp: ThisType =>
           goThis(tp)
         case tp: RefinedType =>
@@ -494,7 +497,7 @@ object Types {
         case tp: SuperType =>
           goSuper(tp)
         case tp: HKApply =>
-          goApply(tp)
+          goHKApply(tp)
         case tp: TypeProxy =>
           go(tp.underlying)
         case tp: ClassInfo =>
@@ -584,7 +587,15 @@ object Types {
         }
       }
 
-      def goApply(tp: HKApply) = tp.tycon match {
+      def goApplied(tp: AppliedType) = tp.tycon match {
+        case tl: HKTypeLambda =>
+          go(tl.resType).mapInfo(info =>
+            tl.derivedLambdaAbstraction(tl.paramNames, tl.paramInfos, info).appliedTo(tp.args))
+        case _ =>
+          go(tp.superType)
+      }
+
+      def goHKApply(tp: HKApply) = tp.tycon match {
         case tl: HKTypeLambda =>
           go(tl.resType).mapInfo(info =>
             tl.derivedLambdaAbstraction(tl.paramNames, tl.paramInfos, info).appliedTo(tp.args))
@@ -963,6 +974,14 @@ object Types {
           case TypeAlias(tp) => tp.dealias(keepAnnots): @tailrec
           case _ => tp
         }
+      case app @ AppliedType(tycon, args) =>
+        val tycon1 = tycon.dealias(keepAnnots)
+        if (tycon1 ne tycon) app.superType.dealias(keepAnnots): @tailrec
+        else this
+      case app @ HKApply(tycon, args) =>
+        val tycon1 = tycon.dealias(keepAnnots)
+        if (tycon1 ne tycon) app.superType.dealias(keepAnnots): @tailrec
+        else this
       case tp: TypeVar =>
         val tp1 = tp.instanceOpt
         if (tp1.exists) tp1.dealias(keepAnnots): @tailrec else tp
@@ -971,10 +990,6 @@ object Types {
         if (keepAnnots) tp.derivedAnnotatedType(tp1, tp.annot) else tp1
       case tp: LazyRef =>
         tp.ref.dealias(keepAnnots): @tailrec
-      case app @ HKApply(tycon, args) =>
-        val tycon1 = tycon.dealias(keepAnnots)
-        if (tycon1 ne tycon) app.superType.dealias(keepAnnots): @tailrec
-        else this
       case _ => this
     }
 
@@ -1021,6 +1036,8 @@ object Types {
         if (tp.symbol.isClass) tp
         else if (tp.symbol.isAliasType) tp.underlying.underlyingClassRef(refinementOK)
         else NoType
+      case tp: AppliedType =>
+        tp.superType.underlyingClassRef(refinementOK)
       case tp: AnnotatedType =>
         tp.underlying.underlyingClassRef(refinementOK)
       case tp: RefinedType =>
@@ -1158,19 +1175,33 @@ object Types {
      *  Inherited by all type proxies. Empty for all other types.
      *  Overwritten in ClassInfo, where parents is cached.
      */
-    def parents(implicit ctx: Context): List[TypeRef] = this match {
-      case tp: TypeProxy => tp.underlying.parents
-      case _ => List()
+    def parentRefs(implicit ctx: Context): List[TypeRef] = this match {
+      case tp: TypeProxy => tp.underlying.parentRefs
+      case _ => Nil
     }
 
     /** The full parent types, including all type arguments */
     def parentsWithArgs(implicit ctx: Context): List[Type] = this match {
       case tp: TypeProxy => tp.superType.parentsWithArgs
-      case _ => List()
+      case _ => Nil
+    }
+
+    /** The full parent types, including (in new scheme) all type arguments */
+    def parentsNEW(implicit ctx: Context): List[Type] = this match {
+      case AppliedType(tycon: HKTypeLambda, args) => // TODO: can be eliminated once ClassInfo is changed, also: cache?
+        tycon.resType.parentsWithArgs.map(_.substParams(tycon, args))
+      case tp: TypeProxy => tp.superType.parentsNEW
+      case _ => Nil
+    }
+
+    /** The first parent of this type, AnyRef if list of parents is empty */
+    def firstParentRef(implicit ctx: Context): TypeRef = parentRefs match {
+      case p :: _ => p
+      case _ => defn.AnyType
     }
 
     /** The first parent of this type, AnyRef if list of parents is empty */
-    def firstParent(implicit ctx: Context): TypeRef = parents match {
+    def firstParentNEW(implicit ctx: Context): Type = parentsNEW match {
       case p :: _ => p
       case _ => defn.AnyType
     }
@@ -3020,21 +3051,17 @@ object Types {
     override def underlying(implicit ctx: Context): Type = tycon
 
     override def superType(implicit ctx: Context): Type = {
-      def reapply(tp: Type) = tp match {
-        case tp: TypeRef if tp.symbol.isClass => tp
-        case _ => tp.applyIfParameterized(args)
-      }
       if (ctx.period != validSuper) {
         validSuper = ctx.period
         cachedSuper = tycon match {
           case tp: HKTypeLambda => defn.AnyType
           case tp: TypeVar if !tp.inst.exists =>
             // supertype not stable, since underlying might change
             validSuper = Nowhere
-            reapply(tp.underlying)
+            tp.underlying.applyIfParameterized(args)
           case tp: TypeProxy =>
             if (tp.typeSymbol.is(Provisional)) validSuper = Nowhere
-            reapply(tp.superType)
+            tp.superType.applyIfParameterized(args)
           case _ => defn.AnyType
         }
       }
@@ -3441,22 +3468,25 @@ object Types {
     private var parentsCache: List[TypeRef] = null
 
     /** The parent type refs as seen from the given prefix */
-    override def parents(implicit ctx: Context): List[TypeRef] = {
+    override def parentRefs(implicit ctx: Context): List[TypeRef] = {
       if (parentsCache == null)
         parentsCache = cls.classParents.mapConserve(_.asSeenFrom(prefix, cls.owner).asInstanceOf[TypeRef])
       parentsCache
     }
 
     /** The parent types with all type arguments */
     override def parentsWithArgs(implicit ctx: Context): List[Type] =
-      parents mapConserve { pref =>
+      parentRefs mapConserve { pref =>
         ((pref: Type) /: pref.classSymbol.typeParams) { (parent, tparam) =>
           val targSym = decls.lookup(tparam.name)
           if (targSym.exists) RefinedType(parent, targSym.name, targSym.info)
           else parent
         }
       }
 
+    override def parentsNEW(implicit ctx: Context): List[Type] =
+      parentRefs // !!! TODO: change
+
     def derivedClassInfo(prefix: Type)(implicit ctx: Context) =
       if (prefix eq this.prefix) this
       else ClassInfo(prefix, cls, classParents, decls, selfInfo)
@@ -3929,12 +3959,12 @@ object Types {
   abstract class DeepTypeMap(implicit ctx: Context) extends TypeMap {
     override def mapClassInfo(tp: ClassInfo) = {
       val prefix1 = this(tp.prefix)
-      val parents1 = (tp.parents mapConserve this).asInstanceOf[List[TypeRef]]
+      val parentRefs1 = (tp.parentRefs mapConserve this).asInstanceOf[List[TypeRef]]
       val selfInfo1 = tp.selfInfo match {
         case selfInfo: Type => this(selfInfo)
         case selfInfo => selfInfo
       }
-      tp.derivedClassInfo(prefix1, parents1, tp.decls, selfInfo1)
+      tp.derivedClassInfo(prefix1, parentRefs1, tp.decls, selfInfo1)
     }
   }
 

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -323,7 +323,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
         val declsText =
           if (trueDecls.isEmpty || !ctx.settings.debug.value) Text()
           else dclsText(trueDecls)
-        tparamsText ~ " extends " ~ toTextParents(tp.parents) ~ "{" ~ selfText ~ declsText ~
+        tparamsText ~ " extends " ~ toTextParents(tp.parentsNEW) ~ "{" ~ selfText ~ declsText ~
           "} at " ~ preText
       case tp =>
         ": " ~ toTextGlobal(tp)
@@ -401,7 +401,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   def toText(sym: Symbol): Text =
     (kindString(sym) ~~ {
-      if (sym.isAnonymousClass) toText(sym.info.parents, " with ") ~ "{...}"
+      if (sym.isAnonymousClass) toText(sym.info.parentsNEW, " with ") ~ "{...}"
       else if (hasMeaninglessName(sym)) simpleNameString(sym.owner) + idString(sym)
       else nameString(sym)
     }).close

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -1258,7 +1258,7 @@ object messages {
     val msg = hl"""|$qual does not name a parent of $cls"""
     val kind = "Reference"
 
-    private val parents: Seq[String] = (cls.info.parents map (_.name.show)).sorted
+    private val parents: Seq[String] = (cls.info.parentRefs map (_.name.show)).sorted
 
     val explanation =
       hl"""|When a qualifier ${"T"} is used in a ${"super"} prefix of the form ${"C.super[T]"},

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

@@ -391,7 +391,7 @@ object Erasure {
             cpy.Super(qual)(thisQual, untpd.Ident(sym.owner.asClass.name))
               .withType(SuperType(thisType, sym.owner.typeRef))
           else
-            qual.withType(SuperType(thisType, thisType.firstParent))
+            qual.withType(SuperType(thisType, thisType.firstParentRef))
         case _ =>
           qual
       }

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

@@ -194,7 +194,7 @@ object ExplicitOuter {
     needsOuterIfReferenced(cls) &&
     (!hasLocalInstantiation(cls) || // needs outer because we might not know whether outer is referenced or not
      cls.mixins.exists(needsOuterIfReferenced) || // needs outer for parent traits
-     cls.classInfo.parents.exists(parent => // needs outer to potentially pass along to parent
+     cls.info.parentsNEW.exists(parent => // needs outer to potentially pass along to parent
        needsOuterIfReferenced(parent.classSymbol.asClass)))
 
   /** Class is always instantiated in the compilation unit where it is defined */

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

@@ -35,7 +35,7 @@ object OverridingPairs {
      *  pair has already been treated in a parent class.
      *  This may be refined in subclasses. @see Bridges for a use case.
      */
-    protected def parents: Array[Symbol] = base.info.parents.toArray map (_.typeSymbol)
+    protected def parents: Array[Symbol] = base.info.parentsNEW.toArray map (_.typeSymbol)
 
     /** Does `sym1` match `sym2` so that it qualifies as overriding.
      *  Types always match. Term symbols match if their membertypes

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

@@ -891,7 +891,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     def isSubTypeOfParent(subtp: Type, tp: Type)(implicit ctx: Context): Boolean =
       if (subtp <:< tp) true
       else tp match {
-        case tp: TypeRef if tp.symbol.isClass => isSubTypeOfParent(subtp, tp.firstParent)
+        case tp: TypeRef if tp.symbol.isClass => isSubTypeOfParent(subtp, tp.firstParentNEW)
         case tp: TypeProxy => isSubTypeOfParent(subtp, tp.superType)
         case _ => false
       }

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

@@ -285,7 +285,7 @@ object RefChecks {
           //Console.println(infoString(member) + " shadows1 " + infoString(other) " in " + clazz);//DEBUG
           return
         }
-        val parentSymbols = clazz.info.parents.map(_.typeSymbol)
+        val parentSymbols = clazz.info.parentsNEW.map(_.typeSymbol)
         if (parentSymbols exists (p => subOther(p) && subMember(p) && deferredCheck)) {
           //Console.println(infoString(member) + " shadows2 " + infoString(other) + " in " + clazz);//DEBUG
           return

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

@@ -293,7 +293,7 @@ trait TypeAssigner {
       case err: ErrorType => untpd.cpy.Super(tree)(qual, mix).withType(err)
       case qtype @ ThisType(_) =>
         val cls = qtype.cls
-        def findMixinSuper(site: Type): Type = site.parents filter (_.name == mix.name) match {
+        def findMixinSuper(site: Type): Type = site.parentRefs filter (_.name == mix.name) match {
           case p :: Nil =>
             p
           case Nil =>
@@ -304,7 +304,7 @@ trait TypeAssigner {
         val owntype =
           if (mixinClass.exists) mixinClass.typeRef
           else if (!mix.isEmpty) findMixinSuper(cls.info)
-          else if (inConstrCall || ctx.erasedTypes) cls.info.firstParent
+          else if (inConstrCall || ctx.erasedTypes) cls.info.firstParentRef
           else {
             val ps = cls.classInfo.parentsWithArgs
             if (ps.isEmpty) defn.AnyType else ps.reduceLeft((x: Type, y: Type) => x & y)