Refactorings of GenericTypes and underlying/upperbound

1. Make genericType a trait instead of a class.
2. Make TypeLambda a type proxy
3. Split underlying in TypeProxy into underlying and superType
4. Cleanups in many other places

Author: odersky

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

@@ -1661,12 +1661,10 @@ object SymDenotations {
                 if (cdenot.superClassBits contains symbol.superId) foldGlb(NoType, tp.parents)
                 else NoType
               case _ =>
-                baseTypeRefOf(tp.underlying)
+                baseTypeRefOf(tp.superType)
             }
-          case tp: HKApply =>
-            baseTypeRefOf(tp.upperBound) // TODO drop?
           case tp: TypeProxy =>
-            baseTypeRefOf(tp.underlying)
+            baseTypeRefOf(tp.superType)
           case AndType(tp1, tp2) =>
             baseTypeRefOf(tp1) & baseTypeRefOf(tp2)
           case OrType(tp1, tp2) =>

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

@@ -275,7 +275,7 @@ class TypeApplications(val self: Type) extends AnyVal {
         if (params.exists(_.name == self.refinedName)) parent1
         else self.derivedRefinedType(parent1, self.refinedName, self.refinedInfo)
       case self: TypeProxy =>
-        self.underlying.widenToNamedTypeParams(params)
+        self.superType.widenToNamedTypeParams(params)
       case self: AndOrType =>
         self.derivedAndOrType(
           self.tp1.widenToNamedTypeParams(params), self.tp2.widenToNamedTypeParams(params))
@@ -317,7 +317,6 @@ class TypeApplications(val self: Type) extends AnyVal {
     case self: SingletonType => -1
     case self: TypeVar => self.origin.knownHK
     case self: WildcardType => self.optBounds.knownHK
-    case self: PolyParam => self.underlying.knownHK
     case self: TypeProxy => self.underlying.knownHK
     case NoType | _: LazyType => 0
     case _ => -1
@@ -568,7 +567,7 @@ class TypeApplications(val self: Type) extends AnyVal {
   final def baseArgInfos(base: Symbol)(implicit ctx: Context): List[Type] =
     if (self derivesFrom base)
       self match {
-        case self: HKApply => self.upperBound.baseArgInfos(base)
+        case self: HKApply => self.superType.baseArgInfos(base)
         case _ => base.typeParams.map(param => self.member(param.name).info.argInfo)
       }
     else
@@ -596,7 +595,7 @@ class TypeApplications(val self: Type) extends AnyVal {
   final def firstBaseArgInfo(base: Symbol)(implicit ctx: Context): Type = base.typeParams match {
     case param :: _ if self derivesFrom base =>
       self match {
-        case self: HKApply => self.upperBound.firstBaseArgInfo(base)
+        case self: HKApply => self.superType.firstBaseArgInfo(base)
         case _ => self.member(param.name).info.argInfo
       }
     case _ =>
@@ -621,7 +620,7 @@ class TypeApplications(val self: Type) extends AnyVal {
       case tp: TermRef =>
         tp.underlying.baseTypeWithArgs(base)
       case tp: HKApply =>
-        tp.upperBound.baseTypeWithArgs(base)
+        tp.superType.baseTypeWithArgs(base)
       case AndType(tp1, tp2) =>
         tp1.baseTypeWithArgs(base) & tp2.baseTypeWithArgs(base)
       case OrType(tp1, tp2) =>

src/dotty/tools/dotc/core/TypeComparer.scala

@@ -677,7 +677,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
         canConstrain(param1) && canInstantiate ||
           isSubType(bounds(param1).hi.applyIfParameterized(args1), tp2)
       case tycon1: TypeProxy =>
-        isSubType(tycon1.underlying.bounds.hi.applyIfParameterized(args1), tp2)
+        isSubType(tycon1.superType.applyIfParameterized(args1), tp2)
       case _ =>
         false
     }
@@ -1218,20 +1218,17 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
       else original(tp1, tp2.appliedTo(tp2.typeParams.map(_.paramBoundsAsSeenFrom(tp2))))
     else if (tparams2.isEmpty)
       original(tp1.appliedTo(tp1.typeParams.map(_.paramBoundsAsSeenFrom(tp1))), tp2)
-    else {
-      val numArgs = tparams1.length
-      def argRefs(tl: GenericType) = List.range(0, numArgs).map(PolyParam(tl, _))
+    else
       TypeLambda(
-        paramNames = tpnme.syntheticLambdaParamNames(numArgs),
+        paramNames = tpnme.syntheticLambdaParamNames(tparams1.length),
         variances = (tparams1, tparams2).zipped.map((tparam1, tparam2) =>
           (tparam1.paramVariance + tparam2.paramVariance) / 2))(
         paramBoundsExp = tl => (tparams1, tparams2).zipped.map((tparam1, tparam2) =>
           tl.lifted(tparams1, tparam1.paramBoundsAsSeenFrom(tp1)).bounds &
           tl.lifted(tparams2, tparam2.paramBoundsAsSeenFrom(tp2)).bounds),
         resultTypeExp = tl =>
-          original(tl.lifted(tparams1, tp1).appliedTo(argRefs(tl)),
-             tl.lifted(tparams2, tp2).appliedTo(argRefs(tl))))
-    }
+          original(tl.lifted(tparams1, tp1).appliedTo(tl.paramRefs),
+             tl.lifted(tparams2, tp2).appliedTo(tl.paramRefs)))
   }
 
   /** Try to distribute `&` inside type, detect and handle conflicts

src/dotty/tools/dotc/core/TypeErasure.scala

@@ -356,8 +356,6 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
         case rt =>
           tp.derivedMethodType(tp.paramNames, formals, rt)
       }
-    case tp: TypeLambda =>
-      this(tp.resultType)
     case tp: PolyType =>
       this(tp.resultType) match {
         case rt: MethodType => rt

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

@@ -194,10 +194,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
         case tp: RefinedType => isClassRef(tp.parent)
         case _ => false
       }
-      def next(tp: TypeProxy) = tp.underlying match {
-        case TypeBounds(_, hi) => hi
-        case nx => nx
-      }
+
       /** If `tp1` and `tp2` are typebounds, try to make one fit into the other
        *  or to make them equal, by instantiating uninstantiated type variables.
        */
@@ -238,13 +235,13 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
         case tp1: RecType =>
           tp1.rebind(approximateOr(tp1.parent, tp2))
         case tp1: TypeProxy if !isClassRef(tp1) =>
-          approximateUnion(next(tp1) | tp2)
+          approximateUnion(tp1.superType | tp2)
         case _ =>
           tp2 match {
             case tp2: RecType =>
               tp2.rebind(approximateOr(tp1, tp2.parent))
             case tp2: TypeProxy if !isClassRef(tp2) =>
-              approximateUnion(tp1 | next(tp2))
+              approximateUnion(tp1 | tp2.superType)
             case _ =>
               val commonBaseClasses = tp.mapReduceOr(_.baseClasses)(intersect)
               val doms = dominators(commonBaseClasses, Nil)