fix(patmat): Add subtype-based fallback in inferPrefixMap and recalculate constraints after application (#23771)

fix #23369

1. Add fallback logic in inferPrefixMap that uses subtype relationships
to find a singleton when an exact match cannot be found
2. Ensure that constraints are calculated after applying inferPrefixMap

Author: noti0na1

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

@@ -830,9 +830,13 @@ object TypeOps:
           prefixTVar.uncheckedNN
         case ThisType(tref) if !tref.symbol.isStaticOwner =>
           val symbol = tref.symbol
+          val compatibleSingleton = singletons.valuesIterator.find(_.underlying.derivesFrom(symbol))
           if singletons.contains(symbol) then
             prefixTVar = singletons(symbol) // e.g. tests/pos/i16785.scala, keep Outer.this
             prefixTVar.uncheckedNN
+          else if compatibleSingleton.isDefined then
+            prefixTVar = compatibleSingleton.get
+            prefixTVar.uncheckedNN
           else if symbol.is(Module) then
             TermRef(this(tref.prefix), symbol.sourceModule)
           else if (prefixTVar != null)
@@ -930,10 +934,11 @@ object TypeOps:
     }
 
     val inferThisMap = new InferPrefixMap
-    val tvars = tp1.etaExpand match
+    val prefixInferredTp = inferThisMap(tp1)
+    val tvars = prefixInferredTp.etaExpand match
       case eta: TypeLambda => constrained(eta)
       case _               => Nil
-    val protoTp1 = inferThisMap.apply(tp1).appliedTo(tvars)
+    val protoTp1 = prefixInferredTp.appliedTo(tvars)
 
     if gadtSyms.nonEmpty then
       ctx.gadtState.addToConstraint(gadtSyms)

tests/warn/i23369.scala

@@ -0,0 +1,26 @@
+class Module {
+  type BarTy
+  sealed trait Adt[A]
+  case class Foo() extends Adt[String]
+  case class Bar[A <: BarTy](x: BarTy) extends Adt[A]
+}
+
+object Basic extends Module {
+  type BarTy = String
+}
+
+def test(a: Basic.Adt[String]) = {
+  a match { // warn: match may not be exhaustive
+    case Basic.Foo() =>
+  }
+}
+
+object Basic2 extends Module {
+  type BarTy = Int
+}
+
+def test2(a: Basic2.Adt[String]) = {
+  a match {
+    case Basic2.Foo() =>
+  }
+}