JVM: don't thread callDefault through the inliner

It's only used by the old backend, and should be given to
PsiSourceCompilerForInline by PsiInlineCodegen.

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<out T : BaseExpressionCodegen>(
     fun performInline(
         typeArguments: List<TypeParameterMarker>?,
         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<out T : BaseExpressionCodegen>(
         )
     }
 
-    private fun createInlineMethodNode(
-        callDefault: Boolean,
-        typeArguments: List<TypeParameterMarker>?,
-        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,

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 =

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 ?: "<no source>", 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()
         }

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<ClassId, Method>? {
-        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

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<ClassId, Method>?
-
-    fun compileInlineFunction(jvmSignature: JvmMethodSignature, callDefault: Boolean): SMAPAndMethodNode
+    fun compileInlineFunction(jvmSignature: JvmMethodSignature): SMAPAndMethodNode
 
     fun hasFinallyBlocks(): Boolean
 

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,
         )

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<ClassId, Method>? =
-        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()