From 5d3ef4c632d503dd3e20314f586e863ebd53d33e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Steven=20Sch=C3=A4fer?= Date: Mon, 16 Dec 2019 16:49:55 +0100 Subject: [PATCH] JVM IR: Fix names of fake local variables for inline arguments --- .../jvm/ir/IrInlineReferenceLocator.kt | 6 +++--- .../FakeInliningLocalVariablesLowering.kt | 21 +++++++------------ .../AbstractIrCheckLocalVariablesTableTest.kt | 9 -------- 3 files changed, 10 insertions(+), 26 deletions(-) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrInlineReferenceLocator.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrInlineReferenceLocator.kt index a87e8f482a5..b4214224d43 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/IrInlineReferenceLocator.kt +++ b/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?) { - lambdaToCallSite[lambda] = callSite + open fun handleInlineFunctionLambdaParam(lambdaReference: IrFunctionReference, callee: IrFunction, callSite: IrDeclaration?) { + lambdaToCallSite[lambdaReference.symbol.owner] = callSite } companion object { diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FakeInliningLocalVariablesLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FakeInliningLocalVariablesLowering.kt index ff06f36a8f3..78b1e0f0e4c 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/FakeInliningLocalVariablesLowering.kt +++ b/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 { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCheckLocalVariablesTableTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCheckLocalVariablesTableTest.kt index 951bf9cb82a..d3729eecd1b 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCheckLocalVariablesTableTest.kt +++ b/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() }