Detect inline cycles faster

E.g. in the following code

    fun x() {}
    inline fun f() { x(); g() }
    inline fun g() { x(); f() }

the old implementation of inline cycle detection bailed out after
generating 3 calls of x() in each function, while the new one stops
after 2. In other words, code generation for a single function is no
longer reentered.

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.backend.common.lower.BOUND_RECEIVER_PARAMETER
 import org.jetbrains.kotlin.backend.common.lower.BOUND_VALUE_PARAMETER
 import org.jetbrains.kotlin.backend.jvm.JvmBackendContext
 import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin
+import org.jetbrains.kotlin.backend.jvm.lower.suspendFunctionOriginal
 import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.codegen.mangleNameIfNeeded
 import org.jetbrains.kotlin.codegen.state.GenerationState
@@ -110,7 +111,12 @@ open class FunctionCodegen(
                     irFunction, classCodegen, methodVisitor, flags, signature, getContinuation, psiElement()
                 )
             }
-            ExpressionCodegen(irFunction, signature, frameMap, InstructionAdapter(methodVisitor), classCodegen, inlinedInto).generate()
+            context.state.globalInlineContext.enterDeclaration(irFunction.suspendFunctionOriginal().descriptor)
+            try {
+                ExpressionCodegen(irFunction, signature, frameMap, InstructionAdapter(methodVisitor), classCodegen, inlinedInto).generate()
+            } finally {
+                context.state.globalInlineContext.exitDeclaration()
+            }
             methodVisitor.visitMaxs(-1, -1)
         }
         methodVisitor.visitEnd()

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCodegen.kt

@@ -5,14 +5,13 @@
 
 package org.jetbrains.kotlin.backend.jvm.codegen
 
-import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.backend.jvm.JvmBackendContext
 import org.jetbrains.kotlin.backend.jvm.ir.isInlineParameter
 import org.jetbrains.kotlin.backend.jvm.ir.isLambda
+import org.jetbrains.kotlin.backend.jvm.lower.suspendFunctionOriginal
 import org.jetbrains.kotlin.codegen.inline.*
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.ir.declarations.*
@@ -145,36 +144,16 @@ class IrInlineCodegen(
         invocationParamBuilder.markValueParametersStart()
     }
 
-    private inner class IrInlineCall(
-        private val irFunctionAccessExpression: IrFunctionAccessExpression
-    ) : InlineCall {
-
-        override val calleeDescriptor: CallableDescriptor =
-            irFunctionAccessExpression.symbol.descriptor.original
-
-        override val callElement: PsiElement?
-            get() =
-                codegen.context.psiSourceManager.findPsiElement(irFunctionAccessExpression, function)
-                    ?: codegen.context.psiSourceManager.findPsiElement(function)
-
-        override val id: Any
-            get() = irFunctionAccessExpression
-
-        override fun toString(): String = irFunctionAccessExpression.render()
-    }
-
     override fun genCall(
         callableMethod: IrCallableMethod,
         codegen: ExpressionCodegen,
         expression: IrFunctionAccessExpression
     ) {
-        val inlineCall = IrInlineCall(expression)
-        if (!state.globalInlineContext.enterIntoInlining(inlineCall)) {
-            AsmUtil.genThrow(
-                codegen.v,
-                "java/lang/UnsupportedOperationException",
-                "Call is a part of inline call cycle: ${expression.render()}"
-            )
+        val element = codegen.context.psiSourceManager.findPsiElement(expression, codegen.irFunction)
+            ?: codegen.context.psiSourceManager.findPsiElement(codegen.irFunction)
+        if (!state.globalInlineContext.enterIntoInlining(expression.symbol.owner.suspendFunctionOriginal().descriptor, element)) {
+            val message = "Call is a part of inline call cycle: ${expression.render()}"
+            AsmUtil.genThrow(codegen.v, "java/lang/UnsupportedOperationException", message)
             return
         }
         try {
@@ -186,7 +165,7 @@ class IrInlineCodegen(
                 false
             )
         } finally {
-            state.globalInlineContext.exitFromInliningOf(inlineCall)
+            state.globalInlineContext.exitFromInlining()
         }
     }
 

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/MethodSignatureMapper.kt

@@ -112,7 +112,7 @@ class MethodSignatureMapper(private val context: JvmBackendContext) {
         val newName = JvmCodegenUtil.sanitizeNameIfNeeded(name, context.state.languageVersionSettings)
 
         if (function.isTopLevel) {
-            if (Visibilities.isPrivate(if (function.isSuspend) function.suspendFunctionOriginal().visibility else function.visibility) &&
+            if (Visibilities.isPrivate(function.suspendFunctionOriginal().visibility) &&
                 newName != "<clinit>" && (function.parent as? IrClass)?.attributeOwnerId in context.multifileFacadeForPart
             ) {
                 return "$newName$${function.parentAsClass.name.asString()}"

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

@@ -639,10 +639,8 @@ private fun IrFunction.suspendFunctionViewOrStub(context: JvmBackendContext): Ir
     return context.suspendFunctionOriginalToView.getOrPut(suspendFunctionOriginal()) { createSuspendFunctionStub(context) }
 }
 
-internal fun IrFunction.suspendFunctionOriginal(): IrFunction {
-    require(isSuspend && this is IrSimpleFunction)
-    return attributeOwnerId as IrFunction
-}
+internal fun IrFunction.suspendFunctionOriginal(): IrFunction =
+    if (this is IrSimpleFunction && isSuspend) attributeOwnerId as IrFunction else this
 
 private fun IrFunction.createSuspendFunctionStub(context: JvmBackendContext): IrFunction {
     require(this.isSuspend && this is IrSimpleFunction)