Update comparisons of higher-kinded types

Several fixes to make sure that Any is a supertype only of * types. Before there
were some types that slipped through the net.

Also, new tests.

Author: odersky

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

@@ -667,7 +667,7 @@ object SymDenotations {
 
     /** Is this symbol a class references to which that are supertypes of null? */
     final def isNullableClass(implicit ctx: Context): Boolean =
-      isClass && !isValueClass && !(this is ModuleClass) && symbol != defn.NothingClass
+      isClass && !isValueClass && !is(ModuleClass) && symbol != defn.NothingClass
 
     /** Is this definition accessible as a member of tree with type `pre`?
      *  @param pre          The type of the tree from which the selection is made

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

@@ -377,21 +377,22 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
       case _ =>
         val cls2 = tp2.symbol
         if (cls2.isClass) {
-          if (cls2 eq AnyKindClass)
-            return true
-          else if (cls2.typeParams.nonEmpty && tp1.isHK)
-            return recur(tp1, EtaExpansion(cls2.typeRef))
-          else {
+          if (cls2.typeParams.isEmpty) {
+            if (cls2 eq AnyKindClass) return true
+            if (tp1.isRef(defn.NothingClass)) return true
+            if (tp1.isHK) return false
             val base = tp1.baseType(cls2)
-            if (base.exists) {
-              if (cls2.is(JavaDefined))
-                // If `cls2` is parameterized, we are seeing a raw type, so we need to compare only the symbol
-                return base.typeSymbol == cls2
-              if (base ne tp1)
-                return isSubType(base, tp2, if (tp1.isRef(cls2)) approx else approx.addLow)
-            }
+            if (base.exists && base.ne(tp1))
+              return isSubType(base, tp2, if (tp1.isRef(cls2)) approx else approx.addLow)
             if (cls2 == defn.SingletonClass && tp1.isStable) return true
           }
+          else if (cls2.is(JavaDefined)) {
+            // If `cls2` is parameterized, we are seeing a raw type, so we need to compare only the symbol
+            val base = tp1.baseType(cls2)
+            if (base.typeSymbol == cls2) return true
+          }
+          else if (tp1.isHK && !tp1.isRef(defn.AnyKindClass))
+            return recur(tp1, EtaExpansion(cls2.typeRef))
         }
         fourthTry
     }
@@ -487,13 +488,11 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
               isSubType(tp1.resType, tp2.resType.subst(tp2, tp1))
             finally comparedTypeLambdas = saved
           case _ =>
-            if (tp1.isHK) {
-              val tparams1 = tp1.typeParams
+            val tparams1 = tp1.typeParams
+            if (tparams1.nonEmpty)
               return recur(
                 HKTypeLambda.fromParams(tparams1, tp1.appliedTo(tparams1.map(_.paramRef))),
-                tp2
-              )
-            }
+                tp2)
             else tp2 match {
               case EtaExpansion(tycon2) if tycon2.symbol.isClass =>
                 return recur(tp1, tycon2)
@@ -552,7 +551,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
         def compareTypeBounds = tp1 match {
           case tp1 @ TypeBounds(lo1, hi1) =>
             ((lo2 eq NothingType) || isSubType(lo2, lo1)) &&
-            ((hi2 eq AnyType) || (hi2 eq AnyKindType) || isSubType(hi1, hi2))
+            ((hi2 eq AnyType) && !hi1.isHK || (hi2 eq AnyKindType) || isSubType(hi1, hi2))
           case tp1: ClassInfo =>
             tp2 contains tp1
           case _ =>
@@ -1228,8 +1227,8 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     if (tp1 eq tp2) tp1
     else if (!tp1.exists) tp2
     else if (!tp2.exists) tp1
-    else if ((tp1 isRef AnyClass) || (tp1 isRef AnyKindClass) || (tp2 isRef NothingClass)) tp2
-    else if ((tp2 isRef AnyClass) || (tp2 isRef AnyKindClass) || (tp1 isRef NothingClass)) tp1
+    else if ((tp1 isRef AnyClass) && !tp2.isHK || (tp1 isRef AnyKindClass) || (tp2 isRef NothingClass)) tp2
+    else if ((tp2 isRef AnyClass) && !tp1.isHK || (tp2 isRef AnyKindClass) || (tp1 isRef NothingClass)) tp1
     else tp2 match {  // normalize to disjunctive normal form if possible.
       case OrType(tp21, tp22) =>
         tp1 & tp21 | tp1 & tp22

tests/neg/anykind.scala

@@ -21,5 +21,6 @@ object AnyKinds {
   g[Int]      // OK
   g[Nothing]  // OK
 
+  trait X[F[_] <: AnyKind] { type L = F[Int]; def a: L = ??? } // error: cannot be used as a value type
 
 }

tests/neg/anykind1.scala

@@ -0,0 +1,11 @@
+object Test {
+
+  // Checking edge cases that should not compile with kind-polymorphism
+  trait X[F[_] <: AnyKind] { def a: Int }
+  new X[Int] { }   // error
+  new X[Int] { }.a // error
+  new X[Either] { } // error
+  new X[Either] { }.a // error
+  new X[({ type l[X, Y] = X })#l] { } // error
+
+}

tests/neg/anykind2.scala

@@ -16,5 +16,6 @@ object AnyKinds {
   g[List]     // error
   g[Nothing]  // OK
 
+  1.asInstanceOf[AnyKind] // error
 
 }

tests/neg/anykind3.scala

@@ -0,0 +1,63 @@
+
+object Test {
+
+  def f[X] = ()
+  f[List]
+
+  // Checking edge cases that should not compile with kind-polymorphism
+
+  trait X[A <: AnyKind, F[_ <: AnyKind]] { type B = F[A] }
+
+  val i0: X[Option, Double]#B = Some(5) // error
+
+  val i1: X[Option, List]#B = Some(5) // error
+
+  val i2: X[Option[Double], List]#B = Some(5) // error
+
+  val i3: X[Option[Double], ({ type l[X[_]] = X[Int] })#l]#B = Some(5) // error
+
+  val i4: X[Double, ({ type l[X[_]] = X[Int] })#l]#B = 5.0 // error
+
+  val i6: X[Either, ({ type l[X[_]] = X[Int] })#l]#B = Some(5) // error
+
+  val i7: X[Either, List]#B = Some(5) // error
+
+  trait Foo[A[_[_]]]
+  val i8: X[Foo, ({ type l[X[_]] = X[Int] })#l]#B = Some(5) // error
+
+  trait X2[A <: AnyKind, B <: AnyKind] { def run[F[_ <: AnyKind]]: F[A] => F[B] }
+
+  val x21 = {
+    new X2[Int, Int] { def run[F[_]]: F[Int] => F[Int] = identity[F[Int]] }
+      .asInstanceOf[X2[List, Option[Double]]].run[({ type l[X[_]] = X[Int] })#l]
+  }
+
+  val x22 = {
+    new X2[Int, Int] { def run[F[_]]: F[Int] => F[Int] = identity[F[Int]] }
+      .asInstanceOf[X2[List, Option[Double]]].run[List]
+  }
+
+  trait X3[A <: AnyKind, B <: AnyKind, C <: AnyKind] { def run[F[_ <: AnyKind, _ <: AnyKind]]: F[A, C] => F[B, C] }
+
+  val x31 = {
+    new X3[Int, Int, String] { def run[F[_, _]]: F[Int, String] => F[Int, String] = identity[F[Int, String]] }
+      .asInstanceOf[X3[Option[Double], List, String]].run[Map]
+  }
+  val x32 = {
+    new X3[Int, Int, String] { def run[F[_, _]]: F[Int, String] => F[Int, String] = identity[F[Int, String]] }
+      .asInstanceOf[X3[List, Option[Double], String]].run[Map]
+  }
+
+  trait X4[A <: AnyKind, B <: AnyKind, C] { def run[F[_ <: AnyKind, _]]: F[A, C] => F[B, C] }
+
+  trait Foo2[A]
+  trait Bar[A]
+  trait Bar2[A, B]
+
+  trait Toto[F[_], A]
+
+  val x41 = {
+    new X3[Foo2, Foo2, Int] { def run[F[_[_], A]]: F[Foo2, Int] => F[Foo2, Int] = identity[F[Foo2, Int]] }
+      .asInstanceOf[X3[Bar, Bar, Int]].run[Bar2]
+  }
+}

tests/neg/anykind4.scala

@@ -0,0 +1,14 @@
+
+object Test {
+
+  trait Foo[T <: AnyKind]
+
+  def foo[T <: AnyKind](implicit f: Foo[T]): f.type = f
+
+  implicit def c1[T]: Foo[T] = ???
+  implicit def c2[T[_]]: Foo[T] = ???
+
+  foo[List](c1) // error
+
+  foo[List](c2)
+}