Check that some types are not higher-kinded.

Invalidates scala#813. Review by @DarkDimius.

Author: odersky

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

@@ -347,6 +347,10 @@ trait Checking {
         ctx.error(i"""$called is already implemented by super${caller.superClass},
                    |its constructor cannot be called again""".stripMargin, call.pos)
     }
+
+  /** Check that `tpt` does not define a higher-kinded type */
+  def checkSimpleKinded(tpt: Tree)(implicit ctx: Context) =
+    if (tpt.tpe.isHK) ctx.error(s"missing type parameter", tpt.pos)
 }
 
 trait NoChecking extends Checking {
@@ -360,4 +364,5 @@ trait NoChecking extends Checking {
   override def checkFeasible(tp: Type, pos: Position, where: => String = "")(implicit ctx: Context): Type = tp
   override def checkNoDoubleDefs(cls: Symbol)(implicit ctx: Context): Unit = ()
   override def checkParentCall(call: Tree, caller: ClassSymbol)(implicit ctx: Context) = ()
+  override def checkSimpleKinded(tpt: Tree)(implicit ctx: Context) = ()
 }

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

@@ -370,6 +370,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
           TypeTree(defn.SeqClass.typeRef.appliedTo(pt :: Nil))
         else
           typedType(tree.tpt)
+      checkSimpleKinded(tpt1)
       val expr1 =
         if (isWildcard) tree.expr withType tpt1.tpe
         else typed(tree.expr, tpt1.tpe)
@@ -918,6 +919,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val ValDef(name, tpt, _) = vdef
     completeAnnotations(vdef, sym)
     val tpt1 = typedType(tpt)
+    checkSimpleKinded(tpt1)
     val rhs1 = vdef.rhs match {
       case rhs @ Ident(nme.WILDCARD) => rhs withType tpt1.tpe
       case rhs => typedExpr(rhs, tpt1.tpe)
@@ -932,6 +934,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val vparamss1 = vparamss nestedMapconserve (typed(_).asInstanceOf[ValDef])
     if (sym is Implicit) checkImplicitParamsNotSingletons(vparamss1)
     val tpt1 = typedType(tpt)
+    checkSimpleKinded(tpt1)
     val rhs1 = typedExpr(ddef.rhs, tpt1.tpe)
     assignType(cpy.DefDef(ddef)(name, tparams1, vparamss1, tpt1, rhs1), sym)
     //todo: make sure dependent method types do not depend on implicits or by-name params

test/dotc/tests.scala

@@ -104,7 +104,7 @@ class tests extends CompilerTest {
   @Test def neg_typedapply() = compileFile(negDir, "typedapply", xerrors = 4)
   @Test def neg_typedidents() = compileFile(negDir, "typedIdents", xerrors = 2)
   @Test def neg_assignments() = compileFile(negDir, "assignments", xerrors = 3)
-  @Test def neg_typers() = compileFile(negDir, "typers", xerrors = 10)(allowDoubleBindings)
+  @Test def neg_typers() = compileFile(negDir, "typers", xerrors = 13)(allowDoubleBindings)
   @Test def neg_privates() = compileFile(negDir, "privates", xerrors = 2)
   @Test def neg_rootImports = compileFile(negDir, "rootImplicits", xerrors = 2)
   @Test def neg_templateParents() = compileFile(negDir, "templateParents", xerrors = 3)

tests/neg/typers.scala

@@ -29,8 +29,14 @@ object typers {
     def g[T](x: T): T = x  // OK!
   }
 
+  type L[X] = scala.collection.immutable.List[X]
+  type M[X, Y] <: scala.collection.immutable.Map[X, Y]
 
-
+  object hk {
+    def f(x: L)  // error: missing type parameter
+    : M =        // error: missing type parameter
+    ??? : M      // error: missing type parameter
+  }
 
   object returns {