Beta-reduce under blocks

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

@@ -48,13 +48,22 @@ object BetaReduce:
   import ast.tpd._
 
   /** Beta-reduces a call to `fn` with arguments `argSyms` or returns `tree` */
-  def apply(tree: Apply, fn: Tree, args: List[Tree])(using Context): Tree =
+  def apply(original: Tree, fn: Tree, args: List[Tree])(using Context): Tree =
     fn match
-      case Typed(expr, _) => BetaReduce(tree, expr, args)
-      case Block(Nil, expr) => BetaReduce(tree, expr, args)
-      case Inlined(_, Nil, expr) => BetaReduce(tree, expr, args)
-      case Block((anonFun: DefDef) :: Nil, closure: Closure) => BetaReduce(anonFun, args)
-      case _ => tree
+      case Typed(expr, _) =>
+        BetaReduce(original, expr, args)
+      case Block((anonFun: DefDef) :: Nil, closure: Closure) =>
+        BetaReduce(anonFun, args)
+      case Block(stats, expr) =>
+        val tree = BetaReduce(original, expr, args)
+        if tree eq original then original
+        else cpy.Block(fn)(stats, tree)
+      case Inlined(call, bindings, expr) =>
+        val tree = BetaReduce(original, expr, args)
+        if tree eq original then original
+        else cpy.Inlined(fn)(call, bindings, tree)
+      case _ =>
+        original
   end apply
 
   /** Beta-reduces a call to `ddef` with arguments `argSyms` */

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

@@ -368,14 +368,14 @@ class InlineBytecodeTests extends DottyBytecodeTest {
       val instructions = instructionsFromMethod(fun)
       val expected =
         List(
-          IntOp(BIPUSH, 10)
-          , VarOp(ISTORE, 1)
-          , VarOp(ILOAD, 1)
-          , Op(ICONST_1)
-          , Op(IADD)
-          , VarOp(ISTORE, 1)
-          , VarOp(ILOAD, 1)
-          , Op(IRETURN)
+          IntOp(BIPUSH, 10),
+          VarOp(ISTORE, 1),
+          VarOp(ILOAD, 1),
+          Op(ICONST_1),
+          Op(IADD),
+          VarOp(ISTORE, 1),
+          VarOp(ILOAD, 1),
+          Op(IRETURN),
         )
       assert(instructions == expected,
         "`f` was not properly inlined in `fun`\n" + diffInstructions(instructions, expected))
@@ -524,4 +524,35 @@ class InlineBytecodeTests extends DottyBytecodeTest {
 
     }
   }
+
+  @Test def beta_reduce_under_block = {
+    val source = """class Test:
+                   |  def test =
+                   |    {
+                   |      val a = 3
+                   |      (i: Int) => i + a
+                   |    }.apply(2)
+                 """.stripMargin
+
+    checkBCode(source) { dir =>
+      val clsIn      = dir.lookupName("Test.class", directory = false).input
+      val clsNode    = loadClassNode(clsIn)
+
+      val fun = getMethod(clsNode, "test")
+      val instructions = instructionsFromMethod(fun)
+      val expected =
+        List(
+          Op(ICONST_3),
+          VarOp(ISTORE, 1),
+          Op(ICONST_2),
+          VarOp(ILOAD, 1),
+          Op(IADD),
+          Op(IRETURN),
+        )
+
+      assert(instructions == expected,
+        "`i was not properly beta-reduced in `test`\n" + diffInstructions(instructions, expected))
+
+    }
+  }
 }

tests/run-staging/i3876-b.check

@@ -1,5 +1,5 @@
 6
 {
   def f(x: scala.Int): scala.Int = x.+(x)
-  ((`x₂`: scala.Int) => f(`x₂`))
-}.apply(3)
+  f(3)
+}