Fix quote pattern irrefutability checks

Author: nicolasstucki

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

@@ -305,23 +305,13 @@ object SpaceEngine {
   }
 
   /** Is this an `'{..}` or `'[..]` irrefutable quoted patterns?
-   *  @param  unapp The unapply function tree
-   *  @param  implicits The implicits of the unapply
-   *  @param  pt The scrutinee type
+   *  @param  body The body of the quoted pattern
+   *  @param  bodyPt The scrutinee body type
    */
-  def isIrrefutableQuotedPattern(unapp: tpd.Tree, implicits: List[tpd.Tree], pt: Type)(using Context): Boolean = {
-    implicits.headOption match
-      // pattern '{ $x: T }
-      case Some(tpd.Apply(tpd.Select(tpd.Quote(tpd.TypeApply(fn, List(tpt)), _), nme.apply), _))
-          if unapp.symbol.owner.eq(defn.QuoteMatching_ExprMatchModule)
-          && fn.symbol.eq(defn.QuotedRuntimePatterns_patternHole) =>
-        pt <:< defn.QuotedExprClass.typeRef.appliedTo(tpt.tpe)
-
-      // pattern '[T]
-      case Some(tpd.Apply(tpd.TypeApply(fn, List(tpt)), _))
-          if unapp.symbol.owner.eq(defn.QuoteMatching_TypeMatchModule) =>
-        pt =:= defn.QuotedTypeClass.typeRef.appliedTo(tpt.tpe)
-
+  def isIrrefutableQuotePattern(pat: tpd.QuotePattern, pt: Type)(using Context): Boolean = {
+    if pat.body.isType then pat.bindings.isEmpty && pt =:= pat.tpe
+    else pat.body match
+      case _: SplicePattern => pat.bindings.isEmpty && pt <:< pat.tpe
       case _ => false
   }
 

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

@@ -33,7 +33,7 @@ import NameOps._
 import SymDenotations.{NoCompleter, NoDenotation}
 import Applications.unapplyArgs
 import Inferencing.isFullyDefined
-import transform.patmat.SpaceEngine.{isIrrefutable, isIrrefutableQuotedPattern}
+import transform.patmat.SpaceEngine.{isIrrefutable, isIrrefutableQuotePattern}
 import config.Feature
 import config.Feature.sourceVersion
 import config.SourceVersion._
@@ -846,19 +846,15 @@ trait Checking {
           val problem = if pat.tpe <:< reportedPt then "is more specialized than" else "does not match"
           em"pattern's type ${pat.tpe} $problem the right hand side expression's type $reportedPt"
         case RefutableExtractor =>
-          val extractor =
-            val UnApply(fn, _, _) = pat: @unchecked
-            tpd.funPart(fn) match
-              case Select(id, _) => id
-              case _ => EmptyTree
-          if extractor.isEmpty then
-            em"pattern binding uses refutable extractor"
-          else if extractor.symbol eq defn.QuoteMatching_ExprMatch then
-            em"pattern binding uses refutable extractor `'{...}`"
-          else if extractor.symbol eq defn.QuoteMatching_TypeMatch then
-            em"pattern binding uses refutable extractor `'[...]`"
-          else
-            em"pattern binding uses refutable extractor `$extractor`"
+          val extractor = pat match
+            case UnApply(fn, _, _) =>
+              tpd.funPart(fn) match
+                case Select(id, _) if !id.isEmpty => id.show
+                case _ => ""
+            case QuotePattern(_, body, _) =>
+              if body.isTerm then "'{...}" else "'[...]"
+          if extractor.isEmpty then em"pattern binding uses refutable extractor"
+          else em"pattern binding uses refutable extractor `$extractor`"
 
       val fix =
         if isPatDef then "adding `: @unchecked` after the expression"
@@ -897,7 +893,7 @@ trait Checking {
             recur(pat1, pt)
           case UnApply(fn, implicits, pats) =>
             check(pat, pt) &&
-            (isIrrefutable(fn, pats.length) || isIrrefutableQuotedPattern(fn, implicits, pt) || fail(pat, pt, Reason.RefutableExtractor)) && {
+            (isIrrefutable(fn, pats.length) || fail(pat, pt, Reason.RefutableExtractor)) && {
               val argPts = unapplyArgs(fn.tpe.widen.finalResultType, fn, pats, pat.srcPos)
               pats.corresponds(argPts)(recur)
             }
@@ -907,6 +903,8 @@ trait Checking {
             check(pat, pt) && recur(arg, pt)
           case Ident(nme.WILDCARD) =>
             true
+          case pat: QuotePattern =>
+            isIrrefutableQuotePattern(pat, pt) || fail(pat, pt, Reason.RefutableExtractor)
           case _ =>
             check(pat, pt)
         }

tests/neg-custom-args/fatal-warnings/i16649-refutable.scala

@@ -2,3 +2,6 @@ import quoted.*
 
 def foo(using Quotes)(x: Expr[Int]) =
   val '{ ($y: Int) + ($z: Int) } = x // error
+  val '{ $a: Int } = x
+  val '{ $b: Any } = x
+  val '{ $c } = x