Fix #9171: treat _ as _:Any in isMatchTypeShaped

Author: OlivierBlanvillain

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

@@ -4755,6 +4755,14 @@ object Types {
   object MatchType {
     def apply(bound: Type, scrutinee: Type, cases: List[Type])(using Context): MatchType =
       unique(new CachedMatchType(bound, scrutinee, cases))
+
+    /** Extractor for `case _ =>` match type patterns */
+    object WildcardPattern {
+      def unapply(tp: Type)(using Context): Option[Type] = tp match {
+        case HKTypeLambda(LambdaParam(tl1, 0) :: Nil, defn.MatchCase(TypeParamRef(tl2, 0), bodyTp)) => Some(bodyTp)
+        case _ => None
+      }
+    }
   }
 
   // ------ ClassInfo, Type Bounds --------------------------------------------------

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

@@ -1546,6 +1546,13 @@ class Typer extends Namer
                 val Typed(_, tpt) = tpd.unbind(tpd.unsplice(pat1))
                 instantiateMatchTypeProto(pat1, pt) match {
                   case defn.MatchCase(patternTp, _) => tpt.tpe frozen_=:= patternTp
+                  case MatchType.WildcardPattern(_) => tpt.tpe frozen_=:= defn.AnyType
+                  case _ => false
+                }
+              case (id @ Ident(nme.WILDCARD), pt) =>
+                pt match {
+                  case defn.MatchCase(patternTp, _) => defn.AnyType frozen_=:= patternTp
+                  case MatchType.WildcardPattern(_) => true
                   case _ => false
                 }
               case _ => false
@@ -1657,6 +1664,7 @@ class Typer extends Namer
     def caseRest(pat: Tree)(using Context) = {
       val pt1 = instantiateMatchTypeProto(pat, pt) match {
         case defn.MatchCase(_, bodyPt) => bodyPt
+        case MatchType.WildcardPattern(bodyPt) => bodyPt
         case pt => pt
       }
       val pat1 = indexPattern(tree).transform(pat)

tests/pos/unify-wildcard-patterns.scala

@@ -7,7 +7,17 @@ object Test0 {
   def m[X](x: X): M[X] = x match { case _: String => 1  case _: Any => "s" }
 }
 
+object Test1 {
+  type M[X] =            X match { case String => Int   case Any => String }
+  def m[X](x: X): M[X] = x match { case _: String => 1  case _ => "s"      }
+}
+
 object Test2 {
   type M[X] =            X match { case String => Int   case _ => String   }
   def m[X](x: X): M[X] = x match { case _: String => 1  case _: Any => "s" }
 }
+
+object Test3 {
+  type M[X] =            X match { case String => Int   case _ => String   }
+  def m[X](x: X): M[X] = x match { case _: String => 1  case _ => "s"      }
+}