Preserve tvar bounds that represent kinds

The kinds of type variables being solved are represented by by their
upper bounds. If we loose track of these then kinds will be incorrect on
the RHS of inline matches and match types.

Without the additional change in TypeComparer this breaks
tests/pos/i5574.scala. The added fallback to fourthTry brings the higher
kinded case into line with the path that's followed in the simply kinded
case and restores the correct behaviour. Unfortunately I'm not able to
justify it other than that it emerged from extensive trial and error and
comparison with the simply kinded case.

I'd also love to understand the use return in TypeComparer. Is it an
optimization or does it have some semantic significance?

Fixes #6014.

Author: milessabin

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

@@ -929,7 +929,10 @@ object Contexts {
             // - we don't want TyperState instantiating these TypeVars
             // - we don't want TypeComparer constraining these TypeVars
             val poly = PolyType(DepParamName.fresh(sym.name.toTypeName) :: Nil)(
-              pt => TypeBounds.empty :: Nil,
+              pt => (sym.info match {
+                case tb @ TypeBounds(lo, hi) if (lo eq defn.NothingType) && hi.isLambdaSub => tb
+                case _ => TypeBounds.empty
+              }) :: Nil,
               pt => defn.AnyType)
             new TypeVar(poly.paramRefs.head, creatorState = null)
           }

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

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

compiler/test/dotc/pos-from-tasty.blacklist

@@ -27,3 +27,4 @@ t6278-synth-def.scala
 
 # Need to print empty tree for implicit match
 i5938.scala
+i6014.scala

tests/pos/i6014.scala

@@ -0,0 +1,25 @@
+import scala.compiletime._
+
+object Test1 {
+  type Foo[F[_]]
+  type Bar[T] = T match {
+    case Foo[f] => f[Int]
+  }
+
+  val li: Bar[Foo[List]] = List(1, 2, 3)
+}
+
+object Test2 {
+  inline def summon[T] = implicit match {
+    case t: T => t
+  }
+
+  class Foo[F[_]]
+
+  inline def bar[T] = inline erasedValue[T] match {
+    case _: Foo[f] => summon[f[Int]]
+  }
+
+  implicit val li: List[Int] = List(1, 2, 3)
+  bar[Foo[List]]
+}