Fix #4226: allow infallible boolean extractors to return true

compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala

@@ -289,7 +289,7 @@ object PatternMatcher {
 
         if (isSyntheticScala2Unapply(unapp.symbol) && caseAccessors.length == args.length)
           matchArgsPlan(caseAccessors.map(ref(scrutinee).select(_)), args, onSuccess)
-        else if (unapp.tpe.isRef(defn.BooleanClass))
+        else if (unapp.tpe.widenSingleton.isRef(defn.BooleanClass))
           TestPlan(GuardTest, unapp, unapp.pos, onSuccess, onFailure)
         else {
           letAbstract(unapp) { unappResult =>

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -309,6 +309,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
   def irrefutable(unapp: Tree): Boolean = {
     // TODO: optionless patmat
     unapp.tpe.widen.finalResultType.isRef(scalaSomeClass) ||
+      unapp.tpe.widen.finalResultType =:= ConstantType(Constant(true)) ||
       (unapp.symbol.is(Synthetic) && unapp.symbol.owner.linkedClass.is(Case)) ||
       productArity(unapp.tpe.widen.finalResultType) > 0
   }

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

@@ -114,7 +114,7 @@ object Applications {
         productSelectorTypes(unapplyResult)
       else if (isGetMatch(unapplyResult, pos))
         getUnapplySelectors(getTp, args, pos)
-      else if (unapplyResult isRef defn.BooleanClass)
+      else if (unapplyResult.widenSingleton isRef defn.BooleanClass)
         Nil
       else if (defn.isProductSubType(unapplyResult))
         productSelectorTypes(unapplyResult)

tests/patmat/i4226.check

@@ -0,0 +1 @@
+11: Pattern Match Exhaustivity: Just(_)

tests/patmat/i4226.scala

@@ -0,0 +1,15 @@
+sealed abstract class Maybe[A]
+final case class Just[A](a: A) extends Maybe[A]
+class Empty[A] extends Maybe[A]
+object Empty {
+  def apply[A](): Maybe[A] = new Empty[A]
+  def unapply[A](e: Empty[A]): true = true
+}
+
+object Test {
+  val a: Maybe[Int] = Just(2)
+  def main(args: Array[String]): Unit = a match {
+    case Just(2) => true
+    case Empty() =>
+  }
+}

tests/patmat/i4226b.check

@@ -0,0 +1 @@
+11: Pattern Match Exhaustivity: _: Empty, Just(_)

tests/patmat/i4226b.scala

@@ -0,0 +1,15 @@
+sealed abstract class Maybe[A]
+final case class Just[A](a: A) extends Maybe[A]
+class Empty[A] extends Maybe[A]
+object Empty {
+  def apply[A](): Maybe[A] = new Empty[A]
+  def unapply[A](e: Empty[A]): false = false
+}
+
+object Test {
+  val a: Maybe[Int] = Just(2)
+  def main(args: Array[String]): Unit = a match {
+    case Just(2) => true
+    case Empty() =>
+  }
+}