Make use of banning to do more GADT reasoning

Specifically, now that "weird" classes can't be defined we can finally
assume that if `A[T]` matches `B[y]` then `y <: T` / `y >: T`
(covariance/contravariance).

Author: dwijnand

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

@@ -218,21 +218,11 @@ trait PatternTypeConstrainer { self: TypeComparer =>
   def constrainSimplePatternType(patternTp: Type, scrutineeTp: Type, forceInvariantRefinement: Boolean): Boolean = {
     def refinementIsInvariant(tp: Type): Boolean = tp match {
       case tp: SingletonType => true
-      case tp: ClassInfo => tp.cls.is(Final) || tp.cls.is(Case)
+      case tp: ClassInfo => !tp.cls.isOneOf(AbstractOrTrait)
       case tp: TypeProxy => refinementIsInvariant(tp.underlying)
       case _ => false
     }
 
-    def widenVariantParams(tp: Type) = tp match {
-      case tp @ AppliedType(tycon, args) =>
-        val args1 = args.zipWithConserve(tycon.typeParams)((arg, tparam) =>
-          if (tparam.paramVarianceSign != 0) TypeBounds.empty else arg
-        )
-        tp.derivedAppliedType(tycon, args1)
-      case tp =>
-        tp
-    }
-
     val patternCls = patternTp.classSymbol
     val scrutineeCls = scrutineeTp.classSymbol
 
@@ -243,8 +233,7 @@ trait PatternTypeConstrainer { self: TypeComparer =>
     val pt = if upcastPattern then patternTp.baseType(scrutineeCls) else patternTp
     val tp = if !upcastPattern then scrutineeTp.baseType(patternCls) else scrutineeTp
 
-    val assumeInvariantRefinement =
-      migrateTo3 || forceInvariantRefinement || refinementIsInvariant(patternTp)
+    val assumeInvariantRefinement = migrateTo3 || refinementIsInvariant(patternTp)
 
     trace(i"constraining simple pattern type $tp >:< $pt", gadts, res => s"$res\ngadt = ${ctx.gadt.debugBoundsDescription}") {
       (tp, pt) match {
@@ -265,8 +254,8 @@ trait PatternTypeConstrainer { self: TypeComparer =>
                 isSubType(SkolemType(patternTp), scrutineeTp)
               else {
                 var res = true
-                if variance <  1 then res &&= isSubType(argS, argP)
-                if variance > -1 then res &&= isSubType(argP, argS)
+                if variance <  1 || forceInvariantRefinement then res &&= isSubType(argS, argP)
+                if variance > -1 || forceInvariantRefinement then res &&= isSubType(argP, argS)
                 res
               }
             }

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

@@ -842,8 +842,9 @@ object RefChecks {
           tycon.typeParams.lazyZip(args1).lazyZip(args2).forall { (param, arg1, arg2) =>
             if superArgs.contains(arg1) then
               val variance = param.paramVarianceSign
-              (variance > 0 || arg2 <:< arg1) &&
-              (variance < 0 || arg1 <:< arg2)
+              if      variance == 0 then arg1 =:= arg2
+              else if variance > 0  then arg1 <:< arg2
+              else                       arg2 <:< arg1
             else
               // class Foo; class Bar
               // trait E[L] extends A[Foo]             // combinedBT: A[Foo]

tests/neg-custom-args/fatal-warnings/type-test-syntesize.scala

@@ -15,8 +15,8 @@ object Test {
   test[Any, String]
   test[Any, Some[_]]
   test[Any, Array[Int]]
-  test[Seq[Int], List[Int]]
 
+  test[Seq[Int], List[Int]] // error
   test[Any, Some[Int]] // error
   test[Any, a.X] // error
   test[a.X, a.Y] // error

tests/neg-custom-args/isInstanceOf/gadt.scala

@@ -8,7 +8,7 @@ object Test1 {
   class DummyTree extends JavaSeqLiteral[Any]
 
   def foo1(tree: Tree[Type]) =
-    tree.isInstanceOf[JavaSeqLiteral[Type]]   // error
+    tree.isInstanceOf[JavaSeqLiteral[Type]]
 
   foo1(new DummyTree)
 }
@@ -26,4 +26,4 @@ object Test2 {
     tree.isInstanceOf[JavaSeqLiteral[Type]]
 
   foo1(new DummyTree)
-}
+}

tests/disabled/pos-special/3324g.scala renamed to tests/pos-special/3324g.scala

@@ -1,37 +1,13 @@
-sealed trait Exp[T]
-case class Num(n: Int) extends Exp[Int]
-case class Plus(e1: Exp[Int], e2: Exp[Int]) extends Exp[Int]
-case class Var[T](name: String) extends Exp[T]
-case class Lambda[T, U](x: Var[T], e: Exp[U]) extends Exp[T => U]
-case class App[T, U](f: Exp[T => U], e: Exp[T]) extends Exp[U]
+class Test {
+  trait A[+T]
+  class B[T] extends A[T]
 
-abstract class Env { outer =>
-  def apply[T](x: Var[T]): T
+  class C
+  class D extends C
 
-  def + [T](xe: (Var[T], T)) = new Env {
-    def apply[T](x: Var[T]): T =
-      if (x == xe._1) xe._2.asInstanceOf[T]
-      else outer(x)
-  }
-}
-
-object Env {
-  val empty = new Env {
-    def apply[T](x: Var[T]): T = ???
-  }
-}
-
-object Test {
-
-  val exp = App(Lambda(Var[Int]("x"), Plus(Var[Int]("x"), Num(1))), Var[Int]("2"))
-
-  def eval[T](e: Exp[T])(env: Env): T = e match {
-    case Num(n) => n
-    case Plus(e1, e2) => eval(e1)(env) + eval(e2)(env)
-    case v: Var[T] => env(v)
-    case Lambda(x: Var[s], e) => ((y: s) => eval(e)(env + (x -> y)))
-    case App(f, e) => eval(f)(env)(eval(e)(env))
+  def quux(a: A[C]): Unit = a match {
+    case _: B[C] =>
   }
 
-  eval(exp)(Env.empty)
+  quux(new B[D])
 }

tests/neg-custom-args/isInstanceOf/JavaSeqLiteral.scala renamed to tests/pos-special/isInstanceOf/JavaSeqLiteral.scala

@@ -5,8 +5,8 @@ class Dummy extends Bar[Nothing] with Foo[String]
 
 def bugReport[A](foo: Foo[A]): Foo[A] =
   foo match {
-    case bar: Bar[A] => bar    // error
+    case bar: Bar[A] => bar
     case dummy: Dummy => ???
   }
 
-def test = bugReport(new Dummy: Foo[String])
+def test = bugReport(new Dummy: Foo[String])