Clean up kindedness tests

We currently mostly use isLambdaSub which detects unapplied
abstract and alias types but not unapplied generic classes.
We should use `hasHigherKind` more often, which includes
unapplied classes.

The first commit fixes a problem with `hasHigherKind` where
abstract types upper bounded by `AnyKind` where not classified
as higher-kinded.

It also changes checkSimpleKinded to use hasHigherKind instead
if isLambdaSub.

Author: odersky

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

@@ -212,7 +212,10 @@ class TypeApplications(val self: Type) extends AnyVal {
 
   /** Is self type of kind != "*"? */
   def hasHigherKind(implicit ctx: Context): Boolean =
-    typeParams.nonEmpty || self.isRef(defn.AnyKindClass)
+    typeParams.nonEmpty || self.hasAnyKind
+
+  /** Is self type of kind "*"? */
+  def hasFirstKind(implicit ctx: Context): Boolean = !hasHigherKind
 
   /** If self type is higher-kinded, its result type, otherwise NoType.
    *  Note: The hkResult of an any-kinded type is again AnyKind.

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

@@ -248,6 +248,20 @@ object Types {
     /** Is this type a (possibly aliased) singleton type? */
     def isSingleton(implicit ctx: Context) = dealias.isInstanceOf[SingletonType]
 
+    /** Is this type of kind `AnyKind`? */
+    def hasAnyKind(implicit ctx: Context): Boolean = {
+      @tailrec def loop(tp: Type): Boolean = tp match {
+        case tp: TypeRef =>
+          val sym = tp.symbol
+          if (sym.isClass) sym == defn.AnyKindClass else loop(tp.superType)
+        case tp: TypeProxy =>
+          loop(tp.underlying)
+        case _ =>
+          false
+      }
+      loop(this)
+    }
+
     /** Is this type guaranteed not to have `null` as a value? */
     final def isNotNull(implicit ctx: Context): Boolean = this match {
       case tp: ConstantType => tp.value.value != null

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

@@ -704,7 +704,7 @@ trait Checking {
 
   /** Check that `tpt` does not define a higher-kinded type */
   def checkSimpleKinded(tpt: Tree)(implicit ctx: Context): Tree =
-    if (tpt.tpe.isLambdaSub && !ctx.compilationUnit.isJava) {
+    if (tpt.tpe.hasHigherKind && !ctx.compilationUnit.isJava) {
         // be more lenient with missing type params in Java,
         // needed to make pos/java-interop/t1196 work.
       errorTree(tpt, MissingTypeParameterFor(tpt.tpe))