Merge pull request #8130 from dotty-staging/fix-#8067

Fix #8067: Don't constrain with types of wrong kinds

Author: odersky

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

@@ -524,13 +524,22 @@ trait ConstraintHandling[AbstractContext] {
           pruneLambdaParams(bound)
       }
 
+      def kindCompatible(tp1: Type, tp2: Type): Boolean =
+        val tparams1 = tp1.typeParams
+        val tparams2 = tp2.typeParams
+        tparams1.corresponds(tparams2)((p1, p2) => kindCompatible(p1.paramInfo, p2.paramInfo))
+        && (tparams1.isEmpty || kindCompatible(tp1.hkResult, tp2.hkResult))
+        || tp1.hasAnyKind
+        || tp2.hasAnyKind
+
       try bound match {
         case bound: TypeParamRef if constraint contains bound =>
           addParamBound(bound)
         case _ =>
           val pbound = prune(bound)
-          pbound.exists && (
-            if (fromBelow) addLowerBound(param, pbound) else addUpperBound(param, pbound))
+          pbound.exists
+          && kindCompatible(param, pbound)
+          && (if fromBelow then addLowerBound(param, pbound) else addUpperBound(param, pbound))
       }
       finally addConstraintInvocations -= 1
     }

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

@@ -250,8 +250,8 @@ class TypeApplications(val self: Type) extends AnyVal {
   /** Convert a type constructor `TC` which has type parameters `X1, ..., Xn`
    *  to `[X1, ..., Xn] -> TC[X1, ..., Xn]`.
    */
-  def EtaExpand(tparams: List[TypeSymbol])(implicit ctx: Context): Type =
-    HKTypeLambda.fromParams(tparams, self.appliedTo(tparams.map(_.typeRef)))
+  def EtaExpand(tparams: List[TypeParamInfo])(implicit ctx: Context): Type =
+    HKTypeLambda.fromParams(tparams, self.appliedTo(tparams.map(_.paramRef)))
       //.ensuring(res => res.EtaReduce =:= self, s"res = $res, core = ${res.EtaReduce}, self = $self, hc = ${res.hashCode}")
 
   /** If self is not lambda-bound, eta expand it. */
@@ -361,7 +361,7 @@ class TypeApplications(val self: Type) extends AnyVal {
   }
 
   /** Turns non-bounds types to type bounds.
-   *  A (possible lambda abstracted) match type is turned into an abstract type.
+   *  A (possible lambda abstracted) match type is turned into a match alias.
    *  Every other type is turned into a type alias
    */
   final def toBounds(implicit ctx: Context): TypeBounds = self match {

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

@@ -602,10 +602,8 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
           case _ =>
             val tparams1 = tp1.typeParams
             if (tparams1.nonEmpty)
-              return recur(
-                HKTypeLambda.fromParams(tparams1, tp1.appliedTo(tparams1.map(_.paramRef))),
-                tp2) || fourthTry
-            else tp2 match {
+              return recur(tp1.EtaExpand(tparams1), tp2) || fourthTry
+            tp2 match {
               case EtaExpansion(tycon2) if tycon2.symbol.isClass =>
                 return recur(tp1, tycon2)
               case _ =>

tests/pos/i8067.scala

@@ -0,0 +1,9 @@
+object Test {
+
+trait Tc[F[_]]
+type OfString[G[_]] = G[String]
+
+def foo[A[_]](fs: A[String])(implicit f: Tc[A]): A[String] = ???
+def bar[B[_]](fs: OfString[B]): B[String] = foo(fs)(new Tc[B] {})
+
+}