Use QuotedExpr instead of Quote trees

Author: nicolasstucki

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

@@ -1986,7 +1986,7 @@ object desugar {
         trees foreach collect
       case Block(Nil, expr) =>
         collect(expr)
-      case Quote(expr) =>
+      case QuotedExpr(expr, _) =>
         new UntypedTreeTraverser {
           def traverse(tree: untpd.Tree)(using Context): Unit = tree match {
             case Splice(expr) => collect(expr)

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

@@ -111,7 +111,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     override def isType: Boolean = !isTerm
   }
   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 {
     def isInBraces: Boolean = span.end != expr.span.end
   }
@@ -624,10 +623,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       case tree: Throw if expr eq tree.expr => tree
       case _ => finalize(tree, untpd.Throw(expr)(tree.source))
     }
-    def Quote(tree: Tree)(quoted: Tree)(using Context): Tree = tree match {
-      case tree: Quote if quoted eq tree.quoted => tree
-      case _ => finalize(tree, untpd.Quote(quoted)(tree.source))
-    }
     def Splice(tree: Tree)(expr: Tree)(using Context): Tree = tree match {
       case tree: Splice if expr eq tree.expr => tree
       case _ => finalize(tree, untpd.Splice(expr)(tree.source))
@@ -713,8 +708,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         cpy.Tuple(tree)(transform(trees))
       case Throw(expr) =>
         cpy.Throw(tree)(transform(expr))
-      case Quote(t) =>
-        cpy.Quote(tree)(transform(t))
       case Splice(expr) =>
         cpy.Splice(tree)(transform(expr))
       case ForYield(enums, expr) =>
@@ -774,8 +767,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         this(x, trees)
       case Throw(expr) =>
         this(x, expr)
-      case Quote(t) =>
-        this(x, t)
       case Splice(expr) =>
         this(x, expr)
       case ForYield(enums, expr) =>

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -1262,7 +1262,7 @@ object Parsers {
               }
             }
             in.nextToken()
-            Quote(t)
+            QuotedExpr(t, EmptyTree)
           }
           else
             if !in.featureEnabled(Feature.symbolLiterals) then
@@ -2494,10 +2494,10 @@ object Parsers {
         case QUOTE =>
           atSpan(in.skipToken()) {
             withinStaged(StageKind.Quoted | (if (location.inPattern) StageKind.QuotedPattern else 0)) {
-              Quote {
+              val expr =
                 if (in.token == LBRACKET) inBrackets(typ())
                 else stagedBlock()
-              }
+              QuotedExpr(expr, EmptyTree)
             }
           }
         case NEW =>

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -712,16 +712,14 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         }
       case Number(digits, kind) =>
         digits
-      case Quote(tree) if tree.isTerm =>
-        keywordStr("'{") ~ toTextGlobal(dropBlock(tree)) ~ keywordStr("}")
       case Splice(tree) =>
         keywordStr("${") ~ toTextGlobal(dropBlock(tree)) ~ keywordStr("}")
       case Thicket(trees) =>
         "Thicket {" ~~ toTextGlobal(trees, "\n") ~~ "}"
       case MacroTree(call) =>
         keywordStr("macro ") ~ toTextGlobal(call)
       case QuotedExpr(expr, tpt) =>
-        val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(printDebug)
+        val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(!tpt.isEmpty && printDebug)
         keywordStr("'") ~ tptText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
       case SplicedExpr(expr, tpt) =>
         val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(printDebug)

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

@@ -34,9 +34,9 @@ trait QuotesAndSplices {
   /** Translate `'{ e }` into `scala.quoted.Expr.apply(e)` and `'[T]` into `scala.quoted.Type.apply[T]`
    *  while tracking the quotation level in the context.
    */
-  def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree = {
+  def typedQuote(tree: untpd.QuotedExpr, pt: Type)(using Context): Tree = {
     record("typedQuote")
-    tree.quoted match {
+    tree.expr match {
       case untpd.Splice(innerExpr) 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,15 +50,15 @@ trait QuotesAndSplices {
 
     if ctx.mode.is(Mode.Pattern) then
       typedQuotePattern(tree, pt, quotes).withSpan(tree.span)
-    else if tree.quoted.isType then
+    else if tree.expr.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.
                     |"""
       report.error(msg, tree.srcPos)
       EmptyTree
     else
-      val exprQuoteTree = untpd.Apply(untpd.ref(defn.QuotedRuntime_exprQuote.termRef), tree.quoted)
+      val exprQuoteTree = untpd.Apply(untpd.ref(defn.QuotedRuntime_exprQuote.termRef), tree.expr)
       val quotedExpr = typedApply(exprQuoteTree, pt)(using quoteContext) match
         case Apply(TypeApply(fn, tpt :: Nil), quotedExpr :: Nil) => QuotedExpr(quotedExpr, tpt)
       makeInlineable(quotedExpr.select(nme.apply).appliedTo(quotes).withSpan(tree.span))
@@ -74,7 +74,7 @@ trait QuotesAndSplices {
     record("typedSplice")
     checkSpliceOutsideQuote(tree)
     tree.expr match {
-      case untpd.Quote(innerExpr) if innerExpr.isTerm =>
+      case untpd.QuotedExpr(innerExpr, _) if innerExpr.isTerm =>
         report.warning("Canceled quote directly inside a splice. ${ '{ XYZ } } is equivalent to XYZ.", tree.srcPos)
         return typed(innerExpr, pt)
       case _ =>
@@ -382,13 +382,13 @@ trait QuotesAndSplices {
    *        ) => ...
    *  ```
    */
-  private def typedQuotePattern(tree: untpd.Quote, pt: Type, qctx: Tree)(using Context): Tree = {
-    if tree.quoted.isTerm && !pt.derivesFrom(defn.QuotedExprClass) then
+  private def typedQuotePattern(tree: untpd.QuotedExpr, pt: Type, qctx: Tree)(using Context): Tree = {
+    val quoted = tree.expr
+    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 tree.quoted.isType && !pt.derivesFrom(defn.QuotedTypeClass) then
+    else if quoted.isType && !pt.derivesFrom(defn.QuotedTypeClass) then
       report.error("Quote pattern can only match scrutinees of type scala.quoted.Type", tree.srcPos)
 
-    val quoted = tree.quoted
     val exprPt = pt.baseType(if quoted.isType then defn.QuotedTypeClass else defn.QuotedExprClass)
     val quotedPt = exprPt.argInfos.headOption match {
       case Some(argPt: ValueType) => argPt // excludes TypeBounds
@@ -440,12 +440,12 @@ trait QuotesAndSplices {
       if splices.isEmpty then ref(defn.EmptyTupleModule.termRef)
       else typed(untpd.Tuple(splices.map(x => untpd.TypedSplice(replaceBindingsInTree.transform(x)))).withSpan(quoted.span), patType)
 
-    val quoteClass = if (tree.quoted.isTerm) defn.QuotedExprClass else defn.QuotedTypeClass
+    val quoteClass = if (quoted.isTerm) defn.QuotedExprClass else defn.QuotedTypeClass
     val quotedPattern =
-      if (tree.quoted.isTerm) tpd.QuotedExpr(shape, TypeTree(defn.AnyType)).select(nme.apply).appliedTo(qctx)
+      if (quoted.isTerm) tpd.QuotedExpr(shape, TypeTree(defn.AnyType)).select(nme.apply).appliedTo(qctx)
       else ref(defn.QuotedTypeModule_of.termRef).appliedToTypeTree(shape).appliedTo(qctx)
 
-    val matchModule = if tree.quoted.isTerm then defn.QuoteMatching_ExprMatch else defn.QuoteMatching_TypeMatch
+    val matchModule = if quoted.isTerm then defn.QuoteMatching_ExprMatch else defn.QuoteMatching_TypeMatch
     val unapplyFun = qctx.asInstance(defn.QuoteMatchingClass.typeRef).select(matchModule).select(nme.unapply)
 
     UnApply(

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

@@ -2046,9 +2046,12 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   }
 
   def typedQuotedExpr(tree: untpd.QuotedExpr, pt: Type)(using Context): Tree =
-    val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
-    val expr1 = typed(tree.expr, tpt1.tpe.widenSkolem)(using StagingLevel.quoteContext)
-    assignType(cpy.QuotedExpr(tree)(expr1, tpt1), tpt1)
+    if tree.tpt.isEmpty then
+      typedQuote(tree, pt)
+    else
+      val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
+      val expr1 = typed(tree.expr, tpt1.tpe.widenSkolem)(using StagingLevel.quoteContext)
+      assignType(cpy.QuotedExpr(tree)(expr1, tpt1), tpt1)
 
   def typedSplicedExpr(tree: untpd.SplicedExpr, pt: Type)(using Context): Tree =
     val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
@@ -3088,7 +3091,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           case tree: untpd.ParsedTry => typedTry(tree, pt)
           case tree @ untpd.PostfixOp(qual, Ident(nme.WILDCARD)) => typedAsFunction(tree, pt)
           case untpd.EmptyTree => tpd.EmptyTree
-          case tree: untpd.Quote => typedQuote(tree, pt)
           case tree: untpd.QuotedExpr => typedQuotedExpr(tree, pt)
           case tree: untpd.Splice => typedSplice(tree, pt)
           case tree: untpd.SplicedExpr => typedSplicedExpr(tree, pt)