Avoid using call in inlinedContext

Author: nicolasstucki

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

@@ -1246,7 +1246,9 @@ object Trees {
      *  innermost enclosing call for which the inlined version is currently
      *  processed.
      */
-    protected def inlineContext(call: Tree)(using Context): Context = ctx
+    protected def inlineContext(pos: SourcePosition)(using Context): Context = ctx
+
+    protected def outlineContext(using Context): Context = ctx
 
     abstract class TreeMap(val cpy: TreeCopier = inst.cpy) { self =>
       def transform(tree: Tree)(using Context): Tree = {
@@ -1304,7 +1306,8 @@ object Trees {
             case SeqLiteral(elems, elemtpt) =>
               cpy.SeqLiteral(tree)(transform(elems), transform(elemtpt))
             case Inlined(call, bindings, expansion) =>
-              cpy.Inlined(tree)(call, transformSub(bindings), transform(expansion)(using inlineContext(call)))
+              val ctx1 = if call.isEmpty then outlineContext else inlineContext(tree.sourcePos)
+              cpy.Inlined(tree)(call, transformSub(bindings), transform(expansion)(using ctx1))
             case TypeTree() =>
               tree
             case SingletonTypeTree(ref) =>
@@ -1442,7 +1445,8 @@ object Trees {
             case SeqLiteral(elems, elemtpt) =>
               this(this(x, elems), elemtpt)
             case Inlined(call, bindings, expansion) =>
-              this(this(x, bindings), expansion)(using inlineContext(call))
+              val ctx1 = if call.isEmpty then outlineContext else inlineContext(tree.sourcePos)
+              this(this(x, bindings), expansion)(using ctx1)
             case TypeTree() =>
               x
             case SingletonTypeTree(ref) =>

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

@@ -1240,21 +1240,25 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     var count: Int = 0
   }
 
-  /** Record an enclosing inlined call.
-   *  EmptyTree calls (for parameters) cancel the next-enclosing call in the list instead of being added to it.
-   *  We assume parameters are never nested inside parameters.
-   */
-  override def inlineContext(call: Tree)(using Context): Context = {
+  /** Record an enclosing inlined call position. */
+  override def inlineContext(pos: SourcePosition)(using Context): Context = {
+    // We assume enclosingInlineds is already normalized, and only process the new call with the head.
+    val oldIC = enclosingInlineds
+    val newIC = pos :: oldIC
+
+    val ctx1 = ctx.fresh.setProperty(InlinedCalls, newIC)
+    if oldIC.isEmpty then ctx1.setProperty(InlinedTrees, new Counter) else ctx1
+  }
+
+  /** Record an remove the last inlined call position. */
+  override def outlineContext(using Context): Context = {
     // We assume enclosingInlineds is already normalized, and only process the new call with the head.
     val oldIC = enclosingInlineds
 
     val newIC =
-      if call.isEmpty then
-        oldIC match
-          case t1 :: ts2 => ts2
-          case _ => oldIC
-      else
-        call.sourcePos :: oldIC
+      oldIC match
+        case t1 :: ts2 => ts2
+        case _ => oldIC
 
     val ctx1 = ctx.fresh.setProperty(InlinedCalls, newIC)
     if oldIC.isEmpty then ctx1.setProperty(InlinedTrees, new Counter) else ctx1

compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala

@@ -57,7 +57,7 @@ object PickledQuotes {
     val unpickled = withMode(Mode.ReadPositions)(
       unpickle(tastyBytes, splices, isType = false))
     val Inlined(call, Nil, expnasion) = unpickled
-    val inlineCtx = inlineContext(call)
+    val inlineCtx = inlineContext(unpickled.sourcePos)
     val expansion1 = spliceTypes(expnasion, splices)(using inlineCtx)
     val expansion2 = spliceTerms(expansion1, splices)(using inlineCtx)
     cpy.Inlined(unpickled)(call, Nil, expansion2)

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

@@ -394,7 +394,8 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
       case tree: Inlined =>
         inContext(prepInlined(tree, start)(using outerCtx)) {
           val bindings = transformSpecificTrees(tree.bindings, start)
-          val expansion = transformTree(tree.expansion, start)(using inlineContext(tree.call))
+          val ctx1 = if tree.call.isEmpty then outlineContext else inlineContext(tree.sourcePos)
+          val expansion = transformTree(tree.expansion, start)(using ctx1)
           goInlined(cpy.Inlined(tree)(tree.call, bindings, expansion), start)
         }
       case tree: Return =>

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

@@ -289,9 +289,9 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
               super.transform(tree1)
           }
         case Inlined(call, bindings, expansion) if !call.isEmpty =>
-          val pos = call.sourcePos
+          val pos = tree.sourcePos
           val callTrace = Inliner.inlineCallTrace(call.symbol, pos)(using ctx.withSource(pos.source))
-          cpy.Inlined(tree)(callTrace, transformSub(bindings), transform(expansion)(using inlineContext(call)))
+          cpy.Inlined(tree)(callTrace, transformSub(bindings), transform(expansion)(using inlineContext(tree.sourcePos)))
         case templ: Template =>
           withNoCheckNews(templ.parents.flatMap(newPart)) {
             forwardParamAccessors(templ)

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

@@ -39,13 +39,13 @@ class YCheckPositions extends Phase {
                 assert(bindings.isEmpty)
                 val old = sources
                 sources = old.tail
-                traverse(expansion)(using inlineContext(EmptyTree).withSource(sources.head))
+                traverse(expansion)(using outlineContext.withSource(sources.head))
                 sources = old
               case Inlined(call, bindings, expansion) =>
                 bindings.foreach(traverse(_))
                 sources = call.symbol.topLevelClass.source :: sources
                 if (!isMacro(call)) // FIXME macro implementations can drop Inlined nodes. We should reinsert them after macro expansion based on the positions of the trees
-                  traverse(expansion)(using inlineContext(call).withSource(sources.head))
+                  traverse(expansion)(using inlineContext(tree.sourcePos).withSource(sources.head))
                 sources = sources.tail
               case _ => traverseChildren(tree)
             }

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

@@ -652,7 +652,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(using Context) {
 
     val inlineTyper = new InlineTyper(ctx.reporter.errorCount)
 
-    val inlineCtx = inlineContext(call).fresh.setTyper(inlineTyper).setNewScope
+    val inlineCtx = inlineContext(call.sourcePos).fresh.setTyper(inlineTyper).setNewScope
 
     def inlinedFromOutside(tree: Tree)(span: Span): Tree =
       Inlined(EmptyTree, Nil, tree)(using ctx.withSource(inlinedMethod.topLevelClass.source)).withSpan(span)

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

@@ -1627,7 +1627,10 @@ class Typer extends Namer
 
   def typedInlined(tree: untpd.Inlined, pt: Type)(using Context): Tree = {
     val (bindings1, exprCtx) = typedBlockStats(tree.bindings)
-    val expansion1 = typed(tree.expansion, pt)(using inlineContext(tree.call)(using exprCtx))
+    val ctx1 =
+      if tree.call.isEmpty then outlineContext(using exprCtx)
+      else inlineContext(tree.sourcePos)(using exprCtx)
+    val expansion1 = typed(tree.expansion, pt)(using ctx1)
     assignType(cpy.Inlined(tree)(tree.call, bindings1.asInstanceOf[List[MemberDef]], expansion1),
         bindings1, expansion1)
   }