Support beta reduction of functions with opaque types

Author: nicolasstucki

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

@@ -86,6 +86,8 @@ object BetaReduce:
         recur(expr, argss).map(cpy.Inlined(fn)(call, bindings, _))
       case Typed(expr, tpt) =>
         recur(expr, argss)
+      case TypeApply(Select(expr, nme.asInstanceOfPM), List(tpt)) =>
+        recur(expr, argss)
       case _ => None
     tree match
       case Apply(Select(fn, nme.apply), args) if defn.isFunctionType(fn.tpe) =>

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

@@ -608,6 +608,37 @@ class InlineBytecodeTests extends DottyBytecodeTest {
     }
   }
 
+  @Test def beta_reduce_function_of_opaque_types = {
+    val source = """object foo:
+                   |  opaque type T = Int
+                   |  inline def apply(inline op: T => T): T = op(2)
+                   |
+                   |class Test:
+                   | def test = foo { n => n }
+                 """.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(
+          Field(GETSTATIC, "foo$", "MODULE$", "Lfoo$;"),
+          VarOp(ASTORE, 1),
+          VarOp(ALOAD, 1),
+          VarOp(ASTORE, 2),
+          Op(ICONST_2),
+          Op(IRETURN),
+        )
+
+      assert(instructions == expected,
+        "`i was not properly beta-reduced in `test`\n" + diffInstructions(instructions, expected))
+
+    }
+  }
+
   @Test def i9456 = {
     val source = """class Foo {
                    |  def test: Int = inline2(inline1(2.+))