scala · smarter · May 2, 2023 · Apr 21, 2023 · Apr 21, 2023 · Apr 21, 2023
diff --git a/compiler/src/dotty/tools/dotc/CompilationUnit.scala b/compiler/src/dotty/tools/dotc/CompilationUnit.scala
@@ -154,11 +154,13 @@ object CompilationUnit {
     var containsCaptureChecking = false
     var containsMacroAnnotation = false
     def traverse(tree: Tree)(using Context): Unit = {
-      if (tree.symbol.isQuote)
-        containsQuote = true
       if tree.symbol.is(Flags.Inline) then
         containsInline = true
       tree match
+        case tpd.Quote(_, _) =>
+          containsQuote = true
+        case tree: tpd.Apply if tree.symbol == defn.QuotedTypeModule_of =>
+          containsQuote = true
         case Import(qual, selectors) =>
           tpd.languageImport(qual) match
             case Some(prefix) =>

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1986,10 +1986,10 @@ object desugar {
         trees foreach collect
       case Block(Nil, expr) =>
         collect(expr)
-      case Quote(expr) =>
+      case Quote(expr, _) =>
         new UntypedTreeTraverser {
           def traverse(tree: untpd.Tree)(using Context): Unit = tree match {
-            case Splice(expr) => collect(expr)
+            case Splice(expr, _) => collect(expr)
             case _ => traverseChildren(tree)
           }
         }.traverse(expr)

diff --git a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -1026,33 +1026,19 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       case t => assert(t.span.exists, i"$t")
     }
 
-  /** Extractors for quotes */
-  object Quoted {
+  object QuotedTypeOf {
     /** Extracts the content of a quoted tree.
      *  The result can be the contents of a term or type quote, which
      *  will return a term or type tree respectively.
      */
     def unapply(tree: tpd.Apply)(using Context): Option[tpd.Tree] =
-      if tree.symbol == defn.QuotedRuntime_exprQuote then
-        // quoted.runtime.Expr.quote[T](<body>)
-        Some(tree.args.head)
-      else if tree.symbol == defn.QuotedTypeModule_of then
+      if tree.symbol == defn.QuotedTypeModule_of then
         // quoted.Type.of[<body>](quotes)
         val TypeApply(_, body :: _) = tree.fun: @unchecked
         Some(body)
       else None
   }
 
-  /** Extractors for splices */
-  object Spliced {
-    /** Extracts the content of a spliced expression tree.
-     *  The result can be the contents of a term splice, which
-     *  will return a term tree.
-     */
-    def unapply(tree: tpd.Apply)(using Context): Option[tpd.Tree] =
-      if tree.symbol.isExprSplice then Some(tree.args.head) else None
-  }
-
   /** Extractors for type splices */
   object SplicedType {
     /** Extracts the content of a spliced type tree.

diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -677,6 +677,46 @@ object Trees {
     override def isType = expansion.isType
   }
 
+  /** A tree representing a quote `'{ expr }`
+   *  `Quote`s are created by the `Parser` with an empty `tpt`. In typer
+   *  they can be typed as a `Quote` with a known `tpt` or desugared and
+   *  typed as a quote pattern.
+   *
+   *  `Quotes` are checked transformed in the `staging`, `splicing` and `pickleQuotes`
+   *  phases. After `pickleQuotes` phase, the only quotes that exist are in `inline`
+   *  methods. These are dropped when we remove the inline method implementations.
+   *
+   *  The `tpt` will be transformed in `staging` and used in `pickleQuotes` to create the
+   *  pickled representation of the quote.
+   *
+   *  @param  expr  The tree that was quoted
+   *  @param  tpt   The type of the tree that was quoted
+   */
+  case class Quote[+T <: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends TermTree[T] {
+    type ThisTree[+T <: Untyped] = Quote[T]
+  }
+
+  /** A tree representing a splice `${ expr }`
+   *
+   *  `Splice`s are created by the `Parser` with an empty `tpt`. In typer
+   *  they can be typed as a `Splice` with a known `tpt` or desugared and
+   *  typed as a quote pattern holes.
+   *
+   *  `Splice` are checked transformed in the `staging` and `splicing` phases.
+   *  After `splicing` phase, the only quotes that exist are in `inline`
+   *  methods. These are dropped when we remove the inline method implementations.
+   *
+   *  The `tpt` will be transformed in `staging` and used in `splicing` to create `Hole`s.
+   *
+   *  @param expr The tree that was spliced
+   *  @param tpt  The type of the spliced tree
+   */
+  case class Splice[+T <: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends TermTree[T] {
+    type ThisTree[+T <: Untyped] = Splice[T]
+  }
+
   /** A type tree that represents an existing or inferred type */
   case class TypeTree[+T <: Untyped]()(implicit @constructorOnly src: SourceFile)
     extends DenotingTree[T] with TypTree[T] {
@@ -1087,6 +1127,8 @@ object Trees {
     type SeqLiteral = Trees.SeqLiteral[T]
     type JavaSeqLiteral = Trees.JavaSeqLiteral[T]
     type Inlined = Trees.Inlined[T]
+    type Quote = Trees.Quote[T]
+    type Splice = Trees.Splice[T]
     type TypeTree = Trees.TypeTree[T]
     type InferredTypeTree = Trees.InferredTypeTree[T]
     type SingletonTypeTree = Trees.SingletonTypeTree[T]
@@ -1257,6 +1299,14 @@ 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, tpt: Tree)(using Context): Quote = tree match {
+        case tree: Quote if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
+        case _ => finalize(tree, untpd.Quote(expr, tpt)(sourceFile(tree)))
+      }
+      def Splice(tree: Tree)(expr: Tree, tpt: Tree)(using Context): Splice = tree match {
+        case tree: Splice if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
+        case _ => finalize(tree, untpd.Splice(expr, tpt)(sourceFile(tree)))
+      }
       def SingletonTypeTree(tree: Tree)(ref: Tree)(using Context): SingletonTypeTree = tree match {
         case tree: SingletonTypeTree if (ref eq tree.ref) => tree
         case _ => finalize(tree, untpd.SingletonTypeTree(ref)(sourceFile(tree)))
@@ -1362,6 +1412,8 @@ object Trees {
         TypeDef(tree: Tree)(name, rhs)
       def Template(tree: Template)(using Context)(constr: DefDef = tree.constr, parents: List[Tree] = tree.parents, derived: List[untpd.Tree] = tree.derived, self: ValDef = tree.self, body: LazyTreeList = tree.unforcedBody): Template =
         Template(tree: Tree)(constr, parents, derived, self, body)
+      def Splice(tree: Splice)(expr: Tree = tree.expr, tpt: Tree = tree.tpt)(using Context): Splice =
+        Splice(tree: Tree)(expr, tpt)
       def Hole(tree: Hole)(isTerm: Boolean = tree.isTerm, idx: Int = tree.idx, args: List[Tree] = tree.args, content: Tree = tree.content, tpt: Tree = tree.tpt)(using Context): Hole =
         Hole(tree: Tree)(isTerm, idx, args, content, tpt)
 
@@ -1494,6 +1546,10 @@ object Trees {
             case Thicket(trees) =>
               val trees1 = transform(trees)
               if (trees1 eq trees) tree else Thicket(trees1)
+            case tree @ Quote(expr, tpt) =>
+              cpy.Quote(tree)(transform(expr), transform(tpt))
+            case tree @ Splice(expr, tpt) =>
+              cpy.Splice(tree)(transform(expr), transform(tpt))
             case tree @ Hole(_, _, args, content, tpt) =>
               cpy.Hole(tree)(args = transform(args), content = transform(content), tpt = transform(tpt))
             case _ =>
@@ -1635,6 +1691,10 @@ object Trees {
               this(this(x, arg), annot)
             case Thicket(ts) =>
               this(x, ts)
+            case Quote(expr, tpt) =>
+              this(this(x, expr), tpt)
+            case Splice(expr, tpt) =>
+              this(this(x, expr), tpt)
             case Hole(_, _, args, content, tpt) =>
               this(this(this(x, args), content), tpt)
             case _ =>

diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -170,6 +170,12 @@ 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, tpt: Tree)(using Context): Quote =
+    ta.assignType(untpd.Quote(expr, tpt), tpt)
+
+  def Splice(expr: Tree, tpt: Tree)(using Context): Splice =
+    ta.assignType(untpd.Splice(expr, tpt), tpt)
+
   def TypeTree(tp: Type, inferred: Boolean = false)(using Context): TypeTree =
     (if inferred then untpd.InferredTypeTree() else untpd.TypeTree()).withType(tp)
 

diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -111,10 +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
-  }
   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
   case class GenFrom(pat: Tree, expr: Tree, checkMode: GenCheckMode)(implicit @constructorOnly src: SourceFile) extends Tree
@@ -401,6 +397,8 @@ 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, tpt: Tree)(implicit src: SourceFile): Quote = new Quote(expr, tpt)
+  def Splice(expr: Tree, tpt: Tree)(implicit src: SourceFile): Splice = new Splice(expr, tpt)
   def TypeTree()(implicit src: SourceFile): TypeTree = new TypeTree()
   def InferredTypeTree()(implicit src: SourceFile): TypeTree = new InferredTypeTree()
   def SingletonTypeTree(ref: Tree)(implicit src: SourceFile): SingletonTypeTree = new SingletonTypeTree(ref)
@@ -622,14 +620,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))
-    }
     def ForYield(tree: Tree)(enums: List[Tree], expr: Tree)(using Context): TermTree = tree match {
       case tree: ForYield if (enums eq tree.enums) && (expr eq tree.expr) => tree
       case _ => finalize(tree, untpd.ForYield(enums, expr)(tree.source))
@@ -711,10 +701,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) =>
         cpy.ForYield(tree)(transform(enums), transform(expr))
       case ForDo(enums, body) =>
@@ -772,10 +758,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) =>
         this(this(x, enums), expr)
       case ForDo(enums, body) =>

diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -665,6 +665,22 @@ class TreePickler(pickler: TastyPickler) {
               pickleTree(hi)
               pickleTree(alias)
           }
+        case Quote(expr, tpt) =>
+          pickleTree(
+            // scala.quoted.runtime.Expr.quoted[<tpt>](<expr>)
+            ref(defn.QuotedRuntime_exprQuote)
+              .appliedToTypeTree(tpt)
+              .appliedTo(expr)
+              .withSpan(tree.span)
+          )
+        case Splice(expr, tpt) =>
+          pickleTree(
+            // scala.quoted.runtime.Expr.splice[<tpt>](<spliced>)
+            ref(defn.QuotedRuntime_exprSplice)
+              .appliedToTypeTree(tpt)
+              .appliedTo(expr)
+              .withSpan(tree.span)
+          )
         case Hole(_, idx, args, _, tpt) =>
           writeByte(HOLE)
           withLength {

diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -1267,6 +1267,21 @@ class TreeUnpickler(reader: TastyReader,
                 res.withAttachment(SuppressedApplyToNone, ())
               else res
 
+      def quotedExpr(fn: Tree, args: List[Tree]): Tree =
+        val TypeApply(_, targs) = fn: @unchecked
+        Quote(args.head, targs.head)
+
+      def splicedExpr(fn: Tree, args: List[Tree]): Tree =
+        val TypeApply(_, targs) = fn: @unchecked
+        Splice(args.head, targs.head)
+
+      def nestedSpliceExpr(fn: Tree, args: List[Tree]): Tree =
+        fn match
+          case Apply(TypeApply(_, targs), _ :: Nil) => // nestedSplice[T](quotes)(expr)
+            Splice(args.head, targs.head)
+          case _ => // nestedSplice[T](quotes)
+            tpd.Apply(fn, args)
+
       def simplifyLub(tree: Tree): Tree =
         tree.overwriteType(tree.tpe.simplified)
         tree
@@ -1283,6 +1298,9 @@ class TreeUnpickler(reader: TastyReader,
               val fn = readTree()
               val args = until(end)(readTree())
               if fn.symbol.isConstructor then constructorApply(fn, args)
+              else if fn.symbol == defn.QuotedRuntime_exprQuote then quotedExpr(fn, args)
+              else if fn.symbol == defn.QuotedRuntime_exprSplice then splicedExpr(fn, args)
+              else if fn.symbol == defn.QuotedRuntime_exprNestedSplice then nestedSpliceExpr(fn, args)
               else tpd.Apply(fn, args)
             case TYPEAPPLY =>
               tpd.TypeApply(readTree(), until(end)(readTpt()))

diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -815,30 +815,33 @@ class Inliner(val call: tpd.Tree)(using Context):
       super.typedValDef(vdef1, sym)
 
     override def typedApply(tree: untpd.Apply, pt: Type)(using Context): Tree =
-      def cancelQuotes(tree: Tree): Tree =
-        tree match
-          case Quoted(Spliced(inner)) => inner
-          case _ => tree
       val locked = ctx.typerState.ownedVars
-      val res = cancelQuotes(constToLiteral(BetaReduce(super.typedApply(tree, pt)))) match {
-        case res: Apply if res.symbol == defn.QuotedRuntime_exprSplice
-                        && StagingLevel.level == 0
-                        && !hasInliningErrors =>
-          val expanded = expandMacro(res.args.head, tree.srcPos)
-          transform.TreeChecker.checkMacroGeneratedTree(res, expanded)
-          typedExpr(expanded) // Inline calls and constant fold code generated by the macro
-        case res =>
-          specializeEq(inlineIfNeeded(res, pt, locked))
-      }
-      res
+      specializeEq(inlineIfNeeded(constToLiteral(BetaReduce(super.typedApply(tree, pt))), pt, locked))
 
     override def typedTypeApply(tree: untpd.TypeApply, pt: Type)(using Context): Tree =
       val locked = ctx.typerState.ownedVars
       val tree1 = inlineIfNeeded(constToLiteral(BetaReduce(super.typedTypeApply(tree, pt))), pt, locked)
-      if tree1.symbol.isQuote then
+      if tree1.symbol == defn.QuotedTypeModule_of then
         ctx.compilationUnit.needsStaging = true
       tree1
 
+    override def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree =
+      super.typedQuote(tree, pt) match
+        case Quote(Splice(inner, _), _) => inner
+        case tree1 =>
+          ctx.compilationUnit.needsStaging = true
+          tree1
+
+    override def typedSplice(tree: untpd.Splice, pt: Type)(using Context): Tree =
+      super.typedSplice(tree, pt) match
+        case tree1 @ Splice(expr, tpt)
+            if StagingLevel.level == 0
+            && !hasInliningErrors =>
+          val expanded = expandMacro(expr, tree1.srcPos)
+          transform.TreeChecker.checkMacroGeneratedTree(tree1, expanded)
+          typedExpr(expanded) // Inline calls and constant fold code generated by the macro
+        case tree1 => tree1
+
     override def typedMatch(tree: untpd.Match, pt: Type)(using Context): Tree =
       val tree1 =
         if tree.isInline then
@@ -1067,11 +1070,15 @@ class Inliner(val call: tpd.Tree)(using Context):
         else tree match {
           case tree: RefTree if tree.isTerm && tree.symbol.isDefinedInCurrentRun && !tree.symbol.isLocal =>
             foldOver(tree.symbol :: syms, tree)
-          case Quoted(body) =>
+          case Quote(body, _) =>
+            level += 1
+            try apply(syms, body)
+            finally level -= 1
+          case QuotedTypeOf(body) =>
             level += 1
             try apply(syms, body)
             finally level -= 1
-          case Spliced(body) =>
+          case Splice(body, _) =>
             level -= 1
             try apply(syms, body)
             finally level += 1

diff --git a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
@@ -91,8 +91,9 @@ object PrepareInlineable {
         }
 
       private def stagingContext(tree: Tree)(using Context): Context = tree match
-        case tree: Apply if tree.symbol.isQuote => StagingLevel.quoteContext
-        case tree: Apply if tree.symbol.isExprSplice => StagingLevel.spliceContext
+        case tree: Quote => StagingLevel.quoteContext
+        case tree: Apply if tree.symbol eq defn.QuotedTypeModule_of => StagingLevel.quoteContext
+        case tree: Splice => StagingLevel.spliceContext
         case _ => ctx
     }
 
@@ -154,7 +155,7 @@ object PrepareInlineable {
           val qual = qualifier(refPart)
           inlining.println(i"adding receiver passing inline accessor for $tree/$refPart -> (${qual.tpe}, $refPart: ${refPart.getClass}, $argss%, %")
 
-          // Need to dealias in order to cagtch all possible references to abstracted over types in
+          // Need to dealias in order to catch all possible references to abstracted over types in
           // substitutions
           val dealiasMap = new TypeMap {
             def apply(t: Type) = mapOver(t.dealias)
@@ -290,7 +291,7 @@ object PrepareInlineable {
     if (inlined.is(Macro) && !ctx.isAfterTyper) {
 
       def checkMacro(tree: Tree): Unit = tree match {
-        case Spliced(code) =>
+        case Splice(code, _) =>
           if (code.symbol.flags.is(Inline))
             report.error("Macro cannot be implemented with an `inline` method", code.srcPos)
           Splicer.checkValidMacroBody(code)