Compile quote patterns directly into QuotePattern AST

Fixes #18125

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -381,7 +381,7 @@ object desugar {
     tree match
       case untpd.Block(stats, expr) =>
         val (untpdTypeVariables, otherStats) = stats.span {
-          case tdef @ untpd.TypeDef(name, _) => name.isVarPattern
+          case tdef @ untpd.TypeDef(name, _) => !tdef.isBackquoted && name.isVarPattern
           case _ => false
         }
         val pattern = if otherStats.isEmpty then expr else untpd.cpy.Block(tree)(otherStats, expr)

compiler/src/dotty/tools/dotc/quoted/QuotePatterns.scala

@@ -15,6 +15,7 @@ import dotty.tools.dotc.core.NameKinds.PatMatGivenVarName
 import dotty.tools.dotc.core.Names.*
 import dotty.tools.dotc.core.StdNames.*
 import dotty.tools.dotc.core.Symbols.*
+import dotty.tools.dotc.core.TypeOps.*
 import dotty.tools.dotc.core.Types.*
 import dotty.tools.dotc.reporting.IllegalVariableInPatternAlternative
 import dotty.tools.dotc.transform.SymUtils._
@@ -24,6 +25,33 @@ import scala.collection.mutable
 object QuotePatterns:
   import tpd._
 
+  /** Check for restricted patterns */
+  def checkPattern(quotePattern: QuotePattern)(using Context): Unit = new tpd.TreeTraverser {
+    def traverse(tree: Tree)(using Context): Unit = tree match {
+      case _: SplicePattern =>
+      case tdef: TypeDef if tdef.symbol.isClass =>
+        val kind = if tdef.symbol.is(Module) then "objects" else "classes"
+        report.error(em"Implementation restriction: cannot match $kind", tree.srcPos)
+      case tree: NamedDefTree =>
+        if tree.name.is(NameKinds.WildcardParamName) then
+          report.warning(
+            "Use of `_` for lambda in quoted pattern. Use explicit lambda instead or use `$_` to match any term.",
+            tree.srcPos)
+        if tree.name.isTermName && !tree.nameSpan.isSynthetic && tree.name != nme.ANON_FUN && tree.name.startsWith("$") then
+          report.error("Names cannot start with $ quote pattern", tree.namePos)
+        traverseChildren(tree)
+      case _: Match =>
+        report.error("Implementation restriction: cannot match `match` expressions", tree.srcPos)
+      case _: Try =>
+        report.error("Implementation restriction: cannot match `try` expressions", tree.srcPos)
+      case _: Return =>
+        report.error("Implementation restriction: cannot match `return` statements", tree.srcPos)
+      case _ =>
+        traverseChildren(tree)
+    }
+
+  }.traverse(quotePattern.body)
+
   /** Encode the quote pattern into an `unapply` that the pattern matcher can handle.
    *
    *  A quote pattern

tests/neg-macros/i6997b.scala

@@ -5,7 +5,7 @@ import scala.quoted.*
 inline def mcr(x: => Any): Any = ${mcrImpl('x)}
 
 def mcrImpl(body: Expr[Any])(using ctx: Quotes): Expr[Any] = {
-  val '{$x: $t} = body // error
+  val '{$x: $t} = body // error // error
   '{
     val tmp: $t = $x.asInstanceOf[$t] // error // error
     println(tmp)

tests/pos-macros/i18125.scala

@@ -0,0 +1,10 @@
+import scala.quoted.*
+
+final class Foo[T](ns: T)
+
+def foo(using Quotes)(x: Expr[Any]): Unit =
+  x match
+    case '{ new Foo($y: b) } =>
+    case '{ new Foo($y: List[b]) } =>
+    case '{ type b; new Foo($y: b) } =>
+

tests/pos-macros/i18125b.scala

@@ -0,0 +1,23 @@
+package oolong.phobos
+
+import scala.quoted.*
+import scala.compiletime.*
+import scala.annotation.StaticAnnotation
+
+final class xmlns[T](ns: T) extends StaticAnnotation
+trait Namespace[T]{
+    val getNamespace: String
+}
+
+object common{
+  private def extractFeildNamespace(using Quotes)(
+      fieldAnnotations: List[Expr[Any]],
+  ): Expr[Option[String]] = {
+    import quotes.reflect.*
+
+    fieldAnnotations.collect { case '{ xmlns($namespace: b) } =>
+      '{ Some(summonInline[Namespace[b]].getNamespace) }
+    }
+    ???
+  }
+}

tests/pos-macros/mirrorQuotePattern.scala

@@ -0,0 +1,11 @@
+import scala.deriving._
+import scala.quoted._
+
+private def derivedExpr[T](mirrorExpr: Expr[Mirror.Of[T]])(using Quotes, Type[T]): Expr[Any] = {
+  mirrorExpr match {
+    case '{ $mirrorExpr : Mirror.Sum { type MirroredElemTypes = mirroredElemTypes } } =>
+      '{ liftableSum[mirroredElemTypes]($mirrorExpr) }
+  }
+}
+
+def liftableSum[MElemTypes](mirror: Mirror.Sum { type MirroredElemTypes = MElemTypes }): Any = ???