Get rid of parentRefs and associated operations

odersky · odersky · commit e36bc58504e2 · 2017-08-31T17:23:27.000+02:00
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -80,10 +80,9 @@ class Definitions {
         val typeParam = enterSyntheticTypeParam(cls, paramFlags, paramDecls)
         def instantiate(tpe: Type) =
           if (tpe.typeParams.nonEmpty) tpe.appliedTo(typeParam.typeRef)
-          else tpe
-        val parents = parentConstrs.toList map instantiate
-        val parentRefs = ctx.normalizeToClassRefs(parents, cls, paramDecls)
-        denot.info = ClassInfo(ScalaPackageClass.thisType, cls, parentRefs, paramDecls)
+          else tpe.dealias
+        val parents = parentConstrs.toList
+        denot.info = ClassInfo(ScalaPackageClass.thisType, cls, parents, paramDecls)
       }
     }
     newClassSymbol(ScalaPackageClass, name, EmptyFlags, completer).entered
@@ -123,7 +122,7 @@ class Definitions {
           if (name.firstPart.startsWith(str.ImplicitFunction)) {
             val superTrait =
               FunctionType(arity).appliedTo(argParams.map(_.typeRef) ::: resParam.typeRef :: Nil)
-            (ImplicitMethodType, ctx.normalizeToClassRefs(superTrait :: Nil, cls, decls))
+            (ImplicitMethodType, superTrait :: Nil)
           }
           else (MethodType, Nil)
         val applyMeth =
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -1223,7 +1223,7 @@ object SymDenotations {
       info2 match {
         case info2: ClassInfo =>
           info1 match {
-            case info1: ClassInfo => info1.classParentsNEW ne info2.classParentsNEW
+            case info1: ClassInfo => info1.classParents ne info2.classParents
             case _ => completersMatter
           }
         case _ => completersMatter
@@ -1366,25 +1366,19 @@ object SymDenotations {
       super.info_=(tp)
     }
 
-    /** The denotations of all parents in this class. */
-    def classParentRefs(implicit ctx: Context): List[TypeRef] = info match {
-      case classInfo: ClassInfo => classInfo.parentRefs
-      case _ => Nil
-    }
-
-    /** The denotations of all parents in this class. */
+   /** 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 classParentsNEW(implicit ctx: Context): List[Type] = info match {
+    def classParents(implicit ctx: Context): List[Type] = info match {
       case classInfo: ClassInfo => classInfo.parentsNEW
       case _ => Nil
     }
 
     /** The symbol of the superclass, NoSymbol if no superclass exists */
-    def superClass(implicit ctx: Context): Symbol = classParentsNEW match {
+    def superClass(implicit ctx: Context): Symbol = classParents match {
       case parent :: _ =>
         val cls = parent.classSymbol
         if (cls is Trait) NoSymbol else cls
@@ -1457,10 +1451,13 @@ object SymDenotations {
     def computeBaseData(implicit onBehalf: BaseData, ctx: Context): (List[ClassSymbol], BaseClassSet) = {
       def emptyParentsExpected =
         is(Package) || (symbol == defn.AnyClass) || ctx.erasedTypes && (symbol == defn.ObjectClass)
-      if (classParentsNEW.isEmpty && !emptyParentsExpected)
+      if (classParents.isEmpty && !emptyParentsExpected)
         onBehalf.signalProvisional()
       val builder = new BaseDataBuilder
-      for (p <- classParentsNEW) builder.addAll(p.typeSymbol.asClass.baseClasses)
+      for (p <- classParents) {
+        assert(p.typeSymbol.isClass, s"$this has $p")
+        builder.addAll(p.typeSymbol.asClass.baseClasses)
+      }
       (classSymbol :: builder.baseClasses, builder.baseClassSet)
     }
 
@@ -1601,7 +1598,7 @@ object SymDenotations {
           denots
       }
       if (name.isConstructorName) ownDenots
-      else collect(ownDenots, classParentsNEW)
+      else collect(ownDenots, classParents)
     }
 
     override final def findMember(name: Name, pre: Type, excluded: FlagSet)(implicit ctx: Context): Denotation = {
@@ -1659,7 +1656,7 @@ object SymDenotations {
                   case _ => false
                 }
                 if (isOwnThis)
-                  if (clsd.baseClassSet.contains(symbol)) foldGlb(NoType, clsd.classParentsNEW)
+                  if (clsd.baseClassSet.contains(symbol)) foldGlb(NoType, clsd.classParents)
                   else NoType
                 else
                   baseTypeOf(clsd.typeRef).asSeenFrom(prefix, owner)
@@ -1737,7 +1734,7 @@ object SymDenotations {
     def computeMemberNames(keepOnly: NameFilter)(implicit onBehalf: MemberNames, ctx: Context): Set[Name] = {
       var names = Set[Name]()
       def maybeAdd(name: Name) = if (keepOnly(thisType, name)) names += name
-      for (p <- classParentsNEW)
+      for (p <- classParents)
         for (name <- p.typeSymbol.asClass.memberNames(keepOnly))
           maybeAdd(name)
       val ownSyms =
diff --git a/compiler/src/dotty/tools/dotc/core/Symbols.scala b/compiler/src/dotty/tools/dotc/core/Symbols.scala
@@ -123,8 +123,7 @@ trait Symbols { this: Context =>
       def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
         val cls = denot.asClass.classSymbol
         val decls = newScope
-        val parentRefs = normalizeToClassRefs(parentTypes, cls, decls)
-        denot.info = ClassInfo(owner.thisType, cls, parentRefs, decls)
+        denot.info = ClassInfo(owner.thisType, cls, parentTypes.map(_.dealias), decls)
       }
     }
     newClassSymbol(owner, name, flags, completer, privateWithin, coord, assocFile)
diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
@@ -271,54 +271,6 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
     parents.mapConserve(_.dealias) // !@@@ track and eliminate usages?
   }
 
-  /** Forward parameter bindings in baseclasses to argument types of
-   *  class `cls` if possible.
-   *  If there have member definitions
-   *
-   *     type param v= middle
-   *     type middle v= to
-   *
-   *  where the variances of both alias are the same, then enter a new definition
-   *
-   *     type param v= to
-   *
-   *  If multiple forwarders would be generated, join their `to` types with an `&`.
-   *
-   *  @param cls           The class for which parameter bindings should be forwarded
-   *  @param decls	       Its scope
-   *  @param parentRefs    The parent type references of `cls`
-   *  @param paramBindings The type parameter bindings generated for `cls`
-   *
-   */
-  def forwardParamBindings(parentRefs: List[TypeRef],
-                           paramBindings: SimpleMap[TypeName, Type],
-                           cls: ClassSymbol, decls: Scope)(implicit ctx: Context) = {
-
-    def forwardRef(argSym: Symbol, from: TypeName, to: TypeAlias) = argSym.info match {
-      case info @ TypeAlias(TypeRef(_: ThisType, `from`)) if info.variance == to.variance =>
-        val existing = decls.lookup(argSym.name)
-        if (existing.exists) existing.info = existing.info & to
-        else enterArgBinding(argSym, to, cls, decls)
-      case _ =>
-    }
-
-    def forwardRefs(from: TypeName, to: Type) = to match {
-      case to: TypeAlias =>
-        for (pref <- parentRefs) {
-          def forward()(implicit ctx: Context): Unit =
-            for (argSym <- pref.decls)
-              if (argSym is BaseTypeArg) forwardRef(argSym, from, to)
-          pref.info match {
-            case info: TempClassInfo => info.addSuspension(implicit ctx => forward())
-            case _ => forward()
-          }
-        }
-      case _ =>
-    }
-
-    paramBindings.foreachBinding(forwardRefs)
-  }
-
   /** An argument bounds violation is a triple consisting of
    *   - the argument tree
    *   - a string "upper" or "lower" indicating which bound is violated
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -1193,15 +1193,6 @@ object Types {
         NoType
     }
 
-    /** For a ClassInfo type, its parents,
-     *  Inherited by all type proxies. Empty for all other types.
-     *  Overwritten in ClassInfo, where parents is cached.
-     */
-    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
@@ -1224,8 +1215,8 @@ object Types {
     }
 
     /** The first parent of this type, AnyRef if list of parents is empty */
-    def firstParentRef(implicit ctx: Context): TypeRef = parentRefs match {
-      case p :: _ => p
+    def firstParentRef(implicit ctx: Context): TypeRef = parentsNEW match { // @!!! needed?
+      case p :: _ => p.typeConstructor.asInstanceOf[TypeRef]
       case _ => defn.AnyType
     }
 
@@ -3559,7 +3550,7 @@ object Types {
   abstract case class ClassInfo(
       prefix: Type,
       cls: ClassSymbol,
-      classParentsNEW: List[Type],
+      classParents: List[Type],
       decls: Scope,
       selfInfo: DotClass /* should be: Type | Symbol */) extends CachedGroundType with TypeType {
 
@@ -3622,30 +3613,26 @@ object Types {
     // cached because baseType needs parents
     private var parentsCache: List[Type] = null
 
-    /** The parent type refs as seen from the given prefix */
-    override def parentRefs(implicit ctx: Context): List[TypeRef] =
-      parentsNEW.map(_.typeConstructor.asInstanceOf[TypeRef])
-
     /** The parent types with all type arguments */
     override def parentsWithArgs(implicit ctx: Context): List[Type] = parentsNEW
 
     override def parentsNEW(implicit ctx: Context): List[Type] = {
       if (parentsCache == null)
-        parentsCache = classParentsNEW.mapConserve(_.asSeenFrom(prefix, cls.owner))
+        parentsCache = classParents.mapConserve(_.asSeenFrom(prefix, cls.owner))
       parentsCache
     }
 
     def derivedClassInfo(prefix: Type)(implicit ctx: Context) =
       if (prefix eq this.prefix) this
-      else ClassInfo(prefix, cls, classParentsNEW, decls, selfInfo)
+      else ClassInfo(prefix, cls, classParents, decls, selfInfo)
 
-    def derivedClassInfo(prefix: Type = this.prefix, classParentsNEW: List[Type] = this.classParentsNEW, decls: Scope = this.decls, selfInfo: DotClass = this.selfInfo)(implicit ctx: Context) =
-      if ((prefix eq this.prefix) && (classParentsNEW eq this.classParentsNEW) && (decls eq this.decls) && (selfInfo eq this.selfInfo)) this
-      else ClassInfo(prefix, cls, classParentsNEW, decls, selfInfo)
+    def derivedClassInfo(prefix: Type = this.prefix, classParents: List[Type] = this.classParents, decls: Scope = this.decls, selfInfo: DotClass = this.selfInfo)(implicit ctx: Context) =
+      if ((prefix eq this.prefix) && (classParents eq this.classParents) && (decls eq this.decls) && (selfInfo eq this.selfInfo)) this
+      else ClassInfo(prefix, cls, classParents, decls, selfInfo)
 
     override def computeHash = doHash(cls, prefix)
 
-    override def toString = s"ClassInfo($prefix, $cls, $classParentsNEW)"
+    override def toString = s"ClassInfo($prefix, $cls, $classParents)"
   }
 
   class CachedClassInfo(prefix: Type, cls: ClassSymbol, classParents: List[Type], decls: Scope, selfInfo: DotClass)
@@ -3663,9 +3650,9 @@ object Types {
 
     def addSuspension(suspension: Context => Unit): Unit = suspensions ::= suspension
 
-    /** Install classinfo with known parents in `denot` and resume all suspensions */
+    /** Install classinfo with known parents in `denot` and resume all suspensions */ // @!!! elim
     def finalize(denot: SymDenotation, parents: List[Type])(implicit ctx: Context) = {
-      denot.info = derivedClassInfo(classParentsNEW = parents)
+      denot.info = derivedClassInfo(classParents = parents)
       suspensions.foreach(_(ctx))
     }
 
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -731,14 +731,14 @@ class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpi
           case _ => readTpt()
         }
       }
-      val parentRefs = ctx.normalizeToClassRefs(parents.map(_.tpe), cls, cls.unforcedDecls)
+      val parentTypes = parents.map(_.tpe.dealias)
       val self =
         if (nextByte == SELFDEF) {
           readByte()
           untpd.ValDef(readName(), readTpt(), EmptyTree).withType(NoType)
         }
         else EmptyValDef
-      cls.info = ClassInfo(cls.owner.thisType, cls, parentRefs, cls.unforcedDecls,
+      cls.info = ClassInfo(cls.owner.thisType, cls, parentTypes, cls.unforcedDecls,
         if (self.isEmpty) NoType else self.tpt.tpe)
       cls.setNoInitsFlags(fork.indexStats(end))
       val constr = readIndexedDef().asInstanceOf[DefDef]
diff --git a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
@@ -99,8 +99,9 @@ object Scala2Unpickler {
       else selfInfo
     val tempInfo = new TempClassInfo(denot.owner.thisType, denot.classSymbol, decls, ost)
     denot.info = tempInfo // first rough info to avoid CyclicReferences
-    var parentRefs = ctx.normalizeToClassRefs(parents, cls, decls)
-    if (parentRefs.isEmpty) parentRefs = defn.ObjectType :: Nil
+    val normalizedParents =
+    	if (parents.isEmpty) defn.ObjectType :: Nil
+    	else parents.map(_.dealias)
     for (tparam <- tparams) {
       val tsym = decls.lookup(tparam.name)
       if (tsym.exists) tsym.setFlag(TypeParam)
@@ -124,7 +125,7 @@ object Scala2Unpickler {
       registerCompanionPair(scalacCompanion, denot.classSymbol)
     }
 
-    tempInfo.finalize(denot, parentRefs) // install final info, except possibly for typeparams ordering
+    tempInfo.finalize(denot, normalizedParents) // install final info, except possibly for typeparams ordering
     denot.ensureTypeParamsInCorrectOrder()
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala b/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.parentRefs map (_.name.show)).sorted
+    private val parents: Seq[String] = (cls.info.parentsNEW map (_.typeSymbol.name.show)).sorted
 
     val explanation =
       hl"""|When a qualifier ${"T"} is used in a ${"super"} prefix of the form ${"C.super[T]"},
diff --git a/compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala b/compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala
@@ -81,7 +81,7 @@ class CheckReentrant extends MiniPhaseTransform { thisTransformer =>
                 sym.info.widenExpr.classSymbols.foreach(addVars)
               }
             }
-        for (parent <- cls.classInfo.classParentsNEW)
+        for (parent <- cls.classInfo.classParents)
           addVars(parent.typeSymbol.asClass)
       }
     }
diff --git a/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala b/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala
@@ -102,7 +102,7 @@ class ExtensionMethods extends MiniPhaseTransform with DenotTransformer with Ful
           moduleClassSym.copySymDenotation(info =
             cinfo.derivedClassInfo(
               // FIXME: use of VC*Companion superclasses is disabled until the conflicts with SyntheticMethods are solved.
-              //classParents = ctx.normalizeToClassRefs(List(newSuperClass), moduleSym, decls1),
+              //classParents = List(newSuperClass)
               decls = decls1))
         case _ =>
           moduleClassSym
diff --git a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
@@ -251,7 +251,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
 
             // Add Child annotation to sealed parents unless current class is anonymous
             if (!sym.isAnonymousClass) // ignore anonymous class
-              sym.asClass.classParentsNEW.foreach { parent =>
+              sym.asClass.classParents.foreach { parent =>
                 val sym2 = if (sym.is(Module)) sym.sourceModule else sym
                 registerChild(sym2, parent)
               }
diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala
@@ -455,7 +455,7 @@ object Checking {
         case tp: ClassInfo =>
           tp.derivedClassInfo(
             prefix = apply(tp.prefix),
-            classParentsNEW =
+            classParents =
               tp.parentsWithArgs.map { p =>
                 apply(p).stripAnnots match {
                   case ref: RefType => ref
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -436,7 +436,7 @@ trait ImplicitRunInfo { self: RunInfo =>
                 iscopeRefs(tp.baseType(parent.typeSymbol)) foreach addRef
               val companion = cls.companionModule
               if (companion.exists) addRef(companion.valRef)
-              cls.classParentsNEW foreach addParentScope
+              cls.classParents foreach addParentScope
             }
             tp.classSymbols(liftingCtx) foreach addClassScope
           case _ =>
diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -860,7 +860,7 @@ class Namer { typer: Typer =>
        * (4) If the class is sealed, it is defined in the same compilation unit as the current class
        */
       def checkedParentType(parent: untpd.Tree): Type = {
-        val ptype = parentType(parent)(ctx.superCallContext)
+        val ptype = parentType(parent)(ctx.superCallContext).dealias
         if (cls.isRefinementClass) ptype
         else {
           val pt = checkClassType(ptype, parent.pos,
@@ -914,10 +914,9 @@ class Namer { typer: Typer =>
       symbolOfTree(constr).ensureCompleted()
 
       val parentTypes = ensureFirstIsClass(parents.map(checkedParentType(_)), cls.pos)
-      val parentRefs = ctx.normalizeToClassRefs(parentTypes, cls, decls)
-      typr.println(i"completing $denot, parents = $parents%, %, parentTypes = $parentTypes%, %, parentRefs = $parentRefs%, %")
+      typr.println(i"completing $denot, parents = $parents%, %, parentTypes = $parentTypes%, %")
 
-      tempInfo.finalize(denot, parentRefs)
+      tempInfo.finalize(denot, parentTypes)
 
       Checking.checkWellFormed(cls)
       if (isDerivedValueClass(cls)) cls.setFlag(Final)
diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
@@ -102,7 +102,7 @@ object RefChecks {
           ctx.error(DoesNotConformToSelfType(category, cinfo.selfType, cls, otherSelf, relation, other.classSymbol),
             cls.pos)
       }
-      for (parent <- cinfo.classParentsNEW)
+      for (parent <- cinfo.classParents)
         checkSelfConforms(parent.typeSymbol.asClass, "illegal inheritance", "parent")
       for (reqd <- cinfo.cls.givenSelfType.classSymbols)
         checkSelfConforms(reqd, "missing requirement", "required")
diff --git a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -308,9 +308,9 @@ 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.parentRefs filter (_.name == mix.name) match {
+        def findMixinSuper(site: Type): Type = site.parentsNEW filter (_.typeSymbol.name == mix.name) match {
           case p :: Nil =>
-            p
+            p.typeConstructor
           case Nil =>
             errorType(SuperQualMustBeParent(mix, cls), tree.pos)
           case p :: q :: _ =>
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
diff --git a/doc-tool/src/dotty/tools/dottydoc/model/factories.scala b/doc-tool/src/dotty/tools/dottydoc/model/factories.scala

Original file line number	Diff line number	Diff line change
`@@ -123,8 +123,7 @@ trait Symbols { this: Context =>`
`123`	`123`	`def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {`
`124`	`124`	`val cls = denot.asClass.classSymbol`
`125`	`125`	`val decls = newScope`
`126`		`- val parentRefs = normalizeToClassRefs(parentTypes, cls, decls)`
`127`		`- denot.info = ClassInfo(owner.thisType, cls, parentRefs, decls)`
	`126`	`+ denot.info = ClassInfo(owner.thisType, cls, parentTypes.map(_.dealias), decls)`
`128`	`127`	`}`
`129`	`128`	`}`
`130`	`129`	`newClassSymbol(owner, name, flags, completer, privateWithin, coord, assocFile)`
Original file line number	Diff line number	Diff line change
`@@ -731,14 +731,14 @@ class TreeUnpickler(reader: TastyReader, nameAtRef: NameRef => TermName, posUnpi`
`731`	`731`	`case _ => readTpt()`
`732`	`732`	`}`
`733`	`733`	`}`
`734`		`- val parentRefs = ctx.normalizeToClassRefs(parents.map(_.tpe), cls, cls.unforcedDecls)`
	`734`	`+ val parentTypes = parents.map(_.tpe.dealias)`
`735`	`735`	`val self =`
`736`	`736`	`if (nextByte == SELFDEF) {`
`737`	`737`	`readByte()`
`738`	`738`	`untpd.ValDef(readName(), readTpt(), EmptyTree).withType(NoType)`
`739`	`739`	`}`
`740`	`740`	`else EmptyValDef`
`741`		`- cls.info = ClassInfo(cls.owner.thisType, cls, parentRefs, cls.unforcedDecls,`
	`741`	`+ cls.info = ClassInfo(cls.owner.thisType, cls, parentTypes, cls.unforcedDecls,`
`742`	`742`	`if (self.isEmpty) NoType else self.tpt.tpe)`
`743`	`743`	`cls.setNoInitsFlags(fork.indexStats(end))`
`744`	`744`	`val constr = readIndexedDef().asInstanceOf[DefDef]`
Original file line number	Diff line number	Diff line change
`@@ -99,8 +99,9 @@ object Scala2Unpickler {`
`99`	`99`	`else selfInfo`
`100`	`100`	`val tempInfo = new TempClassInfo(denot.owner.thisType, denot.classSymbol, decls, ost)`
`101`	`101`	`denot.info = tempInfo // first rough info to avoid CyclicReferences`
`102`		`- var parentRefs = ctx.normalizeToClassRefs(parents, cls, decls)`
`103`		`- if (parentRefs.isEmpty) parentRefs = defn.ObjectType :: Nil`
	`102`	`+ val normalizedParents =`
	`103`	`+ if (parents.isEmpty) defn.ObjectType :: Nil`
	`104`	`+ else parents.map(_.dealias)`
`104`	`105`	`for (tparam <- tparams) {`
`105`	`106`	`val tsym = decls.lookup(tparam.name)`
`106`	`107`	`if (tsym.exists) tsym.setFlag(TypeParam)`
`@@ -124,7 +125,7 @@ object Scala2Unpickler {`
`124`	`125`	`registerCompanionPair(scalacCompanion, denot.classSymbol)`
`125`	`126`	`}`
`126`	`127`
`127`		`- tempInfo.finalize(denot, parentRefs) // install final info, except possibly for typeparams ordering`
	`128`	`+ tempInfo.finalize(denot, normalizedParents) // install final info, except possibly for typeparams ordering`
`128`	`129`	`denot.ensureTypeParamsInCorrectOrder()`
`129`	`130`	`}`
`130`	`131`	`}`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ class CheckReentrant extends MiniPhaseTransform { thisTransformer =>`
`81`	`81`	`sym.info.widenExpr.classSymbols.foreach(addVars)`
`82`	`82`	`}`
`83`	`83`	`}`
`84`		`- for (parent <- cls.classInfo.classParentsNEW)`
	`84`	`+ for (parent <- cls.classInfo.classParents)`
`85`	`85`	`addVars(parent.typeSymbol.asClass)`
`86`	`86`	`}`
`87`	`87`	`}`