Refine kind checking

Need to also check parameter kinds of higher-kinded types,
not just result kinds.

Author: odersky

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

@@ -251,18 +251,21 @@ class TypeApplications(val self: Type) extends AnyVal {
   }
 
   /** Is self type higher-kinded (i.e. of kind != "*")? */
-  def isHK(implicit ctx: Context): Boolean = self.dealias match {
-    case self: TypeRef => self.info.isHK
-    case self: RefinedType => false
-    case self: HKTypeLambda => true
-    case self: SingletonType => false
+  def isHK(implicit ctx: Context): Boolean = hkResult.exists
+
+  /** If self type is higher-kinded, its result type, otherwise NoType */
+  def hkResult(implicit ctx: Context): Type = self.dealias match {
+    case self: TypeRef => self.info.hkResult
+    case self: RefinedType => NoType
+    case self: HKTypeLambda => self.resultType
+    case self: SingletonType => NoType
     case self: TypeVar =>
       // Using `origin` instead of `underlying`, as is done for typeParams,
       // avoids having to set ephemeral in some cases.
-      self.origin.isHK
-    case self: WildcardType => self.optBounds.isHK
-    case self: TypeProxy => self.superType.isHK
-    case _ => false
+      self.origin.hkResult
+    case self: WildcardType => self.optBounds.hkResult
+    case self: TypeProxy => self.superType.hkResult
+    case _ => NoType
   }
 
   /** Dealias type if it can be done without forcing the TypeRef's info */

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

@@ -100,30 +100,38 @@ object Checking {
     checkValidIfHKApply(ctx.addMode(Mode.AllowLambdaWildcardApply))
   }
 
-  /** Check that the rank of the kind of `arg` does not exceed the rank of the
-   *  kind of `paramBounds`. E.g. if `paramBounds` has *-kind, `arg` must have
-   *  *-kind as well, and analogously for higher kinds.
-   *  More detailed kind checking is done as part of checkBounds in PostTyper.
-   *  The purpose of checkKindRank is to do a rough test earlier in Typer,
+  /** Check that kind of `arg` has the same outline as the kind of paramBounds.
+   *  E.g. if `paramBounds` has kind * -> *, `arg` must have that kind as well,
+   *  and analogously for all other kinds. This kind checking does not take into account
+   *  variances or bounds. The more detailed kind checking is done as part of checkBounds in PostTyper.
+   *  The purpose of preCheckKind is to do a rough test earlier in Typer,
    *  in order to prevent scenarios that lead to self application of
-   *  types. Self application needs to be avoided since it can lead to stackoverflows.
-   *  A test case is neg/i2771.scala.
+   *  types. Self application needs to be avoided since it can lead to stack overflows.
+   *  Test cases are neg/i2771.scala and neg/i2771b.scala.
    */
-  def checkKindRank(arg: Tree, paramBounds: TypeBounds)(implicit ctx: Context): Tree = {
+  def preCheckKind(arg: Tree, paramBounds: TypeBounds)(implicit ctx: Context): Tree = {
     def result(tp: Type): Type = tp match {
       case tp: HKTypeLambda => tp.resultType
       case tp: TypeProxy => result(tp.superType)
       case _ => defn.AnyType
     }
-    def kindOK(argType: Type, boundType: Type): Boolean =
-      !argType.isHK ||
-        boundType.isHK && kindOK(result(argType), result(boundType))
+    def kindOK(argType: Type, boundType: Type): Boolean = {
+      // println(i"check kind rank2$arg $argType $boundType") // DEBUG
+      val argResult = argType.hkResult
+      val boundResult = argType.hkResult
+      if (argResult.exists)
+        boundResult.exists &&
+        kindOK(boundResult, argResult) &&
+        argType.typeParams.corresponds(boundType.typeParams)((ap, bp) =>
+          kindOK(ap.paramInfo, bp.paramInfo))
+      else !boundResult.exists
+    }
     if (kindOK(arg.tpe, paramBounds.hi)) arg
-    else errorTree(arg, em"${arg.tpe} takes type parameters")
+    else errorTree(arg, em"${arg.tpe} has wrong kind")
   }
 
-  def checkKindRanks(args: List[Tree], paramBoundss: List[TypeBounds])(implicit ctx: Context): List[Tree] = {
-    val args1 = args.zipWithConserve(paramBoundss)(checkKindRank)
+  def preCheckKinds(args: List[Tree], paramBoundss: List[TypeBounds])(implicit ctx: Context): List[Tree] = {
+    val args1 = args.zipWithConserve(paramBoundss)(preCheckKind)
     args1 ++ args.drop(paramBoundss.length)
       // add any arguments that do not correspond to a parameter back,
       // so the wrong number of parameters is reported afterwards.

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

@@ -14,7 +14,7 @@ import NameOps._
 import collection.mutable
 import reporting.diagnostic.Message
 import reporting.diagnostic.messages._
-import Checking.{checkKindRank, checkKindRanks, checkNoPrivateLeaks}
+import Checking.{preCheckKind, preCheckKinds, checkNoPrivateLeaks}
 
 trait TypeAssigner {
   import tpd._
@@ -358,7 +358,7 @@ trait TypeAssigner {
             else if (!paramNames.contains(name))
               ctx.error(s"undefined parameter name, required: ${paramNames.mkString(" or ")}", arg.pos)
             else
-              namedArgMap(name) = checkKindRank(arg, paramBoundsByName(name.asTypeName)).tpe
+              namedArgMap(name) = preCheckKind(arg, paramBoundsByName(name.asTypeName)).tpe
 
           // Holds indexes of non-named typed arguments in paramNames
           val gapBuf = new mutable.ListBuffer[Int]
@@ -391,7 +391,7 @@ trait TypeAssigner {
           }
         }
         else {
-          val argTypes = checkKindRanks(args, pt.paramInfos).tpes
+          val argTypes = preCheckKinds(args, pt.paramInfos).tpes
           if (sameLength(argTypes, paramNames) || ctx.phase.prev.relaxedTyping) pt.instantiate(argTypes)
           else wrongNumberOfTypeArgs(fn.tpe, pt.typeParams, args, tree.pos)
         }

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

@@ -1140,7 +1140,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         }
         args.zipWithConserve(tparams)(typedArg(_, _)).asInstanceOf[List[Tree]]
       }
-      val args2 = checkKindRanks(args1, tparams.map(_.paramInfo.bounds))
+      val args2 = preCheckKinds(args1, tparams.map(_.paramInfo.bounds))
       // check that arguments conform to bounds is done in phase PostTyper
       assignType(cpy.AppliedTypeTree(tree)(tpt1, args2), tpt1, args2)
     }