Be more careful when constraining parameter types wrt scrutinees

i3989a.scala gives an example which is rejected under the new scheme.
This would pass and fail at runtime under the previous scheme.

Author: odersky

compiler/src/dotty/tools/dotc/typer/Inferencing.scala

@@ -154,6 +154,59 @@ object Inferencing {
       tree
   }
 
+  /** Derive information about a pattern type by comparing it with some variant of the
+   *  static scrutinee type. We have the following situation in case of a (dynamic) pattern match:
+   *
+   *       StaticScrutineeType           PatternType
+   *                         \            /
+   *                      DynamicScrutineeType
+   *
+   *  If `PatternType` is not a subtype of `StaticScrutineeType, there's no information to be gained.
+   *  Now let's say we can prove that `PatternType <: StaticScrutineeType`.
+   *
+   *            StaticScrutineeType
+   *                  |         \
+   *                  |          \
+   *                  |           \
+   *                  |            PatternType
+   *                  |          /
+   *               DynamicScrutineeType
+   *
+   *  What can we say about the relationship of parameter types between `PatternType` and
+   *  `DynamicScrutineeType`?
+   *
+   *   - If `DynamicScrutineeType` refines the type parameters of `StaticScrutineeType`
+   *     in the same way as `PatternType`, the subtype test `PatternType <:< StaticScrutineeType`
+   *     tells us all we need to know.
+   *   - Otherwise, if variant refinement is a possibility we can only make predictions
+   *     about invariant parameters of `StaticScrutineeType`. Hence we do a subtype test
+   *     where `PatternType <: widenVariantParams(StaticScrutineeType)`, where `widenVariantParams`
+   *     replaces all type argument of variant parameters with empty bounds.
+   */
+  def constrainPatternType(tp: Type, pt: Type)(implicit ctx: Context) = {
+    def refinementIsInvariant(tp: Type): Boolean = tp match {
+      case tp: ClassInfo => tp.cls.is(Final) || tp.cls.is(Case)
+      case tp: TypeProxy => refinementIsInvariant(tp.underlying)
+      case tp: AndOrType => refinementIsInvariant(tp.tp1) && refinementIsInvariant(tp.tp2)
+      case _ => false
+    }
+
+    def widenVariantParams = new TypeMap {
+      def apply(tp: Type) = mapOver(tp) match {
+        case tp @ AppliedType(tycon, args) =>
+          val args1 = args.zipWithConserve(tycon.typeParams)((arg, tparam) =>
+            if (tparam.paramVariance != 0) TypeBounds.empty else arg
+          )
+          tp.derivedAppliedType(tycon, args1)
+        case tp =>
+          tp
+      }
+    }
+
+    val widePt = if (ctx.scala2Mode || refinementIsInvariant(tp)) pt else widenVariantParams(pt)
+    (tp <:< widePt)(ctx.addMode(Mode.GADTflexible))
+  }
+
   /** The list of uninstantiated type variables bound by some prefix of type `T` which
    *  occur in at least one formal parameter type of a prefix application.
    *  Considered prefixes are:

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -569,7 +569,7 @@ class Typer extends Namer
       def typedTpt = checkSimpleKinded(typedType(tree.tpt))
       def handlePattern: Tree = {
         val tpt1 = typedTpt
-        if (!ctx.isAfterTyper) tpt1.tpe.<:<(pt)(ctx.addMode(Mode.GADTflexible))
+        if (!ctx.isAfterTyper) constrainPatternType(tpt1.tpe, pt)
         // special case for an abstract type that comes with a class tag
         tryWithClassTag(ascription(tpt1, isWildcard = true), pt)
       }

tests/neg/i3989a.scala

@@ -0,0 +1,10 @@
+object Test extends App {
+  trait A[+X]
+  class B[+X](val x: X) extends A[X]
+  class C[+X](x: Any) extends B[Any](x) with A[X]
+  def f(a: A[Int]): Int = a match {
+    case a: B[_] => a.x // error
+    case _ => 0
+  }
+  f(new C[Int]("foo"))
+}

tests/pos/t3880.scala

@@ -1,11 +1,12 @@
 abstract class Bar[+B] {
 }
-abstract class C1[+B] extends Bar[B] {
+final class C1[+B] extends Bar[B] {
   private[this] def g(x: C1[B]): Unit = ()
 
   // this method is fine: notice that it allows the call to g,
   // which requires C1[B], even though we matched on C1[_].
-  // (That is good news.)
+  // (That is good news, but is sound only because C1 is final; see #3989
+  // and compare with i3989a.scala.
   private[this] def f1(x: Bar[B]): Unit = x match {
     case x: C1[_] => g(x)
   }

tests/pos/t6084.scala

@@ -1,11 +1,14 @@
 package object foo { type X[T, U] = (T => U) }
 
 package foo {
-  abstract class Foo[T, U](val d: T => U) extends (T => U) {
+  // Note that Foo must be final because of #3989.
+  final class Foo[T, U](val d: T => U) extends (T => U) {
     def f1(r: X[T, U])           = r match { case x: Foo[_,_] => x.d }  // inferred ok
     def f2(r: X[T, U]): (T => U) = r match { case x: Foo[_,_] => x.d }  // dealiased ok
     def f3(r: X[T, U]): X[T, U]  = r match { case x: Foo[_,_] => x.d }  // alias not ok
 
+    def apply(x: T): U = d(x)
+
     // x.d : foo.this.package.type.X[?scala.reflect.internal.Types$NoPrefix$?.T, ?scala.reflect.internal.Types$NoPrefix$?.U] ~>scala.this.Function1[?scala.reflect.internal.Types$NoPrefix$?.T, ?scala.reflect.internal.Types$NoPrefix$?.U]
     //  at scala.Predef$.assert(Predef.scala:170)
     //  at scala.tools.nsc.Global.assert(Global.scala:235)