Do not try to create view of suspend function descriptor on IR BE

Keep container source in wrapped descriptor

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/coroutineCodegenUtil.kt

@@ -391,7 +391,7 @@ fun createMethodNodeForSuspendCoroutineUninterceptedOrReturn(
     typeMapper: KotlinTypeMapper,
     languageVersionSettings: LanguageVersionSettings
 ): MethodNode {
-    assert(functionDescriptor.isBuiltInSuspendCoroutineUninterceptedOrReturnInJvm(languageVersionSettings)) {
+    assert(functionDescriptor.isBuiltInSuspendCoroutineUninterceptedOrReturn(languageVersionSettings)) {
         "functionDescriptor must be kotlin.coroutines.intrinsics.suspendCoroutineUninterceptedOrReturn"
     }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/inlineIntrinsics.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.codegen.inline
 
 import org.jetbrains.kotlin.backend.common.isBuiltInIntercepted
+import org.jetbrains.kotlin.backend.common.isBuiltInSuspendCoroutineUninterceptedOrReturn
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.codegen.ExpressionCodegen
@@ -48,7 +49,7 @@ internal fun generateInlineIntrinsic(
             createMethodNodeForIntercepted(descriptor, typeMapper, languageVersionSettings)
         descriptor.isBuiltInCoroutineContext(languageVersionSettings) ->
             createMethodNodeForCoroutineContext(descriptor, languageVersionSettings)
-        descriptor.isBuiltInSuspendCoroutineUninterceptedOrReturnInJvm(languageVersionSettings) ->
+        descriptor.isBuiltInSuspendCoroutineUninterceptedOrReturn(languageVersionSettings) ->
             createMethodNodeForSuspendCoroutineUninterceptedOrReturn(descriptor, typeMapper, languageVersionSettings)
         descriptor.isBuiltinAlwaysEnabledAssert() ->
             createMethodNodeForAlwaysEnabledAssert(descriptor, typeMapper)

compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt

@@ -172,7 +172,7 @@ class KotlinTypeMapper @JvmOverloads constructor(
             return Type.VOID_TYPE
         }
 
-        if (descriptor.isSuspendFunctionNotSuspensionView()) {
+        if (descriptor.isSuspendFunctionNotSuspensionView() && !isIrBackend) {
             return mapReturnType(
                 getOrCreateJvmSuspendFunctionView(descriptor as SimpleFunctionDescriptor, isReleaseCoroutines),
                 sw
@@ -733,7 +733,7 @@ class KotlinTypeMapper @JvmOverloads constructor(
             return mapSignature(f.callableFromObject, kind, skipGenericSignature)
         }
 
-        if (f.isSuspendFunctionNotSuspensionView()) {
+        if (f.isSuspendFunctionNotSuspensionView() && !isIrBackend) {
             return mapSignature(
                 getOrCreateJvmSuspendFunctionView(f, isReleaseCoroutines), kind,
                 skipGenericSignature
@@ -1315,10 +1315,6 @@ class KotlinTypeMapper @JvmOverloads constructor(
                 return descriptor.containingDeclaration.name.asString()
             }
 
-            if (descriptor.containingDeclaration.fqNameSafe.asString() == "kotlin.coroutines.intrinsics") {
-                return "kotlin.coroutines.IntrinsicsKt" // TODO: why this change is needed in JVM_IR?
-            }
-
             if (directMember is FictitiousArrayConstructor) {
                 return "kotlin.Array"
             }

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/descriptors/WrappedDescriptors.kt

@@ -31,7 +31,6 @@ import org.jetbrains.kotlin.serialization.deserialization.descriptors.Deserializ
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.*
-import java.lang.UnsupportedOperationException
 
 
 abstract class WrappedDeclarationDescriptor<T : IrDeclaration>(annotations: Annotations) :
@@ -374,7 +373,6 @@ open class WrappedSimpleFunctionDescriptor(
     annotations: Annotations = Annotations.EMPTY,
     sourceElement: SourceElement = SourceElement.NO_SOURCE
 ) : SimpleFunctionDescriptor, WrappedCallableDescriptor<IrSimpleFunction>(annotations, sourceElement) {
-    private val userDataMap = mutableMapOf<CallableDescriptor.UserDataKey<*>, Any?>()
 
     // TODO: Remove as soon as all IR declarations have their originalDescriptor.
     constructor(originalDescriptor: FunctionDescriptor) : this(originalDescriptor.annotations, originalDescriptor.source) {
@@ -423,7 +421,7 @@ open class WrappedSimpleFunctionDescriptor(
     }
 
     override fun setOverriddenDescriptors(overriddenDescriptors: MutableCollection<out CallableMemberDescriptor>) {
-        if (!isSuspend) TODO("not implemented")
+        TODO("not implemented")
     }
 
     override fun getKind() =
@@ -450,15 +448,10 @@ open class WrappedSimpleFunctionDescriptor(
 
     override fun getInitialSignatureDescriptor() = null
 
-    override fun <V : Any?> getUserData(key: CallableDescriptor.UserDataKey<V>?): V? =
+    override fun <V : Any?> getUserData(key: CallableDescriptor.UserDataKey<V>?): V? = null
-        userDataMap[key as CallableDescriptor.UserDataKey<*>] as V?
 
     override fun newCopyBuilder(): FunctionDescriptor.CopyBuilder<out SimpleFunctionDescriptor> {
-        // KotlinTypeMapper uses getOrCreateJvmSuspendFunctionView extensively, but since
+        TODO("not implemented")
-        // after AddContinuationLowering all suspend descriptors are views anyway, return original
-        // one as a copy (with user data changed)
-        if (isSuspend) return ChangeUserDataCopyBuilder()
-        else TODO("not implemented")
     }
 
     override fun <R, D> accept(visitor: DeclarationDescriptorVisitor<R, D>?, data: D) =
@@ -467,96 +460,6 @@ open class WrappedSimpleFunctionDescriptor(
     override fun acceptVoid(visitor: DeclarationDescriptorVisitor<Void, Void>?) {
         visitor!!.visitFunctionDescriptor(this, null)
     }
-
-    inner class ChangeUserDataCopyBuilder : FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-        override fun setOwner(owner: DeclarationDescriptor): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            return this
-        }
-
-        override fun setModality(modality: Modality): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            return this
-        }
-
-        override fun setVisibility(visibility: Visibility): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            return this
-        }
-
-        override fun setKind(kind: CallableMemberDescriptor.Kind): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            return this
-        }
-
-        override fun setCopyOverrides(copyOverrides: Boolean): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            return this
-        }
-
-        override fun setName(name: Name): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            return this
-        }
-
-        override fun setValueParameters(parameters: MutableList<ValueParameterDescriptor>): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            return this
-        }
-
-        override fun setTypeParameters(parameters: MutableList<TypeParameterDescriptor>): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            return this
-        }
-
-        override fun setReturnType(type: KotlinType): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            return this
-        }
-
-        override fun setExtensionReceiverParameter(extensionReceiverParameter: ReceiverParameterDescriptor?): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            return this
-        }
-
-        override fun setDispatchReceiverParameter(dispatchReceiverParameter: ReceiverParameterDescriptor?): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            return this
-        }
-
-        override fun setOriginal(original: CallableMemberDescriptor?): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            return this
-        }
-
-        override fun setSignatureChange(): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            return this
-        }
-
-        override fun setPreserveSourceElement(): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            return this
-        }
-
-        override fun setDropOriginalInContainingParts(): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            return this
-        }
-
-        override fun setHiddenToOvercomeSignatureClash(): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            return this
-        }
-
-        override fun setHiddenForResolutionEverywhereBesideSupercalls(): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            return this
-        }
-
-        override fun setAdditionalAnnotations(additionalAnnotations: Annotations): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            return this
-        }
-
-        override fun setSubstitution(substitution: TypeSubstitution): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            return this
-        }
-
-        override fun <V : Any?> putUserData(
-            userDataKey: CallableDescriptor.UserDataKey<V>,
-            value: V
-        ): FunctionDescriptor.CopyBuilder<WrappedSimpleFunctionDescriptor> {
-            this@WrappedSimpleFunctionDescriptor.userDataMap[userDataKey] = value
-            return this
-        }
-
-        override fun build(): WrappedSimpleFunctionDescriptor? {
-            return this@WrappedSimpleFunctionDescriptor
-        }
-    }
 }
 
 class WrappedFunctionDescriptorWithContainerSource(

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

@@ -206,9 +206,7 @@ fun generateParameterAnnotations(
     state: GenerationState
 ) {
     val iterator = irFunction.valueParameters.iterator()
-    val kotlinParameterTypes =
+    val kotlinParameterTypes = jvmSignature.valueParameters
-        if (irFunction.isSuspend) jvmSignature.valueParameters.dropLast(1) // do not generate annotation for continuation parameter
-        else jvmSignature.valueParameters
     var syntheticParameterCount = 0
     kotlinParameterTypes.forEachIndexed { i, parameterSignature ->
         val kind = parameterSignature.kind

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.backend.jvm.lower
 
 import org.jetbrains.kotlin.backend.common.FileLoweringPass
+import org.jetbrains.kotlin.backend.common.descriptors.WrappedFunctionDescriptorWithContainerSource
 import org.jetbrains.kotlin.backend.common.descriptors.WrappedSimpleFunctionDescriptor
 import org.jetbrains.kotlin.backend.common.descriptors.synthesizedName
 import org.jetbrains.kotlin.backend.common.ir.copyTo
@@ -42,6 +43,7 @@ import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.ir.visitors.*
 import org.jetbrains.kotlin.load.java.JavaVisibilities
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DescriptorWithContainerSource
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.util.OperatorNameConventions
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstance
@@ -125,8 +127,9 @@ private class AddContinuationLowering(private val context: JvmBackendContext) :
             val parametersFields = info.function.valueParameters.map { addField(it.name.asString(), it.type) }
             val constructor = addPrimaryConstructorForLambda(info.arity, info.function, parametersFields)
             val secondaryConstructor = addSecondaryConstructorForLambda(constructor)
-            val invokeToOverride = functionNClass.functions.single { it.owner.valueParameters.size == info.arity + 1 }
+            val invokeToOverride = functionNClass.functions.single {
-            assert(invokeToOverride.owner.name.asString() == "invoke")
+                it.owner.valueParameters.size == info.arity + 1 && it.owner.name.asString() == "invoke"
+            }
             val invokeSuspend = addInvokeSuspendForLambda(info.function, parametersFields)
             if (info.arity <= 1) {
                 val create = addCreate(constructor, suspendLambda, info.arity, parametersFields)
@@ -142,8 +145,10 @@ private class AddContinuationLowering(private val context: JvmBackendContext) :
     }
 
     private fun IrClass.addInvokeSuspendForLambda(irFunction: IrFunction, fields: List<IrField>): IrFunction {
-        val superMethod = suspendLambda.functions.single { it.owner.name.asString() == INVOKE_SUSPEND_METHOD_NAME }.owner
+        val superMethod = suspendLambda.functions.single {
-        assert(superMethod.valueParameters.size == 1 && superMethod.valueParameters[0].type.isKotlinResult())
+            it.owner.name.asString() == INVOKE_SUSPEND_METHOD_NAME && it.owner.valueParameters.size == 1 &&
+                    it.owner.valueParameters[0].type.isKotlinResult()
+        }.owner
         return addFunctionOverride(superMethod)
             .also { function ->
                 function.body = irFunction.body?.deepCopyWithSymbols()
@@ -192,8 +197,11 @@ private class AddContinuationLowering(private val context: JvmBackendContext) :
         arity: Int,
         parametersFields: List<IrField>
     ): IrFunction {
-        val create = superType.functions.single { it.name == Name.identifier("create") && it.valueParameters.size == arity + 1 }
+        val create = superType.functions.single {
-        assert(create.valueParameters.last().type.isContinuation() && if (arity == 1) create.valueParameters.first().type.isNullableAny() else true)
+            it.name == Name.identifier("create") && it.valueParameters.size == arity + 1 &&
+                    it.valueParameters.last().type.isContinuation() &&
+                    if (arity == 1) it.valueParameters.first().type.isNullableAny() else true
+        }
         return addFunctionOverride(create).also { function ->
             function.body = context.createIrBuilder(function.symbol).irBlockBody {
                 +irReturn(irCall(constructor).also {
@@ -233,8 +241,9 @@ private class AddContinuationLowering(private val context: JvmBackendContext) :
             irFunction.valueParameters.mapTo(constructor.valueParameters) { it.copyTo(constructor) }
             val completionParameterSymbol = constructor.addCompletionValueParameter()
 
-            val superClassConstructor = suspendLambda.owner.constructors.single { it.valueParameters.size == 2 }
+            val superClassConstructor = suspendLambda.owner.constructors.single {
-            assert(superClassConstructor.valueParameters[0].type.isInt() && superClassConstructor.valueParameters[1].type.isNullableContinuation())
+                it.valueParameters.size == 2 && it.valueParameters[0].type.isInt() && it.valueParameters[1].type.isNullableContinuation()
+            }
             constructor.body = context.createIrBuilder(constructor.symbol).irBlockBody {
                 +irDelegatingConstructorCall(superClassConstructor).also {
                     it.putValueArgument(0, irInt(arity + 1))
@@ -426,7 +435,12 @@ private class AddContinuationLowering(private val context: JvmBackendContext) :
     private fun IrSimpleFunction.getOrCreateView(): IrSimpleFunction =
         transformedSuspendFunctionsCache.getOrPut(this) {
             // Copy source element, so we can check for suspend calls in monitor during state-machine generation
-            val descriptor = WrappedSimpleFunctionDescriptor(sourceElement = this.descriptor.source)
+            val originalDescriptor = this.descriptor
+            val descriptor =
+                if (originalDescriptor is DescriptorWithContainerSource && originalDescriptor.containerSource != null)
+                    WrappedFunctionDescriptorWithContainerSource(originalDescriptor.containerSource!!)
+                else
+                    WrappedSimpleFunctionDescriptor(sourceElement = originalDescriptor.source)
             IrFunctionImpl(
                 startOffset, endOffset, origin, IrSimpleFunctionSymbolImpl(descriptor),
                 name, visibility, modality, context.irBuiltIns.anyType,

compiler/testData/codegen/box/coroutines/illegalState.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 // WITH_RUNTIME
 // WITH_COROUTINES
 // TARGET_BACKEND: JVM

compiler/testData/codegen/box/coroutines/localFunctions/named/nestedLocals.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JVM_IR
 // WITH_RUNTIME
 // WITH_COROUTINES
 // COMMON_COROUTINES_TEST

compiler/testData/codegen/box/coroutines/localFunctions/named/simpleSuspensionPoint.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND: JVM_IR
 // WITH_RUNTIME
 // WITH_COROUTINES
 // COMMON_COROUTINES_TEST

compiler/testData/codegen/box/coroutines/suspendCoroutineFromStateMachine.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND: JVM_IR
 // WITH_RUNTIME
 // WITH_COROUTINES
 // COMMON_COROUTINES_TEST