Narrow matches from TypeLambda to HKTypeLambda where appropriate

Author: odersky

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

@@ -215,7 +215,7 @@ class TypeApplications(val self: Type) extends AnyVal {
     self match {
       case self: ClassInfo =>
         self.cls.typeParams
-      case self: TypeLambda =>
+      case self: HKTypeLambda =>
         self.typeParams
       case self: TypeRef =>
         val tsym = self.symbol
@@ -386,7 +386,7 @@ class TypeApplications(val self: Type) extends AnyVal {
     val dealiased = stripped.safeDealias
     if (args.isEmpty || ctx.erasedTypes) self
     else dealiased match {
-      case dealiased: TypeLambda =>
+      case dealiased: HKTypeLambda =>
         def tryReduce =
           if (!args.exists(_.isInstanceOf[TypeBounds])) {
             val followAlias = Config.simplifyApplications && {
@@ -414,6 +414,8 @@ class TypeApplications(val self: Type) extends AnyVal {
               else HKApply(dealiased, args)
           }
         tryReduce
+      case dealiased: PolyType =>
+        dealiased.instantiate(args)
       case dealiased: AndOrType =>
         dealiased.derivedAndOrType(dealiased.tp1.appliedTo(args), dealiased.tp2.appliedTo(args))
       case dealiased: TypeAlias =>

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

@@ -430,7 +430,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
       compareHkApply2(tp1, tp2, tycon2, args2)
     case tp2: HKTypeLambda =>
       def compareTypeLambda: Boolean = tp1.stripTypeVar match {
-        case tp1: TypeLambda =>
+        case tp1: HKTypeLambda =>
           /* Don't compare bounds of lambdas under language:Scala2, or t2994 will fail
            * The issue is that, logically, bounds should compare contravariantly,
            * but that would invalidate a pattern exploited in t2994:

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

@@ -539,7 +539,7 @@ object Types {
       }
 
       def goApply(tp: HKApply) = tp.tycon match {
-        case tl: TypeLambda =>
+        case tl: HKTypeLambda =>
           go(tl.resType).mapInfo(info =>
             tl.derivedLambdaAbstraction(tl.paramNames, tl.paramInfos, info).appliedTo(tp.args))
         case _ =>
@@ -2830,7 +2830,7 @@ object Types {
     override def superType(implicit ctx: Context): Type = {
       if (ctx.period != validSuper) {
         cachedSuper = tycon match {
-          case tp: TypeLambda => defn.AnyType
+          case tp: HKTypeLambda => defn.AnyType
           case tp: TypeVar if !tp.inst.exists =>
             // supertype not stable, since underlying might change
             return tp.underlying.applyIfParameterized(args)

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

@@ -121,9 +121,9 @@ object Inferencing {
 
   /** 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: TypeLambda =>
-      val (poly1, tvars) = constrained(poly, tree)
-      val tree1 = tree.withType(poly1).appliedToTypeTrees(tvars)
+    case tl: TypeLambda =>
+      val (tl1, tvars) = constrained(tl, tree)
+      val tree1 = tree.withType(tl1).appliedToTypeTrees(tvars)
       tree1.tpe <:< pt
       fullyDefinedType(tree1.tpe, "template parent", tree.pos)
       tree1