JVM IR: Fix names of fake local variables for inline arguments

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrInlineReferenceLocator.kt

@@ -49,7 +49,7 @@ internal open class IrInlineReferenceLocator(private val context: JvmBackendCont
                 handleInlineFunctionCallableReferenceParam(reference)
                 if (valueArgument is IrBlock && valueArgument.origin.isLambda) {
                     val declaration = if (parameter.isCrossinline) null else currentScope!!.irElement as IrDeclaration
-                    handleInlineFunctionLambdaParam(reference.symbol.owner, function, declaration)
+                    handleInlineFunctionLambdaParam(reference, function, declaration)
                 }
             }
         }
@@ -60,8 +60,8 @@ internal open class IrInlineReferenceLocator(private val context: JvmBackendCont
         inlineReferences.add(valueArgument)
     }
 
-    open fun handleInlineFunctionLambdaParam(lambda: IrFunction, callee: IrFunction, callSite: IrDeclaration?) {
+    open fun handleInlineFunctionLambdaParam(lambdaReference: IrFunctionReference, callee: IrFunction, callSite: IrDeclaration?) {
-        lambdaToCallSite[lambda] = callSite
+        lambdaToCallSite[lambdaReference.symbol.owner] = callSite
     }
 
     companion object {

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FakeInliningLocalVariablesLowering.kt

@@ -9,7 +9,6 @@ import org.jetbrains.kotlin.backend.common.FileLoweringPass
 import org.jetbrains.kotlin.backend.common.lower.createIrBuilder
 import org.jetbrains.kotlin.backend.common.phaser.makeIrFilePhase
 import org.jetbrains.kotlin.backend.jvm.JvmBackendContext
-import org.jetbrains.kotlin.backend.jvm.codegen.mapClass
 import org.jetbrains.kotlin.backend.jvm.ir.IrInlineReferenceLocator
 import org.jetbrains.kotlin.ir.builders.createTmpVariable
 import org.jetbrains.kotlin.ir.builders.irBlockBody
@@ -22,7 +21,7 @@ import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.expressions.IrBlockBody
 import org.jetbrains.kotlin.ir.expressions.IrCallableReference
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
-import org.jetbrains.kotlin.ir.util.parentAsClass
+import org.jetbrains.kotlin.ir.expressions.IrFunctionReference
 import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid
 import org.jetbrains.kotlin.ir.visitors.acceptVoid
 import org.jetbrains.kotlin.load.java.JvmAbi
@@ -49,10 +48,14 @@ internal class FakeInliningLocalVariablesLowering(val context: JvmBackendContext
         // Do not record inline function callable reference parameters. They will not be used.
     }
 
-    override fun handleInlineFunctionLambdaParam(lambda: IrFunction, callee: IrFunction, callSite: IrDeclaration?) {
+    override fun handleInlineFunctionLambdaParam(lambdaReference: IrFunctionReference, callee: IrFunction, callSite: IrDeclaration?) {
         // Do not record lambda parameters. Instead deal with them now.
+        val lambda = lambdaReference.symbol.owner
         if (lambda.origin == IrDeclarationOrigin.LOCAL_FUNCTION_FOR_LAMBDA) {
-            lambda.addFakeInliningLocalVariablesForArguments(callee)
+            val argumentToFunctionName = context.methodSignatureMapper.mapFunctionName(callee)
+            val lambdaReferenceName = context.getLocalClassType(lambdaReference)!!.internalName.substringAfterLast("/")
+            val localName = "${JvmAbi.LOCAL_VARIABLE_NAME_PREFIX_INLINE_ARGUMENT}-$argumentToFunctionName-$lambdaReferenceName"
+            lambda.addFakeLocalVariable(localName)
         }
     }
 
@@ -62,16 +65,6 @@ internal class FakeInliningLocalVariablesLowering(val context: JvmBackendContext
         addFakeLocalVariable(localName)
     }
 
-    private fun IrFunction.addFakeInliningLocalVariablesForArguments(callee: IrFunction) {
-        val currentFunctionName = context.methodSignatureMapper.mapFunctionName(this)
-        val argumentToFunctionName = context.methodSignatureMapper.mapFunctionName(callee)
-        val internalName = context.typeMapper.mapClass(parentAsClass).internalName
-        val thisType = internalName.substringAfterLast('/', internalName)
-        val lambdaReference = "$thisType\$$currentFunctionName"
-        val localName = "${JvmAbi.LOCAL_VARIABLE_NAME_PREFIX_INLINE_ARGUMENT}-$argumentToFunctionName-$lambdaReference"
-        addFakeLocalVariable(localName)
-    }
-
     private fun IrFunction.addFakeLocalVariable(name: String) {
         context.createIrBuilder(symbol).run {
             body = irBlockBody {

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCheckLocalVariablesTableTest.kt

@@ -32,11 +32,6 @@ abstract class AbstractIrCheckLocalVariablesTableTest : AbstractCheckLocalVariab
         return list.map { it.toString() }
             // Ignore local index.
             .map { line -> line.replaceFirst("INDEX=\\d+".toRegex(), "INDEX=*") }
-            // Ignore the names of local functions which have integer names in
-            // the current backend and more descriptive names with the JVM_IR
-            // backend.
-            .map { line -> line.replace("\\\$\\d+".toRegex(), "\\\$*") }
-            .map { line -> line.replace("\\\$lambda-\\d+".toRegex(), "\\\$*") }
             .sorted()
     }
 
@@ -45,10 +40,6 @@ abstract class AbstractIrCheckLocalVariablesTableTest : AbstractCheckLocalVariab
             .filter { line -> line.startsWith("// VARIABLE ") }
             // Ignore local index.
             .map { line -> line.replaceFirst("INDEX=\\d+".toRegex(), "INDEX=*") }
-            // Ignore the names of local functions which have integer names in
-            // the current backend and more descriptive names with the JVM_IR
-            // backend.
-            .map { line -> line.replace("\\\$\\d+".toRegex(), "\\\$*") }
             .sorted()
     }