Generalize kind checking

We now check that the rank of the kind of a type argument does
not exceed the rank of its bounds. i2771b is an example that shows
that checking at rank * only is not enough.

Author: odersky

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

@@ -100,21 +100,25 @@ object Checking {
     checkValidIfHKApply(ctx.addMode(Mode.AllowLambdaWildcardApply))
   }
 
-  /** Check that `arg` has a *-type, unless `paramBounds` is higher-kinded.
+  /** 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 checkStarKind is to do a rough test earlier in Typer,
+   *  The purpose of checkKindRank 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.
    */
-  def checkStarKind(arg: Tree, paramBounds: TypeBounds)(implicit ctx: Context): Tree =
-    if (arg.tpe.isHK && !paramBounds.isHK)
-      errorTree(arg, em"${arg.tpe} takes type parameters")
-    else
-      arg
-
-  def checkStarKinds(args: List[Tree], paramBoundss: List[TypeBounds])(implicit ctx: Context): List[Tree] = {
-    val args1 = args.zipWithConserve(paramBoundss)(checkStarKind)
+  def checkKindRank(arg: Tree, paramBounds: TypeBounds)(implicit ctx: Context): Tree = {
+    def kindOK(argType: Type, boundType: Type): Boolean =
+      !argType.isHK ||
+        boundType.isHK && kindOK(argType.resultType, boundType.resultType)
+    if (kindOK(arg.tpe, paramBounds.hi)) arg
+    else errorTree(arg, em"${arg.tpe} takes type parameters")
+  }
+
+  def checkKindRanks(args: List[Tree], paramBoundss: List[TypeBounds])(implicit ctx: Context): List[Tree] = {
+    val args1 = args.zipWithConserve(paramBoundss)(checkKindRank)
     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.{checkStarKind, checkStarKinds, checkNoPrivateLeaks}
+import Checking.{checkKindRank, checkKindRanks, 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) = checkStarKind(arg, paramBoundsByName(name.asTypeName)).tpe
+              namedArgMap(name) = checkKindRank(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 = checkStarKinds(args, pt.paramInfos).tpes
+          val argTypes = checkKindRanks(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 = checkStarKinds(args1, tparams.map(_.paramInfo.bounds))
+      val args2 = checkKindRanks(args1, tparams.map(_.paramInfo.bounds))
       // check that arguments conform to bounds is done in phase PostTyper
       assignType(cpy.AppliedTypeTree(tree)(tpt1, args2), tpt1, args2)
     }

tests/neg/i2771b.scala

@@ -0,0 +1,11 @@
+trait A { type L[X[_]] }
+trait B { type L }
+trait C { type M <: A }
+trait D { type M >: B }
+
+object Test {
+  def test(x: C with D): Unit = {
+    def f(y: x.M)(z: y.L[y.L]) = z          // error: y.L takes type parameters
+    f(new B { type L[F[_[_]]] = F[F] })(1)  // error: F takes type parameters
+  }
+}