Use upper bound of abstract types in exhaustivity checking (scala#23909)

closes scala#23620,
scala#24246

If the upper bound of an abstract type is not `sealed` but is
effectively sealed, it is not handled correctly, since classSym could
return a type that is not `sealed` (Object in the issue above).
If the type were not abstract, it would pass the logic that checks
whether it is an Or, And, etc., and would be handled properly.
This PR makes exhaustivity checking use the upper bound of abstract
types that are effectively sealed.

---------

Co-authored-by: Zieliński Patryk <75637004+zielinsky@users.noreply.github.com>

Author: 2 people

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

@@ -687,6 +687,8 @@ object SpaceEngine {
           else NoType
         }.filter(_.exists)
         parts
+      case tref: TypeRef if tref.isUpperBoundedAbstract =>
+        rec(tref.info.hiBound, mixins)
       case _ => ListOfNoType
     end rec
 
@@ -702,6 +704,10 @@ object SpaceEngine {
         && !cls.hasAnonymousChild       // can't name anonymous classes as counter-examples
         && cls.children.nonEmpty        // can't decompose without children
 
+  extension (tref: TypeRef)
+    def isUpperBoundedAbstract(using Context): Boolean =
+      tref.symbol.isAbstractOrAliasType && !tref.info.hiBound.isNothingType
+
   val ListOfNoType    = List(NoType)
   val ListOfTypNoType = ListOfNoType.map(Typ(_, decomposed = true))
 
@@ -826,7 +832,11 @@ object SpaceEngine {
       classSym.is(Case) && {
         if seen.add(classSym) then productSelectorTypes(tpw, sel.srcPos).exists(isCheckable(_))
         else true // recursive case class: return true and other members can still fail the check
-      }
+      } ||
+      (tpw.isInstanceOf[TypeRef] && {
+        val tref = tpw.asInstanceOf[TypeRef]
+        tref.isUpperBoundedAbstract && isCheckable(tref.info.hiBound)
+      })
 
     !sel.tpe.hasAnnotation(defn.UncheckedAnnot)
     && {

tests/pos/i23620.scala

@@ -0,0 +1,18 @@
+trait Foo
+trait Bar
+
+type FooOrBar = FooOrBar.Type
+object FooOrBar:
+  opaque type Type <: (Foo | Bar) = Foo | Bar
+
+  def bar: FooOrBar = new Bar {}
+
+trait Buz
+
+@main def main =
+  val p: FooOrBar | Buz = FooOrBar.bar
+
+  p match
+    case _: Foo => println("foo")
+    case _: Buz => println("buz")
+    case _: Bar => println("bar")

tests/warn/i23620b.check

@@ -0,0 +1,24 @@
+-- [E029] Pattern Match Exhaustivity Warning: tests/warn/i23620b.scala:20:2 --------------------------------------------
+20 |  p match // warn
+   |  ^
+   |  match may not be exhaustive.
+   |
+   |  It would fail on pattern case: _: Bar
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E029] Pattern Match Exhaustivity Warning: tests/warn/i23620b.scala:23:2 --------------------------------------------
+23 |  p2 match { // warn
+   |  ^^
+   |  match may not be exhaustive.
+   |
+   |  It would fail on pattern case: _: Bar
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E029] Pattern Match Exhaustivity Warning: tests/warn/i23620b.scala:37:2 --------------------------------------------
+37 |  x match // warn
+   |  ^
+   |  match may not be exhaustive.
+   |
+   |  It would fail on pattern case: B
+   |
+   | longer explanation available when compiling with `-explain`

tests/warn/i23620b.scala

@@ -0,0 +1,38 @@
+trait Foo
+trait Bar
+
+type FooOrBar = FooOrBar.Type
+object FooOrBar:
+  opaque type Type <: (Foo | Bar) = Foo | Bar
+
+  def bar: FooOrBar = new Bar {}
+
+type OnlyFoo = OnlyFoo.Type
+object OnlyFoo:
+  opaque type Type <: (Foo | Bar) = Foo
+
+  def foo: OnlyFoo = new Foo {}
+
+@main def main =
+  val p: FooOrBar= FooOrBar.bar
+  val p2: OnlyFoo = OnlyFoo.foo
+
+  p match // warn
+    case _: Foo => println("foo")
+
+  p2 match { // warn
+    case _: Foo => println("foo")
+  }
+
+sealed trait S
+trait Z
+
+case object A extends S, Z
+case object B extends S, Z
+
+trait HasT:
+  type T <: S & Z
+
+def nonExhaustive(h: HasT, x: h.T) =
+  x match // warn
+    case A => ()

tests/warn/i24246.check

@@ -0,0 +1,8 @@
+-- [E029] Pattern Match Exhaustivity Warning: tests/warn/i24246.scala:8:2 ----------------------------------------------
+8 |  x match { // warn
+  |  ^
+  |  match may not be exhaustive.
+  |
+  |  It would fail on pattern case: ZZ
+  |
+  | longer explanation available when compiling with `-explain`

tests/warn/i24246.scala

@@ -0,0 +1,10 @@
+trait X
+
+sealed trait Y
+case object YY extends Y, X
+case object ZZ extends Y, X
+
+def foo[A <: X & Y](x: A): Unit =
+  x match { // warn
+    case YY => ()
+  }