Refactor type splice logic

Specialize the matching and handling of term/type splices. This avoids unnecessary operations on either.

Author: nicolasstucki

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

@@ -879,15 +879,22 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
 
   /** Extractors for splices */
   object Spliced {
-    /** Extracts the content of a spliced tree.
-     *  The result can be the contents of a term or type splice, which
-     *  will return a term or type tree respectively.
+    /** Extracts the content of a spliced expresion tree.
+     *  The result can be the contents of a term splice, which
+     *  will return a term tree.
      */
-    def unapply(tree: tpd.Tree)(using Context): Option[tpd.Tree] = tree match {
-      case tree: tpd.Apply if tree.symbol.isSplice => Some(tree.args.head)
-      case tree: tpd.Select if tree.symbol.isSplice => Some(tree.qualifier)
-      case _ => None
-    }
+    def unapply(tree: tpd.Apply)(using Context): Option[tpd.Tree] =
+      if tree.symbol.isSplice then Some(tree.args.head) else None
+  }
+
+  /** Extractors for splices */
+  object SplicedType {
+    /** Extracts the content of a spliced type tree.
+      *  The result can be the contents of a type splice, which
+      *  will return a type tree.
+      */
+    def unapply(tree: tpd.Select)(using Context): Option[tpd.Tree] =
+      if tree.symbol.isSplice then Some(tree.qualifier) else None
   }
 
   /** Extractor for not-null assertions.

compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala

@@ -123,25 +123,28 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
    *  - If inside inlined code, expand the macro code.
    *  - If inside of a macro definition, check the validity of the macro.
    */
-  protected def transformSplice(body: Tree, splice: Tree)(using Context): Tree = {
+  protected def transformSplice(body: Tree, splice: Apply)(using Context): Tree = {
     val body1 = transform(body)(using spliceContext)
-    splice match {
-      case Apply(fun @ TypeApply(_, _ :: Nil), _) if splice.isTerm =>
+    splice.fun match {
+      case fun @ TypeApply(_, _ :: Nil) =>
         // Type of the splice itsel must also be healed
         // internal.Quoted.expr[F[T]](... T ...)  -->  internal.Quoted.expr[F[$t]](... T ...)
         val tp = healType(splice.sourcePos)(splice.tpe.widenTermRefExpr)
         cpy.Apply(splice)(cpy.TypeApply(fun)(fun.fun, tpd.TypeTree(tp) :: Nil), body1 :: Nil)
-      case Apply(f @ Apply(fun @ TypeApply(_, _), qctx :: Nil), _) if splice.isTerm =>
+      case f @ Apply(fun @ TypeApply(_, _), qctx :: Nil) =>
         // Type of the splice itsel must also be healed
         // internal.Quoted.expr[F[T]](... T ...)  -->  internal.Quoted.expr[F[$t]](... T ...)
         val tp = healType(splice.sourcePos)(splice.tpe.widenTermRefExpr)
         cpy.Apply(splice)(cpy.Apply(f)(cpy.TypeApply(fun)(fun.fun, tpd.TypeTree(tp) :: Nil), qctx :: Nil), body1 :: Nil)
-      case splice: Select =>
-        val tagRef = getQuoteTypeTags.getTagRef(splice.qualifier.tpe.asInstanceOf[TermRef])
-        ref(tagRef).withSpan(splice.span)
     }
   }
 
+  protected def transformSpliceType(body: Tree, splice: Select)(using Context): Tree = {
+    val body1 = transform(body)(using spliceContext)
+    val tagRef = getQuoteTypeTags.getTagRef(splice.qualifier.tpe.asInstanceOf[TermRef])
+    ref(tagRef).withSpan(splice.span)
+  }
+
   /** Check that annotations do not contain quotes and and that splices are valid */
   private def checkAnnotations(tree: Tree)(using Context): Unit =
     tree match

compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala

@@ -187,13 +187,10 @@ class ReifyQuotes extends MacroTransform {
      *  and make a hole from these parts. Otherwise issue an error, unless we
      *  are in the body of an inline method.
      */
-    protected def transformSplice(body: Tree, splice: Tree)(using Context): Tree =
+    protected def transformSplice(body: Tree, splice: Apply)(using Context): Tree =
       if (level > 1) {
         val body1 = nested(isQuote = false).transform(body)(using spliceContext)
-        splice match {
-          case splice: Apply => cpy.Apply(splice)(splice.fun, body1 :: Nil)
-          case splice: Select => cpy.Select(splice)(body1, splice.name)
-        }
+        cpy.Apply(splice)(splice.fun, body1 :: Nil)
       }
       else {
         assert(level == 1, "unexpected top splice outside quote")
@@ -204,10 +201,26 @@ class ReifyQuotes extends MacroTransform {
         // enclosing quote. Any intemediate splice will add it's own Inlined node and cancel it before splicig the lifted tree.
         // Note that lifted trees are not necessarily expressions and that Inlined nodes are expected to be expressions.
         // For example we can have a lifted tree containing the LHS of an assignment (see tests/run-with-compiler/quote-var.scala).
-        if (splice.isType || outer.embedded.isLiftedSymbol(body.symbol)) hole
+        if (outer.embedded.isLiftedSymbol(body.symbol)) hole
         else Inlined(EmptyTree, Nil, hole).withSpan(splice.span)
       }
 
+     /** If inside a quote, split the body of the splice into a core and a list of embedded quotes
+     *  and make a hole from these parts. Otherwise issue an error, unless we
+     *  are in the body of an inline method.
+     */
+     protected def transformSpliceType(body: Tree, splice: Select)(using Context): Tree =
+      if (level > 1) {
+        val body1 = nested(isQuote = false).transform(body)(using spliceContext)
+        cpy.Select(splice)(body1, splice.name)
+      }
+      else {
+        assert(level == 1, "unexpected top splice outside quote")
+        val (body1, quotes) = nested(isQuote = false).splitSplice(body)(using spliceContext)
+        val tpe = outer.embedded.getHoleType(body, splice)
+        makeHole(splice.isTerm, body1, quotes, tpe).withSpan(splice.span)
+      }
+
     /** Transforms the contents of a nested splice
      *  Assuming
      *     '{
@@ -356,11 +369,11 @@ class ReifyQuotes extends MacroTransform {
             capturers(body.symbol)(body)
           case tree: RefTree if isCaptured(tree.symbol, level) =>
             val body = capturers(tree.symbol).apply(tree)
-            val splice: Tree =
-              if (tree.isType) body.select(tpnme.splice)
-              else ref(defn.InternalQuoted_exprSplice).appliedToType(tree.tpe).appliedTo(body)
-
-            transformSplice(body, splice)
+            if (tree.isType)
+              transformSpliceType(body, body.select(tpnme.splice))
+            else
+              val splice = ref(defn.InternalQuoted_exprSplice).appliedToType(tree.tpe).appliedTo(body).asInstanceOf[Apply]
+              transformSplice(body, splice)
 
           case tree: DefDef if tree.symbol.is(Macro) && level == 0 =>
             // Shrink size of the tree. The methods have already been inlined.

compiler/src/dotty/tools/dotc/transform/TreeMapWithStages.scala

@@ -71,8 +71,11 @@ abstract class TreeMapWithStages(@constructorOnly ictx: Context) extends TreeMap
       case quote: TypeApply => cpy.TypeApply(quote)(quote.fun, body :: Nil)
     }
 
-  /** Transform the splice `splice` which contains the spliced `body`. */
-  protected def transformSplice(body: Tree, splice: Tree)(using Context): Tree
+  /** Transform the expression splice `splice` which contains the spliced `body`. */
+  protected def transformSplice(body: Tree, splice: Apply)(using Context): Tree
+
+  /** Transform the typee splice `splice` which contains the spliced `body`. */
+  protected def transformSpliceType(body: Tree, splice: Select)(using Context): Tree
 
   override def transform(tree: Tree)(using Context): Tree =
     if (tree.source != ctx.source && tree.source.exists)
@@ -94,7 +97,7 @@ abstract class TreeMapWithStages(@constructorOnly ictx: Context) extends TreeMap
       tree match {
         case Apply(Select(Quoted(quotedTree), _), _) if quotedTree.isType =>
           dropEmptyBlocks(quotedTree) match
-            case Spliced(t) =>
+            case SplicedType(t) =>
               // '[ x.$splice ] --> x
               transform(t)
             case _ =>
@@ -121,6 +124,12 @@ abstract class TreeMapWithStages(@constructorOnly ictx: Context) extends TreeMap
           }
           finally inQuoteOrSplice = old
 
+        case tree @ SplicedType(splicedTree) =>
+          val old = inQuoteOrSplice
+          inQuoteOrSplice = true
+          try transformSpliceType(splicedTree, tree)
+          finally inQuoteOrSplice = old
+
         case Block(stats, _) =>
           val last = enteredSyms
           stats.foreach(markDef)

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

@@ -1450,6 +1450,10 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
             level -= 1
             try apply(syms, body)
             finally level += 1
+          case SplicedType(body) =>
+            level -= 1
+            try apply(syms, body)
+            finally level += 1
           case _ =>
             foldOver(syms, tree)
         }