Refine kind checking

Fix problems in previous iteration.

Author: odersky

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

@@ -100,14 +100,25 @@ object Checking {
     checkValidIfHKApply(ctx.addMode(Mode.AllowLambdaWildcardApply))
   }
 
-  def checkKind(arg: Tree, paramBounds: TypeBounds)(implicit ctx: Context): Tree =
+  /** Check that `arg` has a *-type, unless `paramBounds` is higher-kinded.
+   *  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,
+   *  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 checkKinds(args: List[Tree], paramBoundss: List[TypeBounds])(implicit ctx: Context): List[Tree] =
-    args.zipWithConserve(paramBoundss)(checkKind)
+  def checkStarKinds(args: List[Tree], paramBoundss: List[TypeBounds])(implicit ctx: Context): List[Tree] = {
+    val args1 = args.zipWithConserve(paramBoundss)(checkStarKind)
+    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.
+  }
 
   /** Check that `tp` refers to a nonAbstract class
    *  and that the instance conforms to the self type of the created class.

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

@@ -838,9 +838,9 @@ class Namer { typer: Typer =>
        * only if parent type contains uninstantiated type parameters.
        */
       def parentType(parent: untpd.Tree)(implicit ctx: Context): Type =
-        if (parent.isType) {
+        if (parent.isType)
           typedAheadType(parent, AnyTypeConstructorProto).tpe
-        } else {
+        else {
           val (core, targs) = stripApply(parent) match {
             case TypeApply(core, targs) => (core, targs)
             case core => (core, Nil)

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.{checkKind, checkKinds, checkNoPrivateLeaks}
+import Checking.{checkStarKind, checkStarKinds, 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) = checkKind(arg, paramBoundsByName(name.asTypeName)).tpe
+              namedArgMap(name) = checkStarKind(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 = checkKinds(args, pt.paramInfos).tpes
+          val argTypes = checkStarKinds(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 = checkKinds(args1, tparams.map(_.paramInfo.bounds))
+      val args2 = checkStarKinds(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/i1652.scala

@@ -1,5 +1,5 @@
 object Test {
-  val v: Array[Array[Array]] = Array()    // error // error
+  val v: Array[Array[Array]] = Array()    // error: Array takes type parameters
   def f[T](w: Array[Array[T]]) = { for (r <- w) () }
-  f(v) // error
+  f(v)
 }

tests/neg/i2771.scala

@@ -6,11 +6,11 @@ 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
+    f(new B { type L[F[_]] = F[F] })(1)
   }
 
   def foo[X[_] <: Any]() = ()
-  foo[Int]()  // should be an error
+  foo[Int]()  // an error would be raised later, during PostTyper.
 
   def bar[X, Y]() = ()
   bar[List, Int]()   // error: List takes type parameters