Refine TypeVarsMissContext for MatchTypes

Match-pattern bound variables should not assume to match all other types,
even if TypeVarsMissContext is true.

Author: odersky

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

@@ -363,6 +363,13 @@ trait ConstraintHandling {
   final def canConstrain(param: TypeParamRef): Boolean =
     (!frozenConstraint || (caseLambda `eq` param.binder)) && constraint.contains(param)
 
+  /** Is `param` assumed to be a sub- and super-type of any other type?
+   *  This holds if `TypeVarsMissContext` is set unless `param` is a part
+   *  of a MatchType that is currently normalized.
+   */
+  final def assumedTrue(param: TypeParamRef): Boolean =
+    ctx.mode.is(Mode.TypevarsMissContext) && (caseLambda `ne` param.binder)
+
   /** Add constraint `param <: bound` if `fromBelow` is false, `param >: bound` otherwise.
    *  `bound` is assumed to be in normalized form, as specified in `firstTry` and
    *  `secondTry` of `TypeComparer`. In particular, it should not be an alias type,

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

@@ -325,7 +325,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
           true
         }
         def compareTypeParamRef =
-          ctx.mode.is(Mode.TypevarsMissContext) ||
+          assumedTrue(tp1) ||
           isSubTypeWhenFrozen(bounds(tp1).hi, tp2) || {
             if (canConstrain(tp1) && !approx.high)
               addConstraint(tp1, tp2, fromBelow = false) && flagNothingBound
@@ -428,7 +428,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
         thirdTryNamed(tp2)
       case tp2: TypeParamRef =>
         def compareTypeParamRef =
-          (ctx.mode is Mode.TypevarsMissContext) || {
+          assumedTrue(tp2) || {
           val alwaysTrue =
             // The following condition is carefully formulated to catch all cases
             // where the subtype relation is true without needing to add a constraint
@@ -787,9 +787,8 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
                     tl => tparams1.map(tparam => tl.integrate(tparams, tparam.paramInfo).bounds),
                     tl => tp1base.tycon.appliedTo(args1.take(lengthDiff) ++
                             tparams1.indices.toList.map(tl.paramRefs(_))))
-                (ctx.mode.is(Mode.TypevarsMissContext) ||
-                  tryInstantiate(tycon2, tycon1.ensureLambdaSub)) &&
-                  recur(tp1, tycon1.appliedTo(args2))
+                (assumedTrue(tycon2) || tryInstantiate(tycon2, tycon1.ensureLambdaSub)) &&
+                recur(tp1, tycon1.appliedTo(args2))
               }
             }
           case _ => false