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 ccd38bba087..8e074a24212 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt @@ -22,7 +22,6 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.inline.InlineUtil import org.jetbrains.kotlin.resolve.inline.isInlineOnly import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature -import org.jetbrains.kotlin.resolve.jvm.requiresFunctionNameManglingForReturnType import org.jetbrains.kotlin.types.TypeSystemCommonBackendContext import org.jetbrains.kotlin.types.model.TypeParameterMarker import org.jetbrains.org.objectweb.asm.Label @@ -100,13 +99,17 @@ abstract class InlineCodegen( fun performInline( typeArguments: List?, inlineDefaultLambdas: Boolean, - mapDefaultSignature: Boolean, typeSystem: TypeSystemCommonBackendContext, registerLineNumberAfterwards: Boolean, ) { var nodeAndSmap: SMAPAndMethodNode? = null try { - nodeAndSmap = createInlineMethodNode(mapDefaultSignature, typeArguments, typeSystem) + nodeAndSmap = + generateInlineIntrinsic(state, functionDescriptor, jvmSignature.asmMethod, typeArguments, typeSystem)?.let { + SMAPAndMethodNode(it, SMAP(listOf())) + } ?: sourceCompiler.compileInlineFunction(jvmSignature).apply { + node.preprocessSuspendMarkers(forInline = true, keepFakeContinuation = false) + } endCall(inlineCall(nodeAndSmap, inlineDefaultLambdas), registerLineNumberAfterwards) } catch (e: CompilationException) { throw e @@ -420,26 +423,8 @@ abstract class InlineCodegen( ) } - private fun createInlineMethodNode( - callDefault: Boolean, - typeArguments: List?, - typeSystem: TypeSystemCommonBackendContext - ): SMAPAndMethodNode { - val intrinsic = generateInlineIntrinsic(state, functionDescriptor, jvmSignature.asmMethod, typeArguments, typeSystem) - if (intrinsic != null) { - return SMAPAndMethodNode(intrinsic, SMAP(listOf())) - } - sourceCompiler.inlineFunctionSignature(jvmSignature, callDefault)?.let { (containerId, asmMethod) -> - val isMangled = requiresFunctionNameManglingForReturnType(functionDescriptor) - return loadCompiledInlineFunction(containerId, asmMethod, functionDescriptor.isSuspend, isMangled, state) - } - return sourceCompiler.compileInlineFunction(jvmSignature, callDefault).apply { - node.preprocessSuspendMarkers(forInline = true, keepFakeContinuation = false) - } - } - companion object { - internal fun loadCompiledInlineFunction( + fun loadCompiledInlineFunction( containerId: ClassId, asmMethod: Method, isSuspend: Boolean, diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenForDefaultBody.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenForDefaultBody.kt index d8b3fbac565..a23f012d4a8 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenForDefaultBody.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenForDefaultBody.kt @@ -38,7 +38,7 @@ class InlineCodegenForDefaultBody( override fun genCallInner(callableMethod: Callable, resolvedCall: ResolvedCall<*>?, callDefault: Boolean, codegen: ExpressionCodegen) { assert(!callDefault) { "inlining default stub into another default stub" } - val (node, smap) = sourceCompilerForInline.compileInlineFunction(jvmSignature, callDefault) + val (node, smap) = sourceCompilerForInline.compileInlineFunction(jvmSignature) val childSourceMapper = SourceMapCopier(sourceMapper, smap) val argsSize = 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 217d48ff474..e5cbd3cb8a6 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineCodegen.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineCodegen.kt @@ -64,6 +64,7 @@ class PsiInlineCodegen( callDefault: Boolean, codegen: ExpressionCodegen ) { + (sourceCompiler as PsiSourceCompilerForInline).callDefault = callDefault assert(hiddenParameters.isEmpty()) { "putHiddenParamsIntoLocals() should be called after processHiddenParameters()" } if (!state.globalInlineContext.enterIntoInlining(functionDescriptor, resolvedCall?.call?.callElement)) { generateStub(resolvedCall?.call?.callElement?.text ?: "", codegen) @@ -82,7 +83,7 @@ class PsiInlineCodegen( } } } - performInline(resolvedCall?.typeArguments?.keys?.toList(), callDefault, callDefault, codegen.typeSystem, registerLineNumber) + performInline(resolvedCall?.typeArguments?.keys?.toList(), callDefault, codegen.typeSystem, registerLineNumber) } finally { state.globalInlineContext.exitFromInlining() } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiSourceCompilerForInline.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiSourceCompilerForInline.kt index 82bf5aab292..cdb75fabdf6 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiSourceCompilerForInline.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiSourceCompilerForInline.kt @@ -16,7 +16,6 @@ import org.jetbrains.kotlin.config.JVMConfigurationKeys import org.jetbrains.kotlin.config.isReleaseCoroutines import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.incremental.KotlinLookupLocation -import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils import org.jetbrains.kotlin.resolve.DescriptorUtils @@ -25,6 +24,7 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCallWithAssert import org.jetbrains.kotlin.resolve.isInlineClass import org.jetbrains.kotlin.resolve.jvm.annotations.isCallableMemberCompiledToJvmDefault import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature +import org.jetbrains.kotlin.resolve.jvm.requiresFunctionNameManglingForReturnType import org.jetbrains.kotlin.serialization.deserialization.descriptors.DescriptorWithContainerSource import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils import org.jetbrains.kotlin.types.expressions.LabelResolver @@ -224,13 +224,9 @@ class PsiSourceCompilerForInline( return (directMember as? ImportedFromObjectCallableDescriptor<*>)?.callableFromObject ?: directMember } - override fun inlineFunctionSignature(jvmSignature: JvmMethodSignature, callDefault: Boolean): Pair? { - val directMember = getDirectMemberAndCallableFromObject() as? DescriptorWithContainerSource - ?: return null - val containerId = KotlinTypeMapper.getContainingClassesForDeserializedCallable(directMember).implClassId - if (!callDefault) { - return containerId to jvmSignature.asmMethod - } + internal var callDefault: Boolean = false + + private fun mapDefault(): Method { // This is all available in the `Callable` passed to `PsiInlineCodegen.genCallInner`, but it's not forwarded through the inliner... var result = state.typeMapper.mapDefaultMethod(functionDescriptor, contextKind) if (result.name.contains("-") && @@ -241,10 +237,19 @@ class PsiSourceCompilerForInline( result = state.typeMapper.mapDefaultMethod(functionDescriptor, contextKind) state.typeMapper.useOldManglingRulesForFunctionAcceptingInlineClass = false } - return containerId to result + return result } - override fun compileInlineFunction(jvmSignature: JvmMethodSignature, callDefault: Boolean): SMAPAndMethodNode { + override fun compileInlineFunction(jvmSignature: JvmMethodSignature): SMAPAndMethodNode { + val asmMethod = if (callDefault) mapDefault() else jvmSignature.asmMethod + + val directMember = getDirectMemberAndCallableFromObject() + if (directMember is DescriptorWithContainerSource) { + val containerId = KotlinTypeMapper.getContainingClassesForDeserializedCallable(directMember).implClassId + val isMangled = requiresFunctionNameManglingForReturnType(functionDescriptor) + return InlineCodegen.loadCompiledInlineFunction(containerId, asmMethod, functionDescriptor.isSuspend, isMangled, state) + } + val element = DescriptorToSourceUtils.descriptorToDeclaration(functionDescriptor) if (!(element is KtNamedFunction || element is KtPropertyAccessor)) { @@ -252,10 +257,6 @@ class PsiSourceCompilerForInline( } val inliningFunction = element as KtDeclarationWithBody? - val asmMethod = if (callDefault) - state.typeMapper.mapDefaultMethod(functionDescriptor, contextKind) - else - jvmSignature.asmMethod val node = MethodNode( Opcodes.API_VERSION, DescriptorAsmUtil.getMethodAsmFlags(functionDescriptor, context.contextKind, state) or diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SourceCompilerForInline.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SourceCompilerForInline.kt index 26679241aca..28bef48f1a8 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SourceCompilerForInline.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SourceCompilerForInline.kt @@ -38,9 +38,7 @@ interface SourceCompilerForInline { fun generateLambdaBody(lambdaInfo: ExpressionLambda, reifiedTypeParameters: ReifiedTypeParametersUsages): SMAPAndMethodNode - fun inlineFunctionSignature(jvmSignature: JvmMethodSignature, callDefault: Boolean): Pair? - - fun compileInlineFunction(jvmSignature: JvmMethodSignature, callDefault: Boolean): SMAPAndMethodNode + fun compileInlineFunction(jvmSignature: JvmMethodSignature): SMAPAndMethodNode fun hasFinallyBlocks(): Boolean diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCodegen.kt index 44ef6abcc42..f491ec0ec3d 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCodegen.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCodegen.kt @@ -129,8 +129,7 @@ class IrInlineCodegen( performInline( expression.symbol.owner.typeParameters.map { it.symbol }, // Always look for default lambdas to allow custom default argument handling in compiler plugins. - true, - false, + inlineDefaultLambdas = true, codegen.typeMapper.typeSystem, registerLineNumberAfterwards = isInsideIfCondition, ) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt index 6f441631042..3c99520b3f0 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt @@ -10,6 +10,7 @@ import com.intellij.psi.PsiFile import org.jetbrains.kotlin.backend.common.CodegenUtil import org.jetbrains.kotlin.backend.common.ir.ir2string import org.jetbrains.kotlin.backend.jvm.ir.getKtFile +import org.jetbrains.kotlin.backend.jvm.lower.inlineclasses.hasMangledReturnType import org.jetbrains.kotlin.codegen.BaseExpressionCodegen import org.jetbrains.kotlin.codegen.OwnerKind import org.jetbrains.kotlin.codegen.inline.* @@ -28,7 +29,6 @@ import org.jetbrains.kotlin.ir.expressions.IrLoop import org.jetbrains.kotlin.ir.util.isSuspend import org.jetbrains.kotlin.ir.util.module import org.jetbrains.kotlin.ir.util.parentAsClass -import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.psi.KtElement import org.jetbrains.kotlin.psi.doNotAnalyze import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.SUSPENSION_POINT_INSIDE_MONITOR @@ -36,7 +36,6 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature import org.jetbrains.org.objectweb.asm.Label import org.jetbrains.org.objectweb.asm.Type import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter -import org.jetbrains.org.objectweb.asm.commons.Method import org.jetbrains.org.objectweb.asm.tree.MethodNode class IrSourceCompilerForInline( @@ -105,11 +104,10 @@ class IrSourceCompilerForInline( return FunctionCodegen(lambdaInfo.function, codegen.classCodegen).generate(codegen, reifiedTypeParameters) } - override fun inlineFunctionSignature(jvmSignature: JvmMethodSignature, callDefault: Boolean): Pair? = - callee.parentClassId?.let { it to jvmSignature.asmMethod } - - override fun compileInlineFunction(jvmSignature: JvmMethodSignature, callDefault: Boolean): SMAPAndMethodNode = - ClassCodegen.getOrCreate(callee.parentAsClass, codegen.context).generateMethodNode(callee) + override fun compileInlineFunction(jvmSignature: JvmMethodSignature): SMAPAndMethodNode = + callee.parentClassId?.let { containerId -> + InlineCodegen.loadCompiledInlineFunction(containerId, jvmSignature.asmMethod, callee.isSuspend, callee.hasMangledReturnType, state) + } ?: ClassCodegen.getOrCreate(callee.parentAsClass, codegen.context).generateMethodNode(callee) override fun hasFinallyBlocks() = data.hasFinallyBlocks()