Cleanup unnecessary staging level updates

Author: nicolasstucki

compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala

@@ -91,9 +91,7 @@ object PrepareInlineable {
         }
 
       private def stagingContext(tree: Tree)(using Context): Context = tree match
-        case tree: Quote => StagingLevel.quoteContext
         case tree: Apply if tree.symbol eq defn.QuotedTypeModule_of => StagingLevel.quoteContext
-        case tree: Splice => StagingLevel.spliceContext
         case _ => ctx
     }
 

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

@@ -45,12 +45,8 @@ class Inlining extends MacroTransform {
         new TreeTraverser {
           def traverse(tree: Tree)(using Context): Unit =
             tree match
-              case _: Quote =>
-                traverseChildren(tree)(using StagingLevel.quoteContext)
               case _: GenericApply if tree.symbol == defn.QuotedTypeModule_of =>
                 traverseChildren(tree)(using StagingLevel.quoteContext)
-              case _: Splice =>
-                traverseChildren(tree)(using StagingLevel.spliceContext)
               case tree: RefTree if !Inlines.inInlineMethod && StagingLevel.level == 0 =>
                 assert(!tree.symbol.isInlineMethod, tree.show)
               case _ =>
@@ -99,12 +95,8 @@ class Inlining extends MacroTransform {
           val tree1 = super.transform(tree)
           if tree1.tpe.isError then tree1
           else Inlines.inlineCall(tree1)
-        case _: Quote =>
-          super.transform(tree)(using StagingLevel.quoteContext)
         case _: GenericApply if tree.symbol == defn.QuotedTypeModule_of =>
           super.transform(tree)(using StagingLevel.quoteContext)
-        case _: Splice =>
-          super.transform(tree)(using StagingLevel.spliceContext)
         case _: PackageDef =>
           super.transform(tree) match
             case tree1: PackageDef  =>

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

@@ -228,19 +228,10 @@ class Splicing extends MacroTransform:
         case tree @ Assign(lhs: RefTree, rhs) =>
           if isCaptured(lhs.symbol) then transformSplicedAssign(tree)
           else super.transform(tree)
-        case Splice(expr) =>
-          val expr1 = transform(expr)(using spliceContext)
-          cpy.Splice(tree)(expr1)
-        case Apply(sel @ Select(app @ Quote(expr), nme.apply), quotesArgs) =>
-          expr match
-            case expr: RefTree if isCaptured(expr.symbol) =>
-              capturedTerm(expr)
-            case _ =>
-              val newExpr = withCurrentQuote(quotesArgs.head) {
-                if level > 1 then transform(expr)(using quoteContext)
-                else transformLevel0QuoteContent(expr)(using quoteContext)
-              }
-              cpy.Apply(tree)(cpy.Select(sel)(cpy.Quote(app)(newExpr), nme.apply), quotesArgs)
+        case Apply(sel @ Select(app @ Quote(body), nme.apply), quotesArgs) =>
+          body match
+            case body: RefTree if isCaptured(body.symbol) => capturedTerm(body)
+            case _ => withCurrentQuote(quotesArgs.head) { super.transform(tree) }
         case Apply(TypeApply(typeof, List(tpt)), List(quotes))
         if tree.symbol == defn.QuotedTypeModule_of && containsCapturedType(tpt.tpe) =>
           val newContent = capturedPartTypes(tpt)
@@ -253,6 +244,9 @@ class Splicing extends MacroTransform:
               ref(capturedType(newContent))(using ctx.withSource(tree.source)).withSpan(tree.span)
         case CapturedApplication(fn, argss) =>
           transformCapturedApplication(tree, fn, argss)
+        case Quote(expr) if level == 0 =>
+          val newExpr = transformLevel0QuoteContent(expr)(using quoteContext)
+          cpy.Quote(tree)(newExpr)
         case _ =>
           super.transform(tree)