Try to disallow illegal match types in F-bounds

This is the minimum extra check needed to avoid loops after the inference
changes in this PR and is incomplete, see test case.

Author: smarter

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

@@ -87,9 +87,22 @@ trait ConstraintHandling[AbstractContext] {
 
   protected def addOneBound(param: TypeParamRef, bound: Type, isUpper: Boolean)(using AbstractContext): Boolean =
     if !constraint.contains(param) then true
-    else if !isUpper && param.occursIn(bound)
-      // We don't allow recursive lower bounds when defining a type,
-      // so we shouldn't allow them as constraints either.
+    else if
+      bound.existsPart {
+        case `param` =>
+          // We don't allow recursive lower bounds when defining a type,
+          // so we shouldn't allow them as constraints either.
+          !isUpper
+        case AppliedType(tycon: TypeRef, args) if tycon.info.isInstanceOf[MatchAlias] =>
+          // FIXME: this is incomplete, see tests/pos/type-match-fbounds.scala
+          args.exists {
+            case `param` => true
+            case tp: TypeVar => tp.origin eq param
+            case _ => false
+          }
+        case _ => false
+      }
+    then
       false
     else
       val oldBounds @ TypeBounds(lo, hi) = constraint.nonParamBounds(param)

tests/neg/type-match-fbounds.scala

@@ -0,0 +1,28 @@
+class A {
+  type Foo[T] = T match {
+    case Int => String
+    case T => T
+  }
+
+  // FIXME: These cases are not disallowed currently and cause
+  // infinite loops
+  /*
+  def a1[T <: (T match {
+    case Int => String
+    case T => T
+  })]: T = ???
+  a1
+
+  def a2[T, U >: T <: (T match {
+    case Int => String
+    case T => T
+  })]: T = ???
+  a2
+
+  def a3[T <: Foo[T]]: T = ???
+  a3
+  */
+
+  def a4[T, U >: T <: Foo[T]]: T = ???
+  a4 // error
+}