Split HKTypeLambda from PolyType

Author: odersky

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

@@ -74,7 +74,7 @@ object TypeApplications {
     }
 
     def unapply(tp: Type)(implicit ctx: Context): Option[TypeRef] = tp match {
-      case tp @ PolyType/*###*/(tparams, AppliedType(fn: TypeRef, args)) if (args == tparams.map(_.toArg)) => Some(fn)
+      case tp @ HKTypeLambda(tparams, AppliedType(fn: TypeRef, args)) if (args == tparams.map(_.toArg)) => Some(fn)
       case _ => None
     }
   }
@@ -252,7 +252,7 @@ class TypeApplications(val self: Type) extends AnyVal {
   def isHK(implicit ctx: Context): Boolean = self.dealias match {
     case self: TypeRef => self.info.isHK
     case self: RefinedType => false
-    case self: TypeLambda => true
+    case self: HKTypeLambda => true
     case self: SingletonType => false
     case self: TypeVar =>
       // Using `origin` instead of `underlying`, as is done for typeParams,
@@ -338,10 +338,10 @@ class TypeApplications(val self: Type) extends AnyVal {
     if (hkParams.isEmpty) self
     else {
       def adaptArg(arg: Type): Type = arg match {
-        case arg @ PolyType(tparams, body) if /*###*/
+        case arg @ HKTypeLambda(tparams, body) if
              !tparams.corresponds(hkParams)(_.paramVariance == _.paramVariance) &&
              tparams.corresponds(hkParams)(varianceConforms) =>
-          PolyType(/*###*/
+          HKTypeLambda(
             (tparams, hkParams).zipped.map((tparam, hkparam) =>
               tparam.paramName.withVariance(hkparam.paramVariance)))(
             tl => arg.paramInfos.map(_.subst(arg, tl).bounds),

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

@@ -669,7 +669,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
           val tparams1 = tparams1a.drop(lengthDiff)
           variancesConform(tparams1, tparams) && {
             if (lengthDiff > 0)
-              tycon1b = PolyType(tparams1.map(_.paramName))(/*###*/
+              tycon1b = HKTypeLambda(tparams1.map(_.paramName))(
                 tl => tparams1.map(tparam => tl.integrate(tparams, tparam.paramInfo).bounds),
                 tl => tycon1a.appliedTo(args1.take(lengthDiff) ++
                         tparams1.indices.toList.map(TypeParamRef(tl, _))))
@@ -1278,7 +1278,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     else if (tparams2.isEmpty)
       original(tp1.appliedTo(tp1.typeParams.map(_.paramInfoAsSeenFrom(tp1))), tp2)
     else
-      PolyType(/*###*/
+      HKTypeLambda(
         paramNames = (tpnme.syntheticTypeParamNames(tparams1.length), tparams1, tparams2)
           .zipped.map((pname, tparam1, tparam2) =>
             pname.withVariance((tparam1.paramVariance + tparam2.paramVariance) / 2)))(

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

@@ -2758,7 +2758,7 @@ object Types {
      *      type T[X] >: L <: U  becomes    type T >: ([X] -> L) <: ([X] -> U)
      */
     override def fromParams[PI <: ParamInfo.Of[TypeName]](params: List[PI], resultType: Type)(implicit ctx: Context): Type = {
-      def expand(tp: Type) = PolyType.fromParams(params, tp) //###
+      def expand(tp: Type) = super.fromParams(params, tp)
       resultType match {
         case rt: TypeAlias =>
           rt.derivedTypeAlias(expand(rt.alias))
@@ -2784,9 +2784,6 @@ object Types {
     def any(n: Int)(implicit ctx: Context) =
       apply(syntheticParamNames(n))(
         pt => List.fill(n)(TypeBounds.empty), pt => defn.AnyType)
-
-    override def paramName(param: ParamInfo.Of[TypeName])(implicit ctx: Context): TypeName =
-      param.paramName.withVariance(param.paramVariance) //###
   }
 
   private object DepStatus {

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -255,7 +255,7 @@ class TreePickler(pickler: TastyPickler) {
       pickleType(tpe.underlying)
     case tpe: HKTypeLambda =>
       pickleMethodic(TYPELAMBDAtype, tpe)
-    case tpe: PolyType /*if richTypes*/ => //###
+    case tpe: PolyType if richTypes =>
       pickleMethodic(POLYtype, tpe)
     case tpe: MethodType if richTypes =>
       pickleMethodic(METHODtype, tpe)

compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -373,9 +373,9 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
         val apiTycon = simpleType(tycon)
         val apiArgs = args.map(processArg)
         new api.Parameterized(apiTycon, apiArgs.toArray)
-      case PolyType(tparams, res) => /*###*/
-        val apiTparams = tparams.map(apiTypeParameter)
-        val apiRes = apiType(res)
+      case tl: TypeLambda =>
+        val apiTparams = tl.typeParams.map(apiTypeParameter)
+        val apiRes = apiType(tl.resType)
         new api.Polymorphic(apiRes, apiTparams.toArray)
       case rt: RefinedType =>
         val name = rt.refinedName.toString

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

@@ -119,9 +119,9 @@ object Inferencing {
     }
   }
 
-  /** If `tree` has a PolyType, infer its type parameters by comparing with expected type `pt` */
+  /** If `tree` has a type lambda type, infer its type parameters by comparing with expected type `pt` */
   def inferTypeParams(tree: Tree, pt: Type)(implicit ctx: Context): Tree = tree.tpe match {
-    case poly: PolyType =>
+    case poly: TypeLambda =>
       val (poly1, tvars) = constrained(poly, tree)
       val tree1 = tree.withType(poly1).appliedToTypeTrees(tvars)
       tree1.tpe <:< pt

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

@@ -369,35 +369,35 @@ object ProtoTypes {
   /** A prototype for type constructors that are followed by a type application */
   @sharable object AnyTypeConstructorProto extends UncachedGroundType with MatchAlways
 
-  /** Add all parameters in given polytype `pt` to the constraint's domain.
+  /** Add all parameters of given type lambda `tl` to the constraint's domain.
    *  If the constraint contains already some of these parameters in its domain,
-   *  make a copy of the polytype and add the copy's type parameters instead.
-   *  Return either the original polytype, or the copy, if one was made.
+   *  make a copy of the type lambda and add the copy's type parameters instead.
+   *  Return either the original type lambda, or the copy, if one was made.
    *  Also, if `owningTree` is non-empty, add a type variable for each parameter.
-   *  @return  The added polytype, and the list of created type variables.
+   *  @return  The added type lambda, and the list of created type variables.
    */
-  def constrained(pt: PolyType, owningTree: untpd.Tree)(implicit ctx: Context): (PolyType, List[TypeTree]) = {
+  def constrained(tl: TypeLambda, owningTree: untpd.Tree)(implicit ctx: Context): (TypeLambda, List[TypeTree]) = {
     val state = ctx.typerState
     assert(!(ctx.typerState.isCommittable && owningTree.isEmpty),
       s"inconsistent: no typevars were added to committable constraint ${state.constraint}")
 
-    def newTypeVars(pt: PolyType): List[TypeTree] =
-      for (n <- (0 until pt.paramNames.length).toList)
+    def newTypeVars(tl: TypeLambda): List[TypeTree] =
+      for (n <- (0 until tl.paramNames.length).toList)
       yield {
         val tt = new TypeTree().withPos(owningTree.pos)
-        tt.withType(new TypeVar(TypeParamRef(pt, n), state, tt, ctx.owner))
+        tt.withType(new TypeVar(TypeParamRef(tl, n), state, tt, ctx.owner))
       }
 
     val added =
-      if (state.constraint contains pt) pt.newLikeThis(pt.paramNames, pt.paramInfos, pt.resultType)
-      else pt
+      if (state.constraint contains tl) tl.newLikeThis(tl.paramNames, tl.paramInfos, tl.resultType)
+      else tl
     val tvars = if (owningTree.isEmpty) Nil else newTypeVars(added)
     ctx.typeComparer.addToConstraint(added, tvars.tpes.asInstanceOf[List[TypeVar]])
     (added, tvars)
   }
 
-  /**  Same as `constrained(pt, EmptyTree)`, but returns just the created polytype */
-  def constrained(pt: PolyType)(implicit ctx: Context): PolyType = constrained(pt, EmptyTree)._1
+  /**  Same as `constrained(tl, EmptyTree)`, but returns just the created type lambda */
+  def constrained(tl: TypeLambda)(implicit ctx: Context): TypeLambda = constrained(tl, EmptyTree)._1
 
   /** Create a new TypeParamRef that represents a dependent method parameter singleton */
   def newDepTypeParamRef(tp: Type)(implicit ctx: Context): TypeParamRef = {

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

@@ -327,7 +327,7 @@ trait TypeAssigner {
 
   def assignType(tree: untpd.TypeApply, fn: Tree, args: List[Tree])(implicit ctx: Context) = {
     val ownType = fn.tpe.widen match {
-      case pt: PolyType =>
+      case pt: TypeLambda =>
         val paramNames = pt.paramNames
         if (hasNamedArg(args)) {
           // Type arguments which are specified by name (immutable after this first loop)

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

@@ -1055,7 +1055,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       typr.println(s"adding refinement $refinement")
       checkRefinementNonCyclic(refinement, refineCls, seen)
       val rsym = refinement.symbol
-      if (rsym.info.isInstanceOf[PolyType] && rsym.allOverriddenSymbols.isEmpty)
+      if (rsym.info.isInstanceOf[TypeLambda] && rsym.allOverriddenSymbols.isEmpty)
         ctx.error(i"polymorphic refinement $rsym without matching type in parent $tpt1 is no longer allowed", refinement.pos)    }
     assignType(cpy.RefinedTypeTree(tree)(tpt1, refinements1), tpt1, refinements1, refineCls)
   }
@@ -1841,7 +1841,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     }
 
     def adaptToArgs(wtp: Type, pt: FunProto): Tree = wtp match {
-      case _: MethodType | _: PolyType =>
+      case _: MethodOrPoly =>
         if (pt.args.lengthCompare(1) > 0 && isUnary(wtp) && ctx.canAutoTuple)
           adaptInterpolated(tree, pt.tupled, original)
         else