Fix #4947: Do not replace positions of inlined arguments

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

@@ -149,12 +149,36 @@ object Inliner {
 
   /** Replace `Inlined` node by a block that contains its bindings and expansion */
   def dropInlined(inlined: tpd.Inlined)(implicit ctx: Context): Tree = {
-    val reposition = new TreeMap {
-      override def transform(tree: Tree)(implicit ctx: Context): Tree = {
-        super.transform(tree).withPos(inlined.call.pos)
+    if (enclosingInlineds.nonEmpty) inlined // Remove in the outer most inlined call
+    else {
+      // Position used for any tree that was inlined (including recursive inlines)
+      val inlinedAtPos = inlined.call.pos
+
+      /** Removes all Inlined trees, replacing them with blocks.
+       *  Repositions all trees directly inside an inlined expantion 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.
+       */
+      class Reposition extends TreeMap {
+        override def transform(tree: Tree)(implicit ctx: Context): Tree = {
+          tree match {
+            case tree: Inlined => transformInline(tree)
+            case _ =>
+              val transformed = super.transform(tree)
+              enclosingInlineds match {
+                case call :: _ if call.symbol.topLevelClass != ctx.owner.topLevelClass =>
+                  // reposition tree inlined from some other file
+                  transformed.withPos(inlinedAtPos)
+                case _ => transformed
+              }
+          }
+        }
+        def transformInline(tree: tpd.Inlined)(implicit ctx: Context): Tree = {
+          tpd.seq(transformSub(tree.bindings), transform(tree.expansion)(inlineContext(tree.call)))
+        }
       }
+
+      (new Reposition).transformInline(inlined)
     }
-    tpd.seq(inlined.bindings, reposition.transform(inlined.expansion))
   }
 }
 

compiler/test/dotty/tools/backend/jvm/DottyBytecodeTests.scala

@@ -335,4 +335,5 @@ class TestBCode extends DottyBytecodeTest {
       assert(!fooInvoke, "foo should not be called\n")
     }
   }
+
 }

compiler/test/dotty/tools/backend/jvm/InlineBytecodeTests.scala

@@ -3,6 +3,10 @@ package dotty.tools.backend.jvm
 import org.junit.Assert._
 import org.junit.Test
 
+import scala.tools.asm.Opcodes._
+
+import scala.collection.JavaConverters._
+
 class InlineBytecodeTests extends DottyBytecodeTest {
   import ASMConverters._
   @Test def inlineUnit = {
@@ -37,4 +41,240 @@ class InlineBytecodeTests extends DottyBytecodeTest {
         diffInstructions(instructions2, instructions3))
     }
   }
+
+  @Test def i4947 = {
+    val source = """class Foo {
+                   |  transparent def track[T](f: => T): T = {
+                   |    println("tracking") // line 3
+                   |    f // line 4
+                   |  }
+                   |  def main(args: Array[String]): Unit = { // line 6
+                   |    track { // line 7
+                   |      println("abc") // line 8
+                   |      track { // line 9
+                   |        println("inner") // line 10
+                   |      }
+                   |    } // line 11
+                   |  }
+                   |}
+                 """.stripMargin
+
+    checkBCode(source) { dir =>
+      val clsIn      = dir.lookupName("Foo.class", directory = false).input
+      val clsNode    = loadClassNode(clsIn, skipDebugInfo = false)
+
+      val track = clsNode.methods.asScala.find(_.name == "track")
+      assert(track.isEmpty, "method `track` should have been erased")
+
+      val main = getMethod(clsNode, "main")
+      val instructions = instructionsFromMethod(main)
+      val expected =
+        List(
+          Label(0),
+          LineNumber(6, Label(0)),
+          LineNumber(3, Label(0)),
+          Field(GETSTATIC, "scala/Predef$", "MODULE$", "Lscala/Predef$;"),
+          Ldc(LDC, "tracking"),
+          Invoke(INVOKEVIRTUAL, "scala/Predef$", "println", "(Ljava/lang/Object;)V", false),
+          Label(6),
+          LineNumber(8, Label(6)),
+          Field(GETSTATIC, "scala/Predef$", "MODULE$", "Lscala/Predef$;"),
+          Ldc(LDC, "abc"),
+          Invoke(INVOKEVIRTUAL, "scala/Predef$", "println","(Ljava/lang/Object;)V", false),
+          Label(11),
+          LineNumber(3, Label(11)),
+          Field(GETSTATIC, "scala/Predef$", "MODULE$", "Lscala/Predef$;"),
+          Ldc(LDC, "tracking"),
+          Invoke(INVOKEVIRTUAL, "scala/Predef$", "println","(Ljava/lang/Object;)V", false),
+          Label(16),
+          LineNumber(10, Label(16)),
+          Field(GETSTATIC, "scala/Predef$", "MODULE$", "Lscala/Predef$;"),
+          Ldc(LDC, "inner"),
+          Invoke(INVOKEVIRTUAL, "scala/Predef$", "println","(Ljava/lang/Object;)V", false),
+          Op(RETURN),
+          Label(22)
+        )
+        assert(instructions == expected,
+          "`track` was not properly inlined in `main`\n" + diffInstructions(instructions, expected))
+
+    }
+  }
+
+  @Test def i4947b = {
+    val source = """class Foo {
+                   |  transparent def track2[T](f: => T): T = {
+                   |    println("tracking2") // line 3
+                   |    f // line 4
+                   |  }
+                   |  transparent def track[T](f: => T): T = {
+                   |    println("tracking") // line 7
+                   |    track2 { // line 8
+                   |      f // line 9
+                   |    }
+                   |  }
+                   |  def main(args: Array[String]): Unit = { // line 12
+                   |    track { // line 13
+                   |      println("abc") // line 14
+                   |    }
+                   |  }
+                   |}
+                 """.stripMargin
+
+    checkBCode(source) { dir =>
+      val clsIn      = dir.lookupName("Foo.class", directory = false).input
+      val clsNode    = loadClassNode(clsIn, skipDebugInfo = false)
+
+      val track = clsNode.methods.asScala.find(_.name == "track")
+      assert(track.isEmpty, "method `track` should have been erased")
+
+      val track2 = clsNode.methods.asScala.find(_.name == "track2")
+      assert(track2.isEmpty, "method `track2` should have been erased")
+
+      val main = getMethod(clsNode, "main")
+      val instructions = instructionsFromMethod(main)
+      val expected =
+        List(
+          Label(0),
+          LineNumber(12, Label(0)),
+          LineNumber(7, Label(0)),
+          Field(GETSTATIC, "scala/Predef$", "MODULE$", "Lscala/Predef$;"),
+          Ldc(LDC, "tracking"),
+          Invoke(INVOKEVIRTUAL, "scala/Predef$", "println", "(Ljava/lang/Object;)V", false),
+          Label(6),
+          LineNumber(3, Label(6)),
+          Field(GETSTATIC, "scala/Predef$", "MODULE$", "Lscala/Predef$;"),
+          Ldc(LDC, "tracking2"),
+          Invoke(INVOKEVIRTUAL, "scala/Predef$", "println","(Ljava/lang/Object;)V", false),
+          Label(11),
+          LineNumber(14, Label(11)),
+          Field(GETSTATIC, "scala/Predef$", "MODULE$", "Lscala/Predef$;"),
+          Ldc(LDC, "abc"),
+          Invoke(INVOKEVIRTUAL, "scala/Predef$", "println","(Ljava/lang/Object;)V", false),
+          Op(RETURN),
+          Label(17)
+        )
+        assert(instructions == expected,
+          "`track` was not properly inlined in `main`\n" + diffInstructions(instructions, expected))
+
+    }
+  }
+
+  @Test def i4947c = {
+    val source = """class Foo {
+                   |  transparent def track2[T](f: => T): T = {
+                   |    println("tracking2") // line 3
+                   |    f // line 4
+                   |  }
+                   |  transparent def track[T](f: => T): T = {
+                   |    track2 { // line 7
+                   |      println("fgh") // line 8
+                   |      f // line 9
+                   |    }
+                   |  }
+                   |  def main(args: Array[String]): Unit = { // line 12
+                   |    track { // line 13
+                   |      println("abc") // line 14
+                   |    }
+                   |  }
+                   |}
+                 """.stripMargin
+
+    checkBCode(source) { dir =>
+      val clsIn      = dir.lookupName("Foo.class", directory = false).input
+      val clsNode    = loadClassNode(clsIn, skipDebugInfo = false)
+
+      val track = clsNode.methods.asScala.find(_.name == "track")
+      assert(track.isEmpty, "method `track` should have been erased")
+
+      val track2 = clsNode.methods.asScala.find(_.name == "track2")
+      assert(track2.isEmpty, "method `track2` should have been erased")
+
+      val main = getMethod(clsNode, "main")
+      val instructions = instructionsFromMethod(main)
+      val expected =
+        List(
+          Label(0),
+          LineNumber(12, Label(0)),
+          LineNumber(3, Label(0)),
+          Field(GETSTATIC, "scala/Predef$", "MODULE$", "Lscala/Predef$;"),
+          Ldc(LDC, "tracking2"),
+          Invoke(INVOKEVIRTUAL, "scala/Predef$", "println", "(Ljava/lang/Object;)V", false),
+          Label(6),
+          LineNumber(8, Label(6)),
+          Field(GETSTATIC, "scala/Predef$", "MODULE$", "Lscala/Predef$;"),
+          Ldc(LDC, "fgh"),
+          Invoke(INVOKEVIRTUAL, "scala/Predef$", "println","(Ljava/lang/Object;)V", false),
+          Label(11),
+          LineNumber(14, Label(11)),
+          Field(GETSTATIC, "scala/Predef$", "MODULE$", "Lscala/Predef$;"),
+          Ldc(LDC, "abc"),
+          Invoke(INVOKEVIRTUAL, "scala/Predef$", "println","(Ljava/lang/Object;)V", false),
+          Op(RETURN),
+          Label(17)
+        )
+        assert(instructions == expected,
+          "`track` was not properly inlined in `main`\n" + diffInstructions(instructions, expected))
+
+    }
+  }
+
+  @Test def i4947d = {
+    val source = """class Foo {
+                   |  transparent def track2[T](f: => T): T = {
+                   |    println("tracking2") // line 3
+                   |    f // line 4
+                   |  }
+                   |  transparent def track[T](f: => T): T = {
+                   |    track2 { // line 7
+                   |      track2 { // line 8
+                   |        f // line 9
+                   |      }
+                   |    }
+                   |  }
+                   |  def main(args: Array[String]): Unit = { // line 13
+                   |    track { // line 14
+                   |      println("abc") // line 15
+                   |    }
+                   |  }
+                   |}
+                 """.stripMargin
+
+    checkBCode(source) { dir =>
+      val clsIn      = dir.lookupName("Foo.class", directory = false).input
+      val clsNode    = loadClassNode(clsIn, skipDebugInfo = false)
+
+      val track = clsNode.methods.asScala.find(_.name == "track")
+      assert(track.isEmpty, "method `track` should have been erased")
+
+      val track2 = clsNode.methods.asScala.find(_.name == "track2")
+      assert(track2.isEmpty, "method `track2` should have been erased")
+
+      val main = getMethod(clsNode, "main")
+      val instructions = instructionsFromMethod(main)
+      val expected =
+        List(
+          Label(0),
+          LineNumber(13, Label(0)),
+          LineNumber(3, Label(0)),
+          Field(GETSTATIC, "scala/Predef$", "MODULE$", "Lscala/Predef$;"),
+          Ldc(LDC, "tracking2"),
+          Invoke(INVOKEVIRTUAL, "scala/Predef$", "println", "(Ljava/lang/Object;)V", false),
+          Label(6),
+          LineNumber(3, Label(6)),
+          Field(GETSTATIC, "scala/Predef$", "MODULE$", "Lscala/Predef$;"),
+          Ldc(LDC, "tracking2"),
+          Invoke(INVOKEVIRTUAL, "scala/Predef$", "println", "(Ljava/lang/Object;)V", false),
+          Label(11),
+          LineNumber(15, Label(11)),
+          Field(GETSTATIC, "scala/Predef$", "MODULE$", "Lscala/Predef$;"),
+          Ldc(LDC, "abc"),
+          Invoke(INVOKEVIRTUAL, "scala/Predef$", "println","(Ljava/lang/Object;)V", false),
+          Op(RETURN),
+          Label(17)
+        )
+        assert(instructions == expected,
+          "`track` was not properly inlined in `main`\n" + diffInstructions(instructions, expected))
+
+    }
+  }
 }

tests/run/i4947.check

@@ -0,0 +1,4 @@
+track: Test$.main(i4947.scala:4)
+track: Test$.main(i4947.scala:5)
+main1: Test$.main(i4947.scala:15)
+main2: Test$.main(i4947.scala:16)

tests/run/i4947.scala

@@ -0,0 +1,20 @@
+object Test {
+
+  transparent def track[T](f: => T): T = {
+    printStack("track")
+    printStack("track")
+    f
+  }
+
+  def printStack(tag: String): Unit = {
+    println(tag + ": "+ new Exception().getStackTrace().apply(1))
+  }
+
+  def main(args: Array[String]): Unit = {
+    track {
+      printStack("main1")
+      printStack("main2")
+    }
+  }
+
+}

tests/run/i4947b.check

@@ -0,0 +1,4 @@
+track: Test$.main(Test_2.scala:3)
+track: Test$.main(Test_2.scala:3)
+main1: Test$.main(Test_2.scala:4)
+main2: Test$.main(Test_2.scala:5)

tests/run/i4947b/Lib_1.scala

@@ -0,0 +1,10 @@
+object Lib {
+  transparent def track[T](f: => T): T = {
+    printStack("track")
+    printStack("track")
+    f
+  }
+  def printStack(tag: String): Unit = {
+    println(tag + ": "+ new Exception().getStackTrace().apply(1))
+  }
+}

tests/run/i4947b/Test_2.scala

@@ -0,0 +1,9 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    Lib.track {
+      Lib.printStack("main1")
+      Lib.printStack("main2")
+    }
+  }
+
+}