Rename SplicedExpr.{spliced=>expr}

Author: nicolasstucki

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

@@ -682,7 +682,7 @@ object Trees {
     type ThisTree[+T <: Untyped] = QuotedExpr[T]
   }
 
-  case class SplicedExpr[+T <: Untyped] private[ast] (spliced: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
+  case class SplicedExpr[+T <: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends TermTree[T] {
     type ThisTree[+T <: Untyped] = SplicedExpr[T]
   }
@@ -1273,9 +1273,9 @@ object Trees {
         case tree: QuotedExpr if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
         case _ => finalize(tree, untpd.QuotedExpr(expr, tpt)(sourceFile(tree)))
       }
-      def SplicedExpr(tree: Tree)(spliced: Tree, tpt: Tree)(using Context): SplicedExpr = tree match {
-        case tree: SplicedExpr if (spliced eq tree.spliced) && (tpt eq tree.tpt) => tree
-        case _ => finalize(tree, untpd.SplicedExpr(spliced, tpt)(sourceFile(tree)))
+      def SplicedExpr(tree: Tree)(expr: Tree, tpt: Tree)(using Context): SplicedExpr = tree match {
+        case tree: SplicedExpr if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
+        case _ => finalize(tree, untpd.SplicedExpr(expr, tpt)(sourceFile(tree)))
       }
       def SingletonTypeTree(tree: Tree)(ref: Tree)(using Context): SingletonTypeTree = tree match {
         case tree: SingletonTypeTree if (ref eq tree.ref) => tree
@@ -1382,8 +1382,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 SplicedExpr(tree: SplicedExpr)(spliced: Tree = tree.spliced, tpt: Tree = tree.tpt)(using Context): SplicedExpr =
-        SplicedExpr(tree: Tree)(spliced, tpt)
+      def SplicedExpr(tree: SplicedExpr)(expr: Tree = tree.expr, tpt: Tree = tree.tpt)(using Context): SplicedExpr =
+        SplicedExpr(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)
 
@@ -1518,8 +1518,8 @@ object Trees {
               if (trees1 eq trees) tree else Thicket(trees1)
             case tree @ QuotedExpr(expr, tpt) =>
               cpy.QuotedExpr(tree)(transform(expr), transform(tpt))
-            case tree @ SplicedExpr(spliced, tpt) =>
-              cpy.SplicedExpr(tree)(transform(spliced), transform(tpt))
+            case tree @ SplicedExpr(expr, tpt) =>
+              cpy.SplicedExpr(tree)(transform(expr), transform(tpt))
             case tree @ Hole(_, _, args, content, tpt) =>
               cpy.Hole(tree)(args = transform(args), content = transform(content), tpt = transform(tpt))
             case _ =>
@@ -1663,8 +1663,8 @@ object Trees {
               this(x, ts)
             case QuotedExpr(expr, tpt) =>
               this(this(x, expr), tpt)
-            case SplicedExpr(spliced, tpt) =>
-              this(this(x, spliced), tpt)
+            case SplicedExpr(expr, tpt) =>
+              this(this(x, expr), tpt)
             case Hole(_, _, args, content, tpt) =>
               this(this(this(x, args), content), tpt)
             case _ =>

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

@@ -173,8 +173,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def QuotedExpr(expr: Tree, tpt: Tree)(using Context): QuotedExpr =
     ta.assignType(untpd.QuotedExpr(expr, tpt), tpt)
 
-  def SplicedExpr(spliced: Tree, tpt: Tree)(using Context): SplicedExpr =
-    ta.assignType(untpd.SplicedExpr(spliced, tpt), tpt)
+  def SplicedExpr(expr: Tree, tpt: Tree)(using Context): SplicedExpr =
+    ta.assignType(untpd.SplicedExpr(expr, tpt), tpt)
 
   def TypeTree(tp: Type, inferred: Boolean = false)(using Context): TypeTree =
     (if inferred then untpd.InferredTypeTree() else untpd.TypeTree()).withType(tp)

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

@@ -402,7 +402,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   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 QuotedExpr(expr: Tree, tpt: Tree)(implicit src: SourceFile): QuotedExpr = new QuotedExpr(expr, tpt)
-  def SplicedExpr(spliced: Tree, tpt: Tree)(implicit src: SourceFile): SplicedExpr = new SplicedExpr(spliced, tpt)
+  def SplicedExpr(expr: Tree, tpt: Tree)(implicit src: SourceFile): SplicedExpr = new SplicedExpr(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)

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -673,12 +673,12 @@ class TreePickler(pickler: TastyPickler) {
               .appliedTo(expr)
               .withSpan(tree.span)
           )
-        case SplicedExpr(spliced, tpt) =>
+        case SplicedExpr(expr, tpt) =>
           pickleTree(
             // scala.quoted.runtime.Expr.splice[<tpt>](<spliced>)
             ref(defn.QuotedRuntime_exprSplice)
               .appliedToTypeTree(tpt)
-              .appliedTo(spliced)
+              .appliedTo(expr)
               .withSpan(tree.span)
           )
         case Hole(_, idx, args, _, tpt) =>

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

@@ -834,10 +834,10 @@ class Inliner(val call: tpd.Tree)(using Context):
 
     override def typedSplicedExpr(tree: untpd.SplicedExpr, pt: Type)(using Context): Tree =
       super.typedSplicedExpr(tree, pt) match
-        case tree1 @ SplicedExpr(spliced, tpt)
+        case tree1 @ SplicedExpr(expr, tpt)
             if StagingLevel.level == 0
             && !hasInliningErrors =>
-          val expanded = expandMacro(spliced, tree1.srcPos)
+          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

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

@@ -723,9 +723,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case QuotedExpr(expr, tpt) =>
         val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(printDebug)
         keywordStr("'") ~ tptText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
-      case SplicedExpr(spliced, tpt) =>
+      case SplicedExpr(expr, tpt) =>
         val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(printDebug)
-        keywordStr("$") ~ tptText ~ keywordStr("{") ~ toTextGlobal(spliced) ~ keywordStr("}")
+        keywordStr("$") ~ tptText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
       case Hole(isTermHole, idx, args, content, tpt) =>
         val (prefix, postfix) = if isTermHole then ("{{{", "}}}") else ("[[[", "]]]")
         val argsText = toTextGlobal(args, ", ")

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

@@ -153,9 +153,9 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
   override def transformOther(tree: Tree)(using Context): Tree = tree match {
     case tree: Export => EmptyTree
     case tree: NamedArg => transformAllDeep(tree.arg)
-    case tree @ SplicedExpr(spliced, tpt) =>
+    case tree @ SplicedExpr(expr, tpt) =>
       assert(dotty.tools.dotc.inlines.Inlines.inInlineMethod)
-      cpy.SplicedExpr(tree)(transformAllDeep(spliced), transformAllDeep(tpt))
+      cpy.SplicedExpr(tree)(transformAllDeep(expr), transformAllDeep(tpt))
     case tree => if (tree.isType) toTypeTree(tree) else tree
   }
 

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

@@ -113,13 +113,13 @@ class Splicing extends MacroTransform:
       tree match
         case tree: SplicedExpr =>
           if level > 1 then
-            val spliced1 = super.transform(tree.spliced)(using spliceContext)
-            cpy.SplicedExpr(tree)(spliced1, tree.tpt)
+            val expr1 = super.transform(tree.expr)(using spliceContext)
+            cpy.SplicedExpr(tree)(expr1, tree.tpt)
           else
             val holeIdx = numHoles
             numHoles += 1
             val splicer = SpliceTransformer(ctx.owner, quotedDefs.contains)
-            val newSplicedCode1 = splicer.transformSplice(tree.spliced, tree.tpe, holeIdx)(using spliceContext)
+            val newSplicedCode1 = splicer.transformSplice(tree.expr, tree.tpe, holeIdx)(using spliceContext)
             val newSplicedCode2 = Level0QuoteTransformer.transform(newSplicedCode1)(using spliceContext)
             newSplicedCode2
         case tree: TypeDef if tree.symbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
@@ -234,9 +234,9 @@ class Splicing extends MacroTransform:
         case tree @ Assign(lhs: RefTree, rhs) =>
           if isCaptured(lhs.symbol) then transformSplicedAssign(tree)
           else super.transform(tree)
-        case SplicedExpr(spliced, tpt) =>
-          val spliced1 = transform(spliced)(using spliceContext)
-          cpy.SplicedExpr(tree)(spliced1, tpt)
+        case SplicedExpr(expr, tpt) =>
+          val expr1 = transform(expr)(using spliceContext)
+          cpy.SplicedExpr(tree)(expr1, tpt)
         case Apply(sel @ Select(app @ QuotedExpr(expr, tpt), nme.apply), quotesArgs) =>
           expr match
             case expr: RefTree if isCaptured(expr.symbol) =>

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

@@ -2055,8 +2055,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val splicedType = // Quotes ?=> Expr[T]
       defn.FunctionType(1, isContextual = true)
         .appliedTo(defn.QuotesClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(tpt1.tpe.widenSkolem))
-    val spliced1 = typed(tree.spliced, splicedType)(using StagingLevel.spliceContext)
-    assignType(cpy.SplicedExpr(tree)(spliced1, tpt1), tpt1)
+    val expr1 = typed(tree.expr, splicedType)(using StagingLevel.spliceContext)
+    assignType(cpy.SplicedExpr(tree)(expr1, tpt1), tpt1)
 
   def completeTypeTree(tree: untpd.TypeTree, pt: Type, original: untpd.Tree)(using Context): TypeTree =
     tree.withSpan(original.span).withAttachmentsFrom(original)