Use new syntax

Author: nicolasstucki

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

@@ -103,7 +103,9 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   }
   case class Throw(expr: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
   case class Quote(quoted: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
-  case class Splice(expr: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
+  case class Splice(expr: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree {
+    def isInBrackets: Boolean = span.end != expr.span.end
+  }
   case class TypSplice(expr: Tree)(implicit @constructorOnly src: SourceFile) extends TypTree
   case class ForYield(enums: List[Tree], expr: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree
   case class ForDo(enums: List[Tree], body: Tree)(implicit @constructorOnly src: SourceFile) extends TermTree

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

@@ -119,43 +119,27 @@ trait QuotesAndSplices {
   def typedAppliedSplice(tree: untpd.Apply, pt: Type)(using Context): Tree = {
     assert(ctx.mode.is(Mode.QuotedPattern))
     val untpd.Apply(splice: untpd.Splice, args) = tree
-    if args.forall(_.isInstanceOf[untpd.Ident]) then
-      val suggestionArgs = args match
-        case arg :: Nil => arg.show
-        case args => args.map(_.show).mkString("(", ", ", ")")
-      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)
-    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.InternalQuotedMatcher_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)
+    else if splice.isInBrackets then // ${x}(...) match an application
+      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 // $x(...) higher-order quasipattern
+      val typedArgs = args.map {
+        case arg: untpd.Ident =>
+          typedExpr(arg)
+        case arg =>
+          ctx.error("Open patttern 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.InternalQuotedMatcher_patternHigherOrderHole).appliedToType(pt).appliedTo(typedPat, SeqLiteral(typedArgs, TypeTree(defn.AnyType)))
   }
 
   /** 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,8 @@ 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)`.
+To match an actual application we can use brackets on the function part `${b}(a1, a2, ..., an)`.
 
 
 ### More details

library/src/scala/internal/quoted/Matcher.scala

@@ -97,7 +97,6 @@ import scala.quoted._
  */
 object Matcher {
 
-  // TODO move to internal.Quoted.Matcher
   /** A splice in a quoted pattern is desugared by the compiler into a call to this method */
   @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.patternHole`")
   def patternHole[T]: T = ???
@@ -106,7 +105,6 @@ object Matcher {
   /** A higher order splice in a quoted pattern is desugared by the compiler into a call to this method */
   def patternHigherOrderHole[U](pat: Any, args: Any*): U = ???
 
-  // TODO move to internal.Quoted.Matcher
   @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.higherOrderHole`")
   /** A higher order splice in a quoted pattern is desugared by the compiler into a call to this method */
   def higherOrderHole[U](args: Any*): U = ???
@@ -116,12 +114,10 @@ object Matcher {
   @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.patternBindHole`")
   class patternBindHole extends Annotation
 
-  // TODO move to internal.Quoted.Matcher
   /** A splice of a name in a quoted pattern is that marks the definition of a type splice */
   @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.patternType`")
   class patternType extends Annotation
 
-  // TODO move to internal.Quoted.Matcher
   /** A type pattern that must be aproximated from above */
   @compileTimeOnly("Illegal reference to `scala.internal.quoted.CompileTime.fromAbove`")
   class fromAbove extends Annotation
@@ -268,27 +264,6 @@ object Matcher {
                  scrutinee.tpe <:< tpt.tpe =>
             matched(scrutinee.seal)
 
-          /* Higher order term hole */
-          // Matches an open term and wraps it into a lambda that provides the free variables
-          // DEPRECATED: replaced with `higherOrderHole`
-          // TODO: remove case
-          case (scrutinee, pattern @ Apply(Select(TypeApply(patternHole, List(Inferred())), "apply"), args0 @ IdentArgs(args)))
-              if patternHole.symbol == internal.Definitions_InternalQuotedMatcher_patternHole =>
-            def bodyFn(lambdaArgs: List[Tree]): Tree = {
-              val argsMap = args.map(_.symbol).zip(lambdaArgs.asInstanceOf[List[Term]]).toMap
-              new TreeMap {
-                override def transformTerm(tree: Term)(using ctx: Context): Term =
-                  tree match
-                    case tree: Ident => summon[Env].get(tree.symbol).flatMap(argsMap.get).getOrElse(tree)
-                    case tree => super.transformTerm(tree)
-              }.transformTree(scrutinee)
-            }
-            val names = args.map(_.name)
-            val argTypes = args0.map(x => x.tpe.widenTermRefExpr)
-            val resType = pattern.tpe
-            val res = Lambda(MethodType(names)(_ => argTypes, _ => resType), bodyFn)
-            matched(res.seal)
-
           /* Higher order term hole */
           // Matches an open term and wraps it into a lambda that provides the free variables
           case (scrutinee, pattern @ Apply(TypeApply(Ident("higherOrderHole"), List(Inferred())), Repeated(args, _) :: Nil))

tests/neg-custom-args/fatal-warnings/quoted-pattern-old-open-expr.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-stages.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/neg/quote-open-patterns-typer.scala

@@ -1,12 +1,12 @@
 import scala.quoted._
 
 def f(x: Expr[Int])(using QuoteContext) = x match {
-  case '{ $f($a: Int): Int } =>
+  case '{ ${f}($a: Int): Int } =>
     val f1: Expr[Int => Int] = f
     val a1: Expr[Int] = a
-  case '{ def a: Int = $f($b: Int); () } =>
+  case '{ def a: Int = ${f}($b: Int); () } =>
     val f1: Expr[Int => Int] = f
     val b1: Expr[Int] = b
-  case '{ val a: Int = 3; $f(a): Int } =>
+  case '{ val a: Int = 3; ${f}(a): Int } =>
     val f1: Expr[Int => Int] = f
 }

tests/pos/quoted-splice-pattern-applied.scala

@@ -20,7 +20,7 @@ object Macros {
 
       case '{ ($x: DSL) * ($y: DSL) } => sym.times(lift(x), lift(y))
 
-      case '{ $f($x: DSL): DSL } => sym.app(liftFun(f), lift(x))
+      case '{ ${f}($x: DSL): DSL } => sym.app(liftFun(f), lift(x))
 
       case '{ val x: DSL = $value; $bodyFn(x): DSL } =>
         UnsafeExpr.open(bodyFn) { (body1, close) =>

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

@@ -39,23 +39,23 @@ object Macros {
       case '{ ($x: Int) <= ($y: Int) } =>
         '{ $sym.leq(${lift(x)}, ${lift(y)}).asInstanceOf[R[T]] }
 
-      case '{ $f($arg: $t): $u } =>
+      case '{ ${f}($arg: $t): $u } =>
         '{ $sym.app[$t, $u](${lift(f)}, ${lift(arg)}).asInstanceOf[R[T]] }
 
       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-matcher-symantics-3/quoted_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/quote-matching-open/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-0/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-simple-eval/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)
   }
 }