Use new higher-order quasi-pattern syntax

```scala
case ${ val a = 3; ${body}{a}: Int } =>
```

Author: nicolasstucki

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

@@ -75,41 +75,13 @@ trait QuotesAndSplices {
     }
     if (ctx.mode.is(Mode.QuotedPattern))
       if (isFullyDefined(pt, ForceDegree.flipBottom)) {
-        object HigherOrderQuasipattern {
-          /** Matches a splice of the form `${<pat> $$ <args*>}` */
-          def unapply(tree: untpd.Tree): Option[(untpd.Tree, List[untpd.Tree])] =
-            tree match
-              case untpd.InfixOp(pat, untpd.Ident(nme.EXPAND_SEPARATOR), args0) =>
-                val args = args0 match
-                  case untpd.Tuple(args) => args
-                  case arg => List(arg)
-                Some((pat, args))
-              case Apply(Select(pat, nme.EXPAND_SEPARATOR), args) => Some((pat, args))
-              case _ => None
-        }
-        tree.expr match
-          case HigherOrderQuasipattern(pat, args) =>
-            val typedArgs = args.map {
-              case arg: untpd.Ident =>
-                typedExpr(arg)
-              case arg =>
-                ctx.error("Exprected an identifier", arg.sourcePos)
-                EmptyTree
-            }
-            if args.isEmpty then
-              ctx.error("Missing arguments for open pattern", tree.expr.sourcePos)
-            val argTypes = typedArgs.map(_.tpe.widenTermRefExpr)
-            val splice1 = untpd.cpy.Splice(tree)(pat).asInstanceOf[untpd.Splice]
-            val typedPat = typedSplice(splice1, defn.FunctionOf(argTypes, pt))
-            ref(defn.InternalQuoted_patternHigherOrderHole).appliedToType(pt).appliedTo(typedPat, SeqLiteral(typedArgs, TypeTree(defn.AnyType)))
-          case _ =>
-            def spliceOwner(ctx: Context): Symbol =
-              if (ctx.mode.is(Mode.QuotedPattern)) spliceOwner(ctx.outer) else ctx.owner
-            val pat = typedPattern(tree.expr, defn.QuotedExprClass.typeRef.appliedTo(pt))(
-              using spliceContext.retractMode(Mode.QuotedPattern).withOwner(spliceOwner(ctx)))
-            val baseType = pat.tpe.baseType(defn.QuotedExprClass)
-            val argType = if baseType != NoType then baseType.argTypesHi.head else defn.NothingType
-            ref(defn.InternalQuoted_exprSplice).appliedToType(argType).appliedTo(pat)
+        def spliceOwner(ctx: Context): Symbol =
+          if (ctx.mode.is(Mode.QuotedPattern)) spliceOwner(ctx.outer) else ctx.owner
+        val pat = typedPattern(tree.expr, defn.QuotedExprClass.typeRef.appliedTo(pt))(
+          using spliceContext.retractMode(Mode.QuotedPattern).withOwner(spliceOwner(ctx)))
+        val baseType = pat.tpe.baseType(defn.QuotedExprClass)
+        val argType = if baseType != NoType then baseType.argTypesHi.head else defn.NothingType
+        ref(defn.InternalQuoted_exprSplice).appliedToType(argType).appliedTo(pat)
       }
       else {
         ctx.error(i"Type must be fully defined.\nConsider annotating the splice using a type ascription:\n  ($tree: XYZ).", tree.expr.sourcePos)
@@ -151,18 +123,39 @@ trait QuotesAndSplices {
       val suggestionArgs = args match
         case arg :: Nil => arg.show
         case args => args.map(_.show).mkString("(", ", ", ")")
-      val suggestion = s"$${${splice.expr.show} $$$$ $suggestionArgs}"
+      val suggestion = s"$${${splice.expr.show}}{$suggestionArgs}"
       ctx.warning(s"""Possibly using open pattern syntax instead application pattern.
                      |If this is a open pattern replace it with $suggestion.
                      |""".stripMargin, tree.sourcePos)
-    if (isFullyDefined(pt, ForceDegree.flipBottom)) then
-      val typedArgs = args.map(arg => typedExpr(arg))
-      val argTypes = typedArgs.map(_.tpe.widenTermRefExpr)
-      val splice1 = typedSplice(splice, defn.FunctionOf(argTypes, pt))
-      Apply(splice1.select(nme.apply), typedArgs).withType(pt).withSpan(tree.span)
-    else
+    object HigherOrderQuasipatternArgs {
+      /** Matches a args of splice of the form `${body}{<args*>}` */
+      def unapply(args: List[untpd.Tree]): Option[List[untpd.Tree]] = args match
+        case Block(Nil, untpd.Tuple(args)) :: Nil => Some(args)
+        case Block(Nil, arg) :: Nil => Some(List(arg))
+        case _ => None
+    }
+    if !isFullyDefined(pt, ForceDegree.flipBottom) then
       ctx.error(i"Type must be fully defined.", splice.sourcePos)
       tree.withType(UnspecifiedErrorType)
+    else args match
+      case HigherOrderQuasipatternArgs(args) =>
+        val typedArgs = args.map {
+          case arg: untpd.Ident =>
+            typedExpr(arg)
+          case arg =>
+            ctx.error("Exprected an identifier", arg.sourcePos)
+            EmptyTree
+        }
+        if args.isEmpty then
+          ctx.error("Missing arguments for open pattern", tree.sourcePos)
+        val argTypes = typedArgs.map(_.tpe.widenTermRefExpr)
+        val typedPat = typedSplice(splice, defn.FunctionOf(argTypes, pt))
+        ref(defn.InternalQuoted_patternHigherOrderHole).appliedToType(pt).appliedTo(typedPat, SeqLiteral(typedArgs, TypeTree(defn.AnyType)))
+      case _ =>
+        val typedArgs = args.map(arg => typedExpr(arg))
+        val argTypes = typedArgs.map(_.tpe.widenTermRefExpr)
+        val splice1 = typedSplice(splice, defn.FunctionOf(argTypes, pt))
+        Apply(splice1.select(nme.apply), typedArgs).withType(pt).withSpan(tree.span)
   }
 
   /** Translate ${ t: Type[T] }` into type `t.splice` while tracking the quotation level in the context */

docs/docs/reference/metaprogramming/macros.md

@@ -757,17 +757,17 @@ then the rest of the quote can refer to this definition.
 
 To match such a term we need to match the definition and the rest of the code, but we need to expicilty state that the rest of the code may refer to this definition.
 ```scala
-case '{ val y: Int = $x; ${body $$ y}: Int } =>
+case '{ val y: Int = $x; ${body}{y}: Int } =>
 ```
-Here `$x` will match any closed expression while `${body $$ y}` will match expression that is closed under `y`. Then
+Here `$x` will match any closed expression while `${body}{y}` will match expression that is closed under `y`. Then
 the subxpression of type `Expr[Int]` is bound to `body` as an `Expr[Int => Int]`. The extra argument represents the references to `y`. Usually this expression is used in compination with `Expr.betaReduce` to replace the extra argument.
 
 ```scala
 inline def eval(inline e: Int): Int = ${ evalExpr('e) }
 
 private def evalExpr(using QuoteContext)(e: Expr[Int]): Expr[Int] = {
   e match {
-    case '{ val y: Int = $x; ${body $$ y}: Int } =>
+    case '{ val y: Int = $x; ${body}{y}: Int } =>
       // body: Expr[Int => Int] where the argument represents references to y
       evalExpr(Expr.betaReduce(body)(evalExpr(x)))
     case '{ ($x: Int) * ($y: Int) } =>
@@ -786,7 +786,7 @@ eval { // expands to the code: (16: Int)
 }
 ```
 
-We can also close over several bindings using `${b $$ (a1, a2, ..., an)}`.
+We can also close over several bindings using `${b}{(a1, a2, ..., an)}`.
 
 
 ### More details

tests/neg/quote-open-patterns-stages.scala

@@ -1,5 +1,5 @@
 import scala.quoted._
 
 def f(using QuoteContext)(x: Expr[Any]) = x match {
-  case '{ identity(${y $$ x}) } => // error: access to value x from wrong staging level
+  case '{ identity(${y}{x}) } => // error: access to value x from wrong staging level
 }

tests/neg/quote-open-patterns-typer.scala

@@ -1,6 +1,6 @@
 import scala.quoted._
 
 def f(using QuoteContext)(x: Expr[Any]) = x match {
-  case '{ val a: Int = 3; ${y $$ identity(a)} } => // error: Exprected an identifier
-  case '{ identity(${y $$ () }) } => // error: Missing arguments for open pattern
+  case '{ val a: Int = 3; ${y}{identity(a)} } => // error: Exprected an identifier
+  case '{ identity(${y}{()}) } => // error: Missing arguments for open pattern
 }

tests/run-macros/quote-matcher-symantics-3/quoted_1.scala

@@ -45,17 +45,17 @@ object Macros {
       case '{ (if ($cond) $thenp else $elsep): $t } =>
         '{ $sym.ifThenElse[$t](${lift(cond)}, ${lift(thenp)}, ${lift(elsep)}) }.asInstanceOf[Expr[R[T]]]
 
-      case '{ (x0: Int) => ${bodyFn $$ x0}: Any } =>
+      case '{ (x0: Int) => ${bodyFn}{x0}: Any } =>
         val (i, nEnvVar) = freshEnvVar[Int]()
         val body2 = UnsafeExpr.open(bodyFn) { (body1, close) => close(body1)(nEnvVar) }
         '{ $sym.lam((x: R[Int]) => ${given Env = envWith(i, 'x)(using env); lift(body2)}).asInstanceOf[R[T]] }
 
-      case '{ (x0: Boolean) => ${bodyFn $$ x0}: Any } =>
+      case '{ (x0: Boolean) => ${bodyFn}{x0}: Any } =>
         val (i, nEnvVar) = freshEnvVar[Boolean]()
         val body2 = UnsafeExpr.open(bodyFn) { (body1, close) => close(body1)(nEnvVar) }
         '{ $sym.lam((x: R[Boolean]) => ${given Env = envWith(i, 'x)(using env); lift(body2)}).asInstanceOf[R[T]] }
 
-      case '{ (x0: Int => Int) => ${bodyFn $$ x0}: Any } =>
+      case '{ (x0: Int => Int) => ${bodyFn}{x0}: Any } =>
         val (i, nEnvVar) = freshEnvVar[Int => Int]()
         val body2 = UnsafeExpr.open(bodyFn) { (body1, close) => close(body1)(nEnvVar) }
         '{ $sym.lam((x: R[Int => Int]) => ${given Env = envWith(i, 'x)(using env); lift(body2)}).asInstanceOf[R[T]] }

tests/run-macros/quote-matching-open/Macro_1.scala

@@ -6,9 +6,9 @@ object Macro {
 
   def impl(x: Expr[Any])(using QuoteContext): Expr[Any] = {
     x match {
-      case '{ (x: Int) => ${body $$ x}: Int } => UnsafeExpr.open(body) { (body, close) => close(body)(Expr(2)) }
-      case '{ (x1: Int, x2: Int) => ${body $$ (x1, x2)}: Int } => UnsafeExpr.open(body) { (body, close) => close(body)(Expr(2), Expr(3)) }
-      case '{ (x1: Int, x2: Int, x3: Int) => ${body $$ (x1, x2, x3)}: Int } => UnsafeExpr.open(body) { (body, close) => close(body)(Expr(2), Expr(3), Expr(4)) }
+      case '{ (x: Int) => ${body}{x}: Int } => UnsafeExpr.open(body) { (body, close) => close(body)(Expr(2)) }
+      case '{ (x1: Int, x2: Int) => ${body}{(x1, x2)}: Int } => UnsafeExpr.open(body) { (body, close) => close(body)(Expr(2), Expr(3)) }
+      case '{ (x1: Int, x2: Int, x3: Int) => ${body}{(x1, x2, x3)}: Int } => UnsafeExpr.open(body) { (body, close) => close(body)(Expr(2), Expr(3), Expr(4)) }
     }
   }
 

tests/run-macros/quoted-pattern-open-expr-0/Macro_1.scala

@@ -4,6 +4,6 @@ inline def test(inline e: Int): String = ${testExpr('e)}
 
 private def testExpr(e: Expr[Int])(using QuoteContext): Expr[String] = {
   e match {
-    case '{ val y: Int = 4; ${body $$ y}: Int } => Expr("Matched open\n" + body.show)
+    case '{ val y: Int = 4; ${body}{y}: Int } => Expr("Matched open\n" + body.show)
   }
 }

tests/run-macros/quoted-pattern-open-expr-simple-eval/Macro_1.scala

@@ -4,7 +4,7 @@ inline def eval(inline e: Int): Int = ${ evalExpr('e) }
 
 private def evalExpr(using QuoteContext)(e: Expr[Int]): Expr[Int] = {
   e match {
-    case '{ val y: Int = $x; ${body $$ y}: Int } =>
+    case '{ val y: Int = $x; ${body}{y}: Int } =>
       evalExpr(Expr.betaReduce(body)(evalExpr(x)))
     case '{ ($x: Int) * ($y: Int) } =>
       (x, y) match

tests/run-macros/quoted-pattern-open-expr/Macro_1.scala

@@ -5,8 +5,8 @@ inline def test(inline e: Int): String = ${testExpr('e)}
 private def testExpr(e: Expr[Int])(using QuoteContext): Expr[String] = {
   e match {
     case '{ val y: Int = 4; $body } => Expr("Matched closed\n" + body.show)
-    case '{ val y: Int = 4; ${body $$ y}: Int } => Expr("Matched open\n" + body.show)
-    case '{ val y: Int => Int = x => x + 1; ${body $$ y}: Int } => Expr("Matched open\n" + body.show)
-    case '{ def g(x: Int): Int = ${body $$ (g, x)}; g(5) } => Expr("Matched open\n" + body.show)
+    case '{ val y: Int = 4; ${body}{y}: Int } => Expr("Matched open\n" + body.show)
+    case '{ val y: Int => Int = x => x + 1; ${body}{y}: Int } => Expr("Matched open\n" + body.show)
+    case '{ def g(x: Int): Int = ${body}{(g, x)}; g(5) } => Expr("Matched open\n" + body.show)
   }
 }