Cleanup implementation of Reposition

Trees now have sources that can be used directly without the need of `enclosingInlineds`
to track the current source. This new implemetation simply uses the tree positions
directly and does not need to keep the context in sync with the `enclosingInlineds`.

Author: nicolasstucki

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

@@ -155,7 +155,7 @@ object Inliner {
     if (enclosingInlineds.nonEmpty) inlined // Remove in the outer most inlined call
     else reposition(inlined, inlined.call.span)
 
-  def reposition(tree: Tree, span: Span)(implicit ctx: Context): Tree = {
+  def reposition(tree: Tree, callSpan: Span)(implicit ctx: Context): Tree = {
     val curSource = ctx.compilationUnit.source
 
     // Tree copier that changes the source of all trees to `curSource`
@@ -169,39 +169,31 @@ object Inliner {
     /** Removes all Inlined trees, replacing them with blocks.
      *  Repositions all trees directly inside an inlined expansion of a non empty call to the position of the call.
      *  Any tree directly inside an empty call (inlined in the inlined code) retains their position.
+     *
+     *  Until we implement JSR-45, we cannot represent in output positions in other source files.
+     *  So, reposition inlined code from other files with the call position.
      */
     class Reposition extends TreeMap(cpyWithNewSource) {
-      def finalize(tree: Tree, copied: untpd.Tree) =
-        copied.withSpan(tree.span).withAttachmentsFrom(tree).withTypeUnchecked(tree.tpe)
-
-      def reposition(tree: Tree)(implicit ctx: Context): Tree = enclosingInlineds match {
-        case call :: _ if call.symbol.source != curSource =>
-          tree match {
-            case _: EmptyTree[?] | _: EmptyValDef[?] => tree
-            case _ =>
-              // Until we implement JSR-45, we cannot represent in output positions in other source files.
-              // So, reposition inlined code from other files with the call position:
-              tree.withSpan(span)
-          }
-        case _ => tree
-      }
 
       override def transform(tree: Tree)(implicit ctx: Context): Tree = {
-        val transformed = reposition(tree match {
-          case tree: Inlined =>
-            tpd.seq(transformSub(tree.bindings), transform(tree.expansion)(inlineContext(tree.call)))(ctx.withSource(curSource)) : Tree
-          case tree: Ident => finalize(tree, untpd.Ident(tree.name)(curSource))
-          case tree: Literal => finalize(tree, untpd.Literal(tree.const)(curSource))
-          case tree: This => finalize(tree, untpd.This(tree.qual)(curSource))
-          case tree: JavaSeqLiteral => finalize(tree, untpd.JavaSeqLiteral(transform(tree.elems), transform(tree.elemtpt))(curSource))
-          case tree: SeqLiteral => finalize(tree, untpd.SeqLiteral(transform(tree.elems), transform(tree.elemtpt))(curSource))
-          case tree: TypeTree => tpd.TypeTree(tree.tpe)(ctx.withSource(curSource)).withSpan(tree.span)
-          case tree: Bind => finalize(tree, untpd.Bind(tree.name, transform(tree.body))(curSource))
+        def finalize(copied: untpd.Tree) =
+          val span = if tree.source == curSource then tree.span else callSpan
+          copied.withSpan(span).withAttachmentsFrom(tree).withTypeUnchecked(tree.tpe)
+
+        given as Context = ctx.withSource(curSource)
+
+        tree match {
+          case tree: Inlined => transform(seq(tree.bindings, tree.expansion).withSpan(tree.span)) // remove Inlined by making them blocks
+          case tree: Ident => finalize(untpd.Ident(tree.name)(curSource))
+          case tree: Literal => finalize(untpd.Literal(tree.const)(curSource))
+          case tree: This => finalize(untpd.This(tree.qual)(curSource))
+          case tree: JavaSeqLiteral => finalize(untpd.JavaSeqLiteral(transform(tree.elems), transform(tree.elemtpt))(curSource))
+          case tree: SeqLiteral => finalize(untpd.SeqLiteral(transform(tree.elems), transform(tree.elemtpt))(curSource))
+          case tree: Bind => finalize(untpd.Bind(tree.name, transform(tree.body))(curSource))
+          case tree: TypeTree => finalize(tpd.TypeTree(tree.tpe))
           case tree: DefTree => super.transform(tree).setDefTree
           case _ => super.transform(tree)
-        })
-        assert(transformed.isInstanceOf[EmptyTree[?]] || transformed.isInstanceOf[EmptyValDef[?]] || transformed.source == curSource)
-        transformed
+        }
       }
     }