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 =>

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

@@ -1273,7 +1273,7 @@ object messages {
     val msg = hl"""|$qual does not name a parent of $cls"""
     val kind = "Reference"
 
-    private val parents: Seq[String] = (cls.info.parentsNEW map (_.typeSymbol.name.show)).sorted
+    private val parents: Seq[String] = (cls.info.parents map (_.typeSymbol.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/sbt/ExtractAPI.scala

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

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

@@ -24,7 +24,7 @@ class CrossCastAnd extends MiniPhaseTransform { thisTransform =>
     lazy val qtype = tree.qualifier.tpe.widen
     val sym = tree.symbol
     if (sym.is(Flags.Private) && qtype.typeSymbol != sym.owner)
-      cpy.Select(tree)(tree.qualifier.asInstance(AndType(qtype.baseTypeWithArgs(sym.owner), tree.qualifier.tpe)), tree.name)
+      cpy.Select(tree)(tree.qualifier.asInstance(AndType(qtype.baseType(sym.owner), tree.qualifier.tpe)), tree.name)
     else tree
   }
 }

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

@@ -409,7 +409,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.firstParentRef))
+            qual.withType(SuperType(thisType, thisType.firstParent.typeConstructor))
         case _ =>
           qual
       }

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

@@ -213,7 +213,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.info.parentsNEW.exists(parent => // needs outer to potentially pass along to parent
+     cls.info.parents.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/FullParameterization.scala

@@ -163,7 +163,7 @@ trait FullParameterization {
         def rewireCall(thisArg: Tree): Tree = {
           val rewired = rewiredTarget(tree, derived)
           if (rewired.exists) {
-            val base = thisArg.tpe.baseTypeWithArgs(origClass)
+            val base = thisArg.tpe.baseType(origClass)
             assert(base.exists)
             ref(rewired.termRef)
               .appliedToTypeTrees(targs ++ base.argInfos.map(TypeTree(_)))

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.parentsNEW.toArray map (_.typeSymbol)
+    protected def parents: Array[Symbol] = base.info.parents.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/transform/PatternMatcherOld.scala

@@ -1359,7 +1359,7 @@ class PatternMatcherOld extends MiniPhaseTransform with DenotTransformer {
       // don't go looking for selectors if we only expect one pattern
       def rawSubPatTypes = aligner.extractedTypes
 
-      def typeArgOfBaseTypeOr(tp: Type, baseClass: Symbol)(or: => Type): Type = (tp.baseTypeWithArgs(baseClass)).argInfos match {
+      def typeArgOfBaseTypeOr(tp: Type, baseClass: Symbol)(or: => Type): Type = (tp.baseType(baseClass)).argInfos match {
         case x :: Nil => x
         case _        => or
       }

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

@@ -254,7 +254,7 @@ class TailRec extends MiniPhaseTransform with DenotTransformer with FullParamete
 
               val callTargs: List[tpd.Tree] =
                 if (abstractOverClass) {
-                  val classTypeArgs = recv.tpe.baseTypeWithArgs(enclosingClass).argInfos
+                  val classTypeArgs = recv.tpe.baseType(enclosingClass).argInfos
                   targs ::: classTypeArgs.map(x => ref(x.typeSymbol))
                 } else targs
 

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

@@ -915,7 +915,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.firstParentNEW)
+        case tp: TypeRef if tp.symbol.isClass => isSubTypeOfParent(subtp, tp.firstParent)
         case tp: TypeProxy => isSubTypeOfParent(subtp, tp.superType)
         case _ => false
       }

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

@@ -456,7 +456,7 @@ object Checking {
           tp.derivedClassInfo(
             prefix = apply(tp.prefix),
             classParents =
-              tp.parentsWithArgs.map { p =>
+              tp.parents.map { p =>
                 apply(p).stripAnnots match {
                   case ref: RefType => ref
                   case _ => defn.ObjectType // can happen if class files are missing

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

@@ -287,7 +287,7 @@ object RefChecks {
           //Console.println(infoString(member) + " shadows1 " + infoString(other) " in " + clazz);//DEBUG
           return
         }
-        val parentSymbols = clazz.info.parentsNEW.map(_.typeSymbol)
+        val parentSymbols = clazz.info.parents.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

@@ -47,7 +47,7 @@ trait TypeAssigner {
    */
   def classBound(info: ClassInfo)(implicit ctx: Context): Type = {
     val cls = info.cls
-    val parentType = info.parentsWithArgs.reduceLeft(ctx.typeComparer.andType(_, _))
+    val parentType = info.parents.reduceLeft(ctx.typeComparer.andType(_, _))
 
     def addRefinement(parent: Type, decl: Symbol) = {
       val inherited =
@@ -308,7 +308,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.parentsNEW filter (_.typeSymbol.name == mix.name) match {
+        def findMixinSuper(site: Type): Type = site.parents filter (_.typeSymbol.name == mix.name) match {
           case p :: Nil =>
             p.typeConstructor
           case Nil =>
@@ -319,9 +319,9 @@ trait TypeAssigner {
         val owntype =
           if (mixinClass.exists) mixinClass.appliedRef
           else if (!mix.isEmpty) findMixinSuper(cls.info)
-          else if (inConstrCall || ctx.erasedTypes) cls.info.firstParentRef
+          else if (inConstrCall || ctx.erasedTypes) cls.info.firstParent.typeConstructor
           else {
-            val ps = cls.classInfo.parentsWithArgs
+            val ps = cls.classInfo.parents
             if (ps.isEmpty) defn.AnyType else ps.reduceLeft((x: Type, y: Type) => x & y)
           }
         tree.withType(SuperType(cls.thisType, owntype))

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

@@ -1468,9 +1468,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       case p :: _ if p.classSymbol.isRealClass => parents
       case _ =>
         val pcls = (defn.ObjectClass /: parents)(improve)
-        typr.println(i"ensure first is class $parents%, % --> ${parents map (_ baseTypeWithArgs pcls)}%, %")
-        val first = ctx.typeComparer.glb(
-            defn.ObjectType :: (parents map (_ baseTypeWithArgs pcls)))
+        typr.println(i"ensure first is class $parents%, % --> ${parents map (_ baseType pcls)}%, %")
+        val first = ctx.typeComparer.glb(defn.ObjectType :: parents.map(_.baseType(pcls)))
         checkFeasibleParent(first, pos, em" in inferred superclass $first") :: parents
     }
   }