Rename Quote.{expr=>body}

nicolasstucki · nicolasstucki · commit d4b2f0933f7b · 2023-04-28T16:19:20.000+02:00
Quotes can contain terms `'{..}` or types `'[..]`.
diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1986,13 +1986,13 @@ object desugar {
         trees foreach collect
       case Block(Nil, expr) =>
         collect(expr)
-      case Quote(expr) =>
+      case Quote(body) =>
         new UntypedTreeTraverser {
           def traverse(tree: untpd.Tree)(using Context): Unit = tree match {
             case Splice(expr) => collect(expr)
             case _ => traverseChildren(tree)
           }
-        }.traverse(expr)
+        }.traverse(body)
       case CapturingTypeTree(refs, parent) =>
         collect(parent)
       case _ =>
diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -687,7 +687,7 @@ object Trees {
    *
    *  @param  expr  The tree that was quoted
    */
-  case class Quote[+T <: Untyped] private[ast] (expr: Tree[T])(implicit @constructorOnly src: SourceFile)
+  case class Quote[+T <: Untyped] private[ast] (body: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends TermTree[T] {
     type ThisTree[+T <: Untyped] = Quote[T]
 
@@ -1305,9 +1305,9 @@ object Trees {
         case tree: Inlined if (call eq tree.call) && (bindings eq tree.bindings) && (expansion eq tree.expansion) => tree
         case _ => finalize(tree, untpd.Inlined(call, bindings, expansion)(sourceFile(tree)))
       }
-      def Quote(tree: Tree)(expr: Tree)(using Context): Quote = tree match {
-        case tree: Quote if (expr eq tree.expr) => tree
-        case _ => finalize(tree, untpd.Quote(expr)(sourceFile(tree)))
+      def Quote(tree: Tree)(body: Tree)(using Context): Quote = tree match {
+        case tree: Quote if (body eq tree.body) => tree
+        case _ => finalize(tree, untpd.Quote(body)(sourceFile(tree)))
       }
       def Splice(tree: Tree)(expr: Tree)(using Context): Splice = tree match {
         case tree: Splice if (expr eq tree.expr) => tree
@@ -1550,8 +1550,8 @@ object Trees {
             case Thicket(trees) =>
               val trees1 = transform(trees)
               if (trees1 eq trees) tree else Thicket(trees1)
-            case tree @ Quote(expr) =>
-              cpy.Quote(tree)(transform(expr))
+            case tree @ Quote(body) =>
+              cpy.Quote(tree)(transform(body))
             case tree @ Splice(expr) =>
               cpy.Splice(tree)(transform(expr))
             case tree @ Hole(_, _, args, content, tpt) =>
@@ -1695,8 +1695,8 @@ object Trees {
               this(this(x, arg), annot)
             case Thicket(ts) =>
               this(x, ts)
-            case Quote(expr) =>
-              this(x, expr)
+            case Quote(body) =>
+              this(x, body)
             case Splice(expr) =>
               this(x, expr)
             case Hole(_, _, args, content, tpt) =>
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -170,8 +170,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def Inlined(call: Tree, bindings: List[MemberDef], expansion: Tree)(using Context): Inlined =
     ta.assignType(untpd.Inlined(call, bindings, expansion), bindings, expansion)
 
-  def Quote(expr: Tree, tpe: Type)(using Context): Quote =
-    untpd.Quote(expr).withExprType(tpe)
+  def Quote(body: Tree, tpe: Type)(using Context): Quote =
+    untpd.Quote(body).withExprType(tpe)
 
   def Splice(expr: Tree, tpe: Type)(using Context): Splice =
     untpd.Splice(expr).withType(tpe)
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -397,7 +397,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def SeqLiteral(elems: List[Tree], elemtpt: Tree)(implicit src: SourceFile): SeqLiteral = new SeqLiteral(elems, elemtpt)
   def JavaSeqLiteral(elems: List[Tree], elemtpt: Tree)(implicit src: SourceFile): JavaSeqLiteral = new JavaSeqLiteral(elems, elemtpt)
   def Inlined(call: tpd.Tree, bindings: List[MemberDef], expansion: Tree)(implicit src: SourceFile): Inlined = new Inlined(call, bindings, expansion)
-  def Quote(expr: Tree)(implicit src: SourceFile): Quote = new Quote(expr)
+  def Quote(body: Tree)(implicit src: SourceFile): Quote = new Quote(body)
   def Splice(expr: Tree)(implicit src: SourceFile): Splice = new Splice(expr)
   def TypeTree()(implicit src: SourceFile): TypeTree = new TypeTree()
   def InferredTypeTree()(implicit src: SourceFile): TypeTree = new InferredTypeTree()
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -665,12 +665,12 @@ class TreePickler(pickler: TastyPickler) {
               pickleTree(hi)
               pickleTree(alias)
           }
-        case tree @ Quote(expr) =>
+        case tree @ Quote(body) =>
           pickleTree(
-            // scala.quoted.runtime.Expr.quoted[<tree.exprType>](<expr>)
+            // scala.quoted.runtime.Expr.quoted[<tree.exprType>](<body>)
             ref(defn.QuotedRuntime_exprQuote)
               .appliedToType(tree.exprType)
-              .appliedTo(expr)
+              .appliedTo(body)
               .withSpan(tree.span)
           )
         case Splice(expr) =>
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -2494,10 +2494,10 @@ object Parsers {
         case QUOTE =>
           atSpan(in.skipToken()) {
             withinStaged(StageKind.Quoted | (if (location.inPattern) StageKind.QuotedPattern else 0)) {
-              val expr =
+              val body =
                 if (in.token == LBRACKET) inBrackets(typ())
                 else stagedBlock()
-              Quote(expr)
+              Quote(body)
             }
           }
         case NEW =>
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -716,9 +716,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         "Thicket {" ~~ toTextGlobal(trees, "\n") ~~ "}"
       case MacroTree(call) =>
         keywordStr("macro ") ~ toTextGlobal(call)
-      case tree @ Quote(expr) =>
+      case tree @ Quote(body) =>
         val exprTypeText = (keywordStr("[") ~ toTextGlobal(tree.exprType) ~ keywordStr("]")).provided(printDebug && tree.typeOpt.exists)
-        keywordStr("'") ~ exprTypeText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
+        keywordStr("'") ~ exprTypeText ~ keywordStr("{") ~ toTextGlobal(body) ~ keywordStr("}")
       case Splice(expr) =>
         val spliceTypeText = (keywordStr("[") ~ toTextGlobal(tree.typeOpt) ~ keywordStr("]")).provided(printDebug && tree.typeOpt.exists)
         keywordStr("$") ~ spliceTypeText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
diff --git a/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala b/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
@@ -401,8 +401,8 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
         }
       case tree: Quote =>
         inContext(prepQuote(tree, start)(using outerCtx)) {
-          val expr = transformTree(tree.expr, start)(using quoteContext)
-          goQuote(cpy.Quote(tree)(expr), start)
+          val body = transformTree(tree.body, start)(using quoteContext)
+          goQuote(cpy.Quote(tree)(body), start)
         }
       case tree: Splice =>
         inContext(prepSplice(tree, start)(using outerCtx)) {
diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -101,7 +101,7 @@ class PickleQuotes extends MacroTransform {
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
       tree match
         case Apply(Select(quote: Quote, nme.apply), List(quotes)) =>
-          val (contents, codeWithHoles) = makeHoles(quote.expr)
+          val (contents, codeWithHoles) = makeHoles(quote.body)
           val sourceRef = Inlines.inlineCallTrace(ctx.owner, tree.sourcePos)
           val codeWithHoles2 = Inlined(sourceRef, Nil, codeWithHoles)
           val pickled = PickleQuotes(quotes, codeWithHoles2, contents, quote.exprType, false)
diff --git a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
@@ -485,7 +485,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           )
         case Block(_, Closure(_, _, tpt)) if ExpandSAMs.needsWrapperClass(tpt.tpe) =>
           superAcc.withInvalidCurrentClass(super.transform(tree))
-        case Quote(expr) =>
+        case _: Quote =>
           ctx.compilationUnit.needsStaging = true
           super.transform(tree)
         case tree =>
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicer.scala b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
@@ -155,15 +155,15 @@ object Splicer {
         case Block(Nil, expr) => checkIfValidArgument(expr)
         case Typed(expr, _) => checkIfValidArgument(expr)
 
-        case Apply(Select(Quote(expr), nme.apply), _) =>
+        case Apply(Select(Quote(body), nme.apply), _) =>
           val noSpliceChecker = new TreeTraverser {
             def traverse(tree: Tree)(using Context): Unit = tree match
               case Splice(_) =>
                 report.error("Quoted argument of macros may not have splices", tree.srcPos)
               case _ =>
                 traverseChildren(tree)
           }
-          noSpliceChecker.traverse(expr)
+          noSpliceChecker.traverse(body)
 
         case Apply(TypeApply(fn, List(quoted)), _)if fn.symbol == defn.QuotedTypeModule_of =>
           // OK
@@ -240,15 +240,15 @@ object Splicer {
 
     override protected  def interpretTree(tree: Tree)(implicit env: Env): Object = tree match {
       // Interpret level -1 quoted code `'{...}` (assumed without level 0 splices)
-      case Apply(Select(Quote(expr), nme.apply), _) =>
-        val expr1 = expr match {
+      case Apply(Select(Quote(body), nme.apply), _) =>
+        val body1 = body match {
           case expr: Ident if expr.symbol.isAllOf(InlineByNameProxy) =>
             // inline proxy for by-name parameter
             expr.symbol.defTree.asInstanceOf[DefDef].rhs
-          case Inlined(EmptyTree, _, expr1) => expr1
-          case _ => expr
+          case Inlined(EmptyTree, _, body1) => body1
+          case _ => body
         }
-        new ExprImpl(Inlined(EmptyTree, Nil, QuoteUtils.changeOwnerOfTree(expr1, ctx.owner)).withSpan(expr1.span), SpliceScope.getCurrent)
+        new ExprImpl(Inlined(EmptyTree, Nil, QuoteUtils.changeOwnerOfTree(body1, ctx.owner)).withSpan(body1.span), SpliceScope.getCurrent)
 
       // Interpret level -1 `Type.of[T]`
       case Apply(TypeApply(fn, quoted :: Nil), _) if fn.symbol == defn.QuotedTypeModule_of =>
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -86,7 +86,7 @@ class Splicing extends MacroTransform:
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
       assert(level == 0)
       tree match
-        case Apply(Select(Quote(expr), nme.apply),List(quotes)) =>
+        case Apply(Select(_: Quote, nme.apply), _) =>
           QuoteTransformer().transform(tree)
         case TypeApply(_, _) if tree.symbol == defn.QuotedTypeModule_of =>
           QuoteTransformer().transform(tree)
@@ -134,7 +134,7 @@ class Splicing extends MacroTransform:
               typeHoles.put(qual, hole)
               hole
           cpy.TypeDef(tree)(rhs = hole)
-        case Apply(Select(Quote(expr), nme.apply),List(quotes)) =>
+        case Apply(Select(_: Quote, nme.apply),List(quotes)) =>
           super.transform(tree)(using quoteContext)
         case _: Template =>
           for sym <- tree.symbol.owner.info.decls do
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -36,8 +36,8 @@ trait QuotesAndSplices {
    */
   def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree = {
     record("typedQuote")
-    tree.expr match {
-      case untpd.Splice(innerExpr) if tree.isTerm && !ctx.mode.is(Mode.Pattern) =>
+    tree.body match {
+      case _: untpd.Splice if tree.isTerm && !ctx.mode.is(Mode.Pattern) =>
         report.warning("Canceled splice directly inside a quote. '{ ${ XYZ } } is equivalent to XYZ.", tree.srcPos)
       case _ =>
     }
@@ -50,7 +50,7 @@ trait QuotesAndSplices {
 
     if ctx.mode.is(Mode.Pattern) then
       typedQuotePattern(tree, pt, quotes).withSpan(tree.span)
-    else if tree.expr.isType then
+    else if tree.body.isType then
       val msg = em"""Quoted types `'[..]` can only be used in patterns.
                     |
                     |Hint: To get a scala.quoted.Type[T] use scala.quoted.Type.of[T] instead.
@@ -59,7 +59,7 @@ trait QuotesAndSplices {
       EmptyTree
     else
       // TODO typecheck directly (without `exprQuote`)
-      val exprQuoteTree = untpd.Apply(untpd.ref(defn.QuotedRuntime_exprQuote.termRef), tree.expr)
+      val exprQuoteTree = untpd.Apply(untpd.ref(defn.QuotedRuntime_exprQuote.termRef), tree.body)
       val quotedExpr = typedApply(exprQuoteTree, pt)(using quoteContext) match
         case Apply(TypeApply(fn, tpt :: Nil), quotedExpr :: Nil) => Quote(quotedExpr, tpt.tpe)
       makeInlineable(quotedExpr.select(nme.apply).appliedTo(quotes).withSpan(tree.span))
@@ -383,7 +383,7 @@ trait QuotesAndSplices {
    *  ```
    */
   private def typedQuotePattern(tree: untpd.Quote, pt: Type, qctx: Tree)(using Context): Tree = {
-    val quoted = tree.expr
+    val quoted = tree.body
     if quoted.isTerm && !pt.derivesFrom(defn.QuotedExprClass) then
       report.error("Quote pattern can only match scrutinees of type scala.quoted.Expr", tree.srcPos)
     else if quoted.isType && !pt.derivesFrom(defn.QuotedTypeClass) then
diff --git a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
@@ -97,8 +97,8 @@ class ReTyper(nestingLevel: Int = 0) extends Typer(nestingLevel) with ReChecking
 
   override def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree =
     assertTyped(tree)
-    val expr1 = typed(tree.expr, tree.exprType)(using quoteContext)
-    untpd.cpy.Quote(tree)(expr1).withType(tree.typeOpt)
+    val body1 = typed(tree.body, tree.exprType)(using quoteContext)
+    untpd.cpy.Quote(tree)(body1).withType(tree.typeOpt)
 
   override def typedSplice(tree: untpd.Splice, pt: Type)(using Context): Tree =
     assertTyped(tree)
diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -647,7 +647,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
         def args: List[Term] = self match
           case self: tpd.Apply => self.args
-          case self: tpd.Quote => List(self.expr) // TODO expose Quote AST in Quotes
+          case self: tpd.Quote => List(self.body) // TODO expose Quote AST in Quotes
           case self: tpd.Splice => List(self.expr) // TODO expose Splice AST in Quotes
       end extension
     end ApplyMethods

Original file line number	Diff line number	Diff line change
`@@ -2494,10 +2494,10 @@ object Parsers {`
`2494`	`2494`	`case QUOTE =>`
`2495`	`2495`	`atSpan(in.skipToken()) {`
`2496`	`2496`	`withinStaged(StageKind.Quoted \| (if (location.inPattern) StageKind.QuotedPattern else 0)) {`
`2497`		`- val expr =`
	`2497`	`+ val body =`
`2498`	`2498`	`if (in.token == LBRACKET) inBrackets(typ())`
`2499`	`2499`	`else stagedBlock()`
`2500`		`- Quote(expr)`
	`2500`	`+ Quote(body)`
`2501`	`2501`	`}`
`2502`	`2502`	`}`
`2503`	`2503`	`case NEW =>`
Original file line number	Diff line number	Diff line change
`@@ -401,8 +401,8 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {`
`401`	`401`	`}`
`402`	`402`	`case tree: Quote =>`
`403`	`403`	`inContext(prepQuote(tree, start)(using outerCtx)) {`
`404`		`- val expr = transformTree(tree.expr, start)(using quoteContext)`
`405`		`- goQuote(cpy.Quote(tree)(expr), start)`
	`404`	`+ val body = transformTree(tree.body, start)(using quoteContext)`
	`405`	`+ goQuote(cpy.Quote(tree)(body), start)`
`406`	`406`	`}`
`407`	`407`	`case tree: Splice =>`
`408`	`408`	`inContext(prepSplice(tree, start)(using outerCtx)) {`
Original file line number	Diff line number	Diff line change
`@@ -485,7 +485,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase`
`485`	`485`	`)`
`486`	`486`	`case Block(_, Closure(_, _, tpt)) if ExpandSAMs.needsWrapperClass(tpt.tpe) =>`
`487`	`487`	`superAcc.withInvalidCurrentClass(super.transform(tree))`
`488`		`- case Quote(expr) =>`
	`488`	`+ case _: Quote =>`
`489`	`489`	`ctx.compilationUnit.needsStaging = true`
`490`	`490`	`super.transform(tree)`
`491`	`491`	`case tree =>`