From ff6de0fe6a7915602c0ef302d13ddccbca51952e Mon Sep 17 00:00:00 2001 From: pyos Date: Tue, 10 Aug 2021 11:00:40 +0200 Subject: [PATCH] JVM: remove InlineCodegen.expressionMap #KT-48180 Fixed --- .../inline/AnonymousObjectTransformer.kt | 7 ++---- .../kotlin/codegen/inline/InlineCodegen.kt | 9 ++------ .../kotlin/codegen/inline/InliningContext.kt | 11 ++++------ .../kotlin/codegen/inline/PsiInlineCodegen.kt | 22 +++++++++---------- 4 files changed, 19 insertions(+), 30 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.kt index d7df75efe77..9149c06488e 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/AnonymousObjectTransformer.kt @@ -520,13 +520,10 @@ class AnonymousObjectTransformer( val paramTypes = transformationInfo.constructorDesc?.let { Type.getArgumentTypes(it) } ?: emptyArray() for (type in paramTypes) { val info = indexToFunctionalArgument[constructorParamBuilder.nextParameterOffset] + val isCaptured = capturedParams.contains(constructorParamBuilder.nextParameterOffset) val parameterInfo = constructorParamBuilder.addNextParameter(type, info is LambdaInfo) parameterInfo.functionalArgument = info - if (capturedParams.contains(parameterInfo.index)) { - parameterInfo.isCaptured = true - } else { - //otherwise it's super constructor parameter - } + parameterInfo.isCaptured = isCaptured } //For all inlined lambdas add their captured parameters diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt index 2b5c12bf2ed..3e361c34abe 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt @@ -32,7 +32,6 @@ abstract class InlineCodegen( private val initialFrameSize = codegen.frameMap.currentSize protected val invocationParamBuilder = ParametersBuilder.newBuilder() - protected val expressionMap = linkedMapOf() private val maskValues = ArrayList() private var maskStartIndex = -1 private var methodHandleInDefaultMethodIndex = -1 @@ -80,8 +79,6 @@ abstract class InlineCodegen( for (info in infos) { val lambda = DefaultLambda(info, sourceCompiler) parameters.getParameterByDeclarationSlot(info.offset).functionalArgument = lambda - val prev = expressionMap.put(info.offset, lambda) - assert(prev == null) { "Lambda with offset ${info.offset} already exists: $prev" } if (info.needReification) { lambda.reifiedTypeParametersUsages.mergeAll(reifiedTypeInliner.reifyInstructions(lambda.node.node)) } @@ -98,7 +95,7 @@ abstract class InlineCodegen( val parameters = invocationParamBuilder.buildParameters() val info = RootInliningContext( - expressionMap, state, codegen.inlineNameGenerator.subGenerator(jvmSignature.asmMethod.name), + state, codegen.inlineNameGenerator.subGenerator(jvmSignature.asmMethod.name), sourceCompiler, sourceCompiler.inlineCallSiteInfo, reifiedTypeInliner, typeParameterMappings ) @@ -213,9 +210,7 @@ abstract class InlineCodegen( } protected fun rememberClosure(parameterType: Type, index: Int, lambdaInfo: LambdaInfo) { - val closureInfo = invocationParamBuilder.addNextValueParameter(parameterType, true, null, index) - closureInfo.functionalArgument = lambdaInfo - expressionMap[closureInfo.index] = lambdaInfo + invocationParamBuilder.addNextValueParameter(parameterType, true, null, index).functionalArgument = lambdaInfo } protected fun putCapturedToLocalVal(stackValue: StackValue, capturedParam: CapturedParamDesc, kotlinType: KotlinType?) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InliningContext.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InliningContext.kt index 9480f6631a6..01275f9f3a2 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InliningContext.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InliningContext.kt @@ -9,7 +9,6 @@ import org.jetbrains.kotlin.codegen.ClassBuilder import org.jetbrains.kotlin.codegen.state.GenerationState class RootInliningContext( - expressionMap: Map, state: GenerationState, nameGenerator: NameGenerator, val sourceCompilerForInline: SourceCompilerForInline, @@ -17,12 +16,11 @@ class RootInliningContext( val inlineMethodReifier: ReifiedTypeInliner<*>, typeParameterMappings: TypeParameterMappings<*> ) : InliningContext( - null, expressionMap, state, nameGenerator, TypeRemapper.createRoot(typeParameterMappings), null, false + null, state, nameGenerator, TypeRemapper.createRoot(typeParameterMappings), null, false ) class RegeneratedClassContext( parent: InliningContext, - expressionMap: Map, state: GenerationState, nameGenerator: NameGenerator, typeRemapper: TypeRemapper, @@ -30,14 +28,13 @@ class RegeneratedClassContext( override val callSiteInfo: InlineCallSiteInfo, override val transformationInfo: TransformationInfo ) : InliningContext( - parent, expressionMap, state, nameGenerator, typeRemapper, lambdaInfo, true + parent, state, nameGenerator, typeRemapper, lambdaInfo, true ) { val continuationBuilders: MutableMap = hashMapOf() } open class InliningContext( val parent: InliningContext?, - val expressionMap: Map, val state: GenerationState, val nameGenerator: NameGenerator, val typeRemapper: TypeRemapper, @@ -97,7 +94,7 @@ open class InliningContext( callSiteInfo: InlineCallSiteInfo, transformationInfo: TransformationInfo ): InliningContext = RegeneratedClassContext( - this, expressionMap, state, generator, TypeRemapper.createFrom(typeRemapper, newTypeMappings), + this, state, generator, TypeRemapper.createFrom(typeRemapper, newTypeMappings), lambdaInfo, callSiteInfo, transformationInfo ) @@ -110,7 +107,7 @@ open class InliningContext( ): InliningContext { val isInliningLambda = lambdaInfo != null return InliningContext( - this, expressionMap, state, generator, + this, state, generator, TypeRemapper.createFrom( typeRemapper, additionalTypeMappings, diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineCodegen.kt index 591244ae772..bddb2957c04 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineCodegen.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineCodegen.kt @@ -62,19 +62,16 @@ class PsiInlineCodegen( return } try { - val registerLineNumber = registerLineNumberAfterwards(resolvedCall) - for (info in expressionMap.values) { - if (info is PsiExpressionLambda) { - // Can't be done immediately in `rememberClosure` for some reason: - info.generateLambdaBody(sourceCompiler) - // Requires `generateLambdaBody` first if the closure is non-empty (for bound callable references, - // or indeed any callable references, it *is* empty, so this was done in `rememberClosure`): - if (!info.isBoundCallableReference) { - putClosureParametersOnStack(info, null) - } + for (info in closuresToGenerate) { + // Can't be done immediately in `rememberClosure` for some reason: + info.generateLambdaBody(sourceCompiler) + // Requires `generateLambdaBody` first if the closure is non-empty (for bound callable references, + // or indeed any callable references, it *is* empty, so this was done in `rememberClosure`): + if (!info.isBoundCallableReference) { + putClosureParametersOnStack(info, null) } } - performInline(registerLineNumber, functionDescriptor.isInlineOnly()) + performInline(registerLineNumberAfterwards(resolvedCall), functionDescriptor.isInlineOnly()) } finally { state.globalInlineContext.exitFromInlining() } @@ -144,6 +141,8 @@ class PsiInlineCodegen( private fun isCallSiteIsSuspend(descriptor: ValueParameterDescriptor): Boolean = state.bindingContext[CodegenBinding.CALL_SITE_IS_SUSPEND_FOR_CROSSINLINE_LAMBDA, descriptor] == true + private val closuresToGenerate = mutableListOf() + private fun rememberClosure(expression: KtExpression, type: Type, parameter: ValueParameterDescriptor) { val ktLambda = KtPsiUtil.deparenthesize(expression) assert(isInlinableParameterExpression(ktLambda)) { "Couldn't find inline expression in ${expression.text}" } @@ -155,6 +154,7 @@ class PsiInlineCodegen( val lambda = PsiExpressionLambda(ktLambda!!, state, parameter.isCrossinline, boundReceiver != null) rememberClosure(type, parameter.index, lambda) + closuresToGenerate += lambda if (boundReceiver != null) { // Has to be done immediately to preserve evaluation order. val receiver = codegen.generateReceiverValue(boundReceiver, false)