Re-normalize parents methods

 - get rid of withArgs variants
 - drop the NEW

Author: odersky

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

@@ -889,7 +889,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
           // to inner symbols of DefDef
           // todo: somehow handle.
 
-    def parents: List[Type] = tp.parentsNEW
+    def parents: List[Type] = tp.parents
   }
 
 

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 firstParent :: otherParents = cls.info.parentsNEW
+    val firstParent :: otherParents = cls.info.parents
     val superRef =
       if (cls is Trait) TypeTree(firstParent)
       else {
@@ -260,7 +260,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.parentsNEW.head :: parents
+      if (parents.head.classSymbol.is(Trait)) parents.head.parents.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/config/Config.scala

@@ -84,13 +84,6 @@ object Config {
   /** If this flag is set, take the fast path when comparing same-named type-aliases and types */
   final val fastPathForRefinedSubtype = true
 
-  /** If this flag is set, `TypeOps.normalizeToClassRefs` will insert forwarders
-   *  for type parameters of base classes. This is an optimization, which avoids
-   *  long alias chains. We should  not rely on the optimization, though. So changing
-   *  the flag to false can be used for checking that everything works OK without it.
-   */
-  final val forwardTypeParams = true
-
   /** If this flag is set, and we compute `T1 { X = S1 }` & `T2 { X = S2 }` as a new
    *  upper bound of a constrained parameter, try to align the refinements by computing
    *  `S1 =:= S2` (which might instantiate type parameters).

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

@@ -1366,14 +1366,8 @@ object SymDenotations {
       super.info_=(tp)
     }
 
-   /** The denotations of all parents in this class. */
-    def classParentsWithArgs(implicit ctx: Context): List[Type] = info match {
-      case classInfo: ClassInfo => classInfo.parentsWithArgs
-      case _ => Nil
-    }
-
     def classParents(implicit ctx: Context): List[Type] = info match {
-      case classInfo: ClassInfo => classInfo.parentsNEW
+      case classInfo: ClassInfo => classInfo.parents
       case _ => Nil
     }
 

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

@@ -491,14 +491,6 @@ class TypeApplications(val self: Type) extends AnyVal {
   final def baseArgInfos(base: Symbol)(implicit ctx: Context): List[Type] = // @!!! drop
     self.baseType(base).argInfos
 
-  /** The base type including all type arguments and applicable refinements
-   *  of this type. Refinements are applicable if they refine a member of
-   *  the parent type which furthermore is not a name-mangled type parameter.
-   *  Existential types in arguments are returned as TypeBounds instances.
-   */
-  final def baseTypeWithArgs(base: Symbol)(implicit ctx: Context): Type = // @!!! drop
-    self.baseType(base)
-
   /** Translate a type of the form From[T] to To[T], keep other types as they are.
    *  `from` and `to` must be static classes, both with one type parameter, and the same variance.
    *  Do the same for by name types => From[T] and => To[T]

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

@@ -208,12 +208,8 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
             case _ =>
               val commonBaseClasses = tp.mapReduceOr(_.baseClasses)(intersect)
               val doms = dominators(commonBaseClasses, Nil)
-              def baseTp(cls: ClassSymbol): Type = {
-                val base =
-                  if (tp1.typeParams.nonEmpty) tp.baseTypeTycon(cls)
-                  else tp.baseTypeWithArgs(cls)
-                base.mapReduceOr(identity)(mergeRefinedOrApplied)
-              }
+              def baseTp(cls: ClassSymbol): Type =
+                tp.baseType(cls).mapReduceOr(identity)(mergeRefinedOrApplied)
               doms.map(baseTp).reduceLeft(AndType.apply)
           }
       }
@@ -264,13 +260,6 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
     cls.enter(sym, decls)
   }
 
-  /** Normalize a list of parent types of class `cls` to make sure they are
-   *  all (possibly applied) references to classes.
-   */
-  def normalizeToClassRefs(parents: List[Type], cls: ClassSymbol, decls: Scope): List[Type] = {
-    parents.mapConserve(_.dealias) // !@@@ track and eliminate usages?
-  }
-
   /** An argument bounds violation is a triple consisting of
    *   - the argument tree
    *   - a string "upper" or "lower" indicating which bound is violated

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

@@ -856,7 +856,7 @@ object Types {
     }
 
     /** Temporary replacement for baseTypeRef */
-    final def baseTypeTycon(base: Symbol)(implicit ctx: Context): Type =
+    final def baseTypeTycon(base: Symbol)(implicit ctx: Context): Type = // @!!! drop
       baseType(base).typeConstructor
 
     def & (that: Type)(implicit ctx: Context): Type = track("&") {
@@ -1194,34 +1194,22 @@ object Types {
     }
 
     /** The full parent types, including all type arguments */
-    def parentsWithArgs(implicit ctx: Context): List[Type] = this match {
-      case tp: TypeProxy => tp.superType.parentsWithArgs
-      case _ => Nil
-    }
-
-    /** The full parent types, including (in new scheme) all type arguments */
-    def parentsNEW(implicit ctx: Context): List[Type] = this match {
+    def parents(implicit ctx: Context): List[Type] = this match {
       case tp @ AppliedType(tycon, args) if tycon.typeSymbol.isClass =>
-        tycon.parentsNEW.map(_.subst(tycon.typeSymbol.typeParams, args))
+        tycon.parents.map(_.subst(tycon.typeSymbol.typeParams, args)) // !@@@ cache?
       case tp: TypeRef =>
         if (tp.info.isInstanceOf[TempClassInfo]) {
           tp.reloadDenot()
           assert(!tp.info.isInstanceOf[TempClassInfo])
         }
-        tp.info.parentsNEW
+        tp.info.parents
       case tp: TypeProxy =>
-        tp.superType.parentsNEW
+        tp.superType.parents
       case _ => Nil
     }
 
     /** The first parent of this type, AnyRef if list of parents is empty */
-    def firstParentRef(implicit ctx: Context): TypeRef = parentsNEW match { // @!!! needed?
-      case p :: _ => p.typeConstructor.asInstanceOf[TypeRef]
-      case _ => defn.AnyType
-    }
-
-    /** The first parent of this type, AnyRef if list of parents is empty */
-    def firstParentNEW(implicit ctx: Context): Type = parentsNEW match {
+    def firstParent(implicit ctx: Context): Type = parents match {
       case p :: _ => p
       case _ => defn.AnyType
     }
@@ -3613,10 +3601,7 @@ object Types {
     // cached because baseType needs parents
     private var parentsCache: List[Type] = null
 
-    /** The parent types with all type arguments */
-    override def parentsWithArgs(implicit ctx: Context): List[Type] = parentsNEW
-
-    override def parentsNEW(implicit ctx: Context): List[Type] = {
+    override def parents(implicit ctx: Context): List[Type] = {
       if (parentsCache == null)
         parentsCache = classParents.mapConserve(_.asSeenFrom(prefix, cls.owner))
       parentsCache
@@ -4136,7 +4121,7 @@ object Types {
   abstract class DeepTypeMap(implicit ctx: Context) extends TypeMap {
     override def mapClassInfo(tp: ClassInfo) = {
       val prefix1 = this(tp.prefix)
-      val parents1 = tp.parentsNEW mapConserve this
+      val parents1 = tp.parents mapConserve this
       val selfInfo1 = tp.selfInfo match {
         case selfInfo: Type => this(selfInfo)
         case selfInfo => selfInfo

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

@@ -733,7 +733,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
             if (sym.owner != thispre.cls) {
               val overriding = thispre.cls.info.decls.lookup(sym.name)
               if (overriding.exists && overriding != sym) {
-                val base = pre.baseTypeWithArgs(sym.owner)
+                val base = pre.baseType(sym.owner)
                 assert(base.exists)
                 pre = SuperType(thispre, base)
               }

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

@@ -322,7 +322,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
           if (tp.variance == 1) " =+ "
           else if (tp.variance == -1) " =- "
           else " = "
-        eql ~ toText(tp.alias)      	
+        eql ~ toText(tp.alias)
       case tp @ TypeBounds(lo, hi) =>
         (if (lo isRef defn.NothingClass) Text() else " >: " ~ toText(lo)) ~
           (if (hi isRef defn.AnyClass) Text() else " <: " ~ toText(hi))
@@ -340,7 +340,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
         val declsText =
           if (trueDecls.isEmpty || !ctx.settings.debug.value) Text()
           else dclsText(trueDecls)
-        tparamsText ~ " extends " ~ toTextParents(tp.parentsNEW) ~ "{" ~ selfText ~ declsText ~
+        tparamsText ~ " extends " ~ toTextParents(tp.parents) ~ "{" ~ selfText ~ declsText ~
           "} at " ~ preText
       case tp =>
         ": " ~ toTextGlobal(tp)
@@ -418,7 +418,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   def toText(sym: Symbol): Text =
     (kindString(sym) ~~ {
-      if (sym.isAnonymousClass) toText(sym.info.parentsNEW, " with ") ~ "{...}"
+      if (sym.isAnonymousClass) toText(sym.info.parents, " with ") ~ "{...}"
       else if (hasMeaninglessName(sym)) simpleNameString(sym.owner) + idString(sym)
       else nameString(sym)
     }).close

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

@@ -164,7 +164,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case ErasedValueType(tycon, underlying) =>
         return "ErasedValueType(" ~ toText(tycon) ~ ", " ~ toText(underlying) ~ ")"
       case tp: ClassInfo =>
-        return toTextParents(tp.parentsWithArgs) ~ "{...}"
+        return toTextParents(tp.parents) ~ "{...}"
       case JavaArrayType(elemtp) =>
         return toText(elemtp) ~ "[]"
       case tp: AnnotatedType if homogenizedView =>