Fix bias in ConstraintHandling#subsumes

Author: abgruszecki

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

@@ -345,7 +345,7 @@ trait ConstraintHandling[AbstractContext] {
     else {
       val saved = constraint
       try
-        c2.forallParams(p =>
+        pre.forallParams(p =>
           c1.contains(p) &&
           c2.upper(p).forall(c1.isLess(p, _)) &&
           isSubTypeWhenFrozen(c1.nonParamBounds(p), c2.nonParamBounds(p)))

tests/buffer.scala

@@ -0,0 +1,38 @@
+object buffer {
+  // def bar[T, TT >: T <: T, U](tt: TT): TT = {
+  //   val u: U = ???
+  //   (0 : Int) match {
+  //     case _: u.type =>
+  //       val i: Int = (??? : U) // error
+  //       // morally not an error
+  //       // val i2: Int = u
+  //       tt
+  //   }
+  // }
+
+  enum SUB[A, +B] { case Refl[T]() extends SUB[T, T] }
+
+  def baz[T](t: T, sub1: 5 SUB T, sub2: 6 SUB T): T = {
+    (sub1, sub2) match {
+      case (SUB.Refl(), SUB.Refl()) =>
+        val _t: T = (5 : 5)
+        ???
+    }
+  }
+
+  // def bazfoo[T](t: T, sub1: 5 SUB T, sub2: 6 SUB T, sub3: String SUB T): T = {
+  //   (sub1, sub2, sub3) match {
+  //     case (SUB.Refl(), SUB.Refl(), SUB.Refl()) =>
+  //       val _t: T = (5 : 5)
+  //       ???
+  //   }
+  // }
+
+  // def bazbar[T](t: T, sub1: String SUB T, sub2: 5 SUB T, sub3: 6 SUB T): T = {
+  //   (sub1, sub2, sub3) match {
+  //     case (SUB.Refl(), SUB.Refl(), SUB.Refl()) =>
+  //       val _t: T = (5 : 5)
+  //       ???
+  //   }
+  // }
+}

tests/buffer2.scala

@@ -0,0 +1,28 @@
+object buffer2 {
+  class SubInt[T <: Int]
+  type SubIntStruct = { type Z <: Int }
+
+  object Unapp {
+    def unapply[T <: Int & String](t: SubInt[T]): Boolean = false
+  }
+
+  def foo[A](a: A) = a match {
+    case Unapp() => 0
+  }
+
+  def bar = "abc" match {
+    case (1, 2) => 0
+    case _ => 1
+  }
+
+  def baz(list: List[String] | List[Int]) = list match {
+    case (x : String) :: xs =>
+      val xs2: List[String] = xs
+      ()
+    case (x : Int) :: xs =>
+      val xs2: List[Int] = xs
+      ()
+    case Nil =>
+      ()
+  }
+}

tests/buffer3.scala

@@ -0,0 +1,41 @@
+  /** Natural transformation. */
+  trait ~>[F[_], G[_]] {
+    def apply[A](fa: F[A]): G[A]
+  }
+
+  /** Higher-kinded pattern functor typeclass. */
+  trait HFunctor[H[f[_], i]] {
+    def hmap[A[_], B[_]](nt: A ~> B): ([x] => H[A,x]) ~> ([x] => H[B,x]) 
+  }
+
+  /** Some HK pattern functor. */
+  // enum ExprF[R[_],I] {
+  //   case Const[R[_]](i: Int) extends ExprF[R,Int]
+  //   case Neg[R[_]](l: R[Int]) extends ExprF[R,Int]
+  //   case Eq[R[_]](l: R[Int], r: R[Int]) extends ExprF[R,Boolean]
+  // }
+
+  sealed trait ExprF[R[_],I]
+    final case class Const[R[_]](i: Int) extends ExprF[R,Int]
+    final case class Foo[T](t: T) extends ExprF[Option, T]
+    final case class Neg[R[_]](l: R[Int]) extends ExprF[R,Int]
+    final case class Eq[R[_]](l: R[Int], r: R[Int]) extends ExprF[R,Boolean]
+  
+  object X {
+    val x = (??? : Neg[Option])._1
+  }
+
+  /** Companion. */
+  object ExprF {
+    implied hfunctor for HFunctor[ExprF] {
+      def hmap[A[_], B[_]](nt: A ~> B): ([x] => ExprF[A,x]) ~> ([x] => ExprF[B,x]) = {
+        new ~>[[x] => ExprF[A,x], [x] => ExprF[B,x]] {
+          def apply[I](fa: ExprF[A,I]): ExprF[B,I] = fa match {
+            case Const(i) => Const(i)
+            case Neg(l) => Neg(nt(l))
+            case Eq(l, r) => Eq(nt(l), nt(r))
+          }
+        }
+      }
+    } 
+  }

tests/buffer4.scala

@@ -0,0 +1,21 @@
+object Test {
+sealed trait Nat
+case class Zero() extends Nat
+case class Succ[N <: Nat](pred: N) extends Nat
+
+sealed trait Vec[A, N <: Nat]
+case class Cons[A, N <: Nat](head: A, tail: Vec[A, N]) extends Vec[A, Succ[N]]
+case class Nil[A]() extends Vec[A, Zero]
+
+  def size[A, N <: Nat](xs: Vec[A, N]): N =
+    xs match {
+      case xs: Nil[A]     => Zero()
+      case xs: Cons[A, m] => Succ(size(xs.tail))
+    }
+
+  def replicate[A, N <: Nat & Product](n: N, a: A): Vec[A, N] =
+    n match {
+      case n: Zero => Nil[A]()
+      case n: Succ[m] => Cons[A, m](a, replicate(n.pred, a))
+    }
+}

tests/bufferR.scala

@@ -0,0 +1,16 @@
+object Regions {
+  class Region
+
+  class Cell[A, R <: Region](init: A) {
+    private[this] var store: A = init
+    def update(a: A) given R: Unit = store = a
+    def apply() given R: A = store
+  }
+
+  def cell[A](init: A) given (r: Region): Cell[A, r.type] =
+    new Cell[A, r.type](init)
+
+  def enter[T](thunk: given Region => T): T = {
+    thunk given new Region
+  }
+}

tests/candidate.scala

@@ -0,0 +1,36 @@
+object Test {
+  def bar[U](u: U): U =
+    (0 : Int) match {
+      case _: u.type =>
+        val i: Int = (??? : U) // error
+        // morally not an error
+        // val i2: Int = u
+        U
+    }
+
+  enum SUB[A, +B] { case Refl[T]() extends SUB[T, T] }
+
+  def baz[T](t: T, sub1: 5 SUB T, sub2: 6 SUB T): T = {
+    (sub1, sub2) match {
+      case (SUB.Refl(), SUB.Refl()) =>
+        val _t: T = (5 : 5)
+        ???
+    }
+  }
+
+  def bazfoo[T](t: T, sub1: 5 SUB T, sub2: 6 SUB T, sub3: String SUB T): T = {
+    (sub1, sub2, sub3) match {
+      case (SUB.Refl(), SUB.Refl(), SUB.Refl()) =>
+        val _t: T = (5 : 5)
+        ???
+    }
+  }
+
+  def bazbar[T](t: T, sub1: String SUB T, sub2: 5 SUB T, sub3: 6 SUB T): T = {
+    (sub1, sub2, sub3) match {
+      case (SUB.Refl(), SUB.Refl(), SUB.Refl()) =>
+        val _t: T = (5 : 5)
+        ???
+    }
+  }
+}

tests/destructuring-var.scala

@@ -0,0 +1,4 @@
+object `destructuring-var` {
+  var Some(z) = Some(0)
+  var a :: b :: Nil = 1 :: 2 :: Nil
+}

tests/neg/overconstrained-type-variables-gadt.scala

@@ -2,16 +2,26 @@ object Test {
   trait T1[A] { def a: A }
   trait T2[B] { def b: B }
 
-  def foo[X, Y](u: T1[X] | T2[Y]): X = u match {
+  def foo[X, Y](v: T1[X] | T2[Y]): X = v match {
     case t1: T1[t] =>
       // consider: foo[Int, String](new T1[String] with T2[String] { ... })
       t1.a // error
   }
 
   class T1Int extends T1[Int] { def a = 0 }
-  def bar[X, Y](u: T1[X] | T2[Y]): X = u match {
+  def bar[X, Y](v: T1[X] | T2[Y]): X = v match {
     case t1: T1Int =>
       // similar reasoning to above applies
       t1.a // error
   }
+
+  class T1IntT2String extends T1[Int] with T2[String] {
+    def a = 0
+    def b = ""
+  }
+  def baz[X](v: T1[X] | T2[X]): Unit = v match {
+    case _: T1IntT2String =>
+      val x1: X = 0 // error
+      val x2: X = "" // error
+  }
 }