fixup! IC & Coroutines: Unbox inline class parameter of suspend lambda

if it is called using parens and not by calling 'invoke' method.

Use underlying type when calling continuation constructor if suspend
function is method inside inline class.

 #KT-43505 Fixed
 #KT-39437 Fixed

compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java

@@ -375,22 +375,17 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
         FunctionDescriptor functionDescriptor = (FunctionDescriptor) descriptor;
         if (!functionDescriptor.isSuspend()) return stackValue;
 
+        // When we call suspend operator fun invoke using parens, we cannot box receiver as return type inline class
+        if (resolvedCall instanceof VariableAsFunctionResolvedCall &&
+            functionDescriptor.isOperator() && functionDescriptor.getName().getIdentifier().equals("invoke")
+        ) return stackValue;
+
         KotlinType unboxedInlineClass = CoroutineCodegenUtilKt
                 .originalReturnTypeOfSuspendFunctionReturningUnboxedInlineClass(functionDescriptor, typeMapper);
 
         StackValue stackValueToWrap = stackValue;
-        KotlinType originalKotlinType;
-        if (unboxedInlineClass != null) {
-            originalKotlinType = unboxedInlineClass;
-        } else {
-            originalKotlinType = stackValueToWrap.kotlinType;
-        }
-        Type originalType;
-        if (unboxedInlineClass != null) {
-            originalType = typeMapper.mapType(unboxedInlineClass);
-        } else {
-            originalType = stackValueToWrap.type;
-        }
+        KotlinType originalKotlinType = unboxedInlineClass != null ? unboxedInlineClass : stackValueToWrap.kotlinType;
+        Type originalType = unboxedInlineClass != null ? typeMapper.mapType(unboxedInlineClass) : stackValueToWrap.type;
 
         stackValue = new StackValue(originalType, originalKotlinType) {
             @Override

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

@@ -35,6 +35,7 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
+import org.jetbrains.kotlin.resolve.isInlineClassType
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
@@ -294,7 +295,7 @@ class CoroutineCodegenForLambda private constructor(
             functionCodegen.generateMethod(JvmDeclarationOrigin.NO_ORIGIN, funDescriptor,
                                            object : FunctionGenerationStrategy.CodegenBased(state) {
                                                override fun doGenerateBody(codegen: ExpressionCodegen, signature: JvmMethodSignature) {
-                                                   codegen.v.generateInvokeMethod(signature)
+                                                   codegen.v.generateInvokeMethod(signature, funDescriptor)
                                                }
                                            })
         }
@@ -316,13 +317,13 @@ class CoroutineCodegenForLambda private constructor(
         )
         mv.visitCode()
         with(InstructionAdapter(mv)) {
-            generateInvokeMethod(jvmMethodSignature)
+            generateInvokeMethod(jvmMethodSignature, untypedDescriptor)
         }
 
         FunctionCodegen.endVisit(mv, "invoke", element)
     }
 
-    private fun InstructionAdapter.generateInvokeMethod(signature: JvmMethodSignature) {
+    private fun InstructionAdapter.generateInvokeMethod(signature: JvmMethodSignature, descriptor: FunctionDescriptor) {
         // this
         load(0, AsmTypes.OBJECT_TYPE)
         val parameterTypes = signature.valueParameters.map { it.asmType }
@@ -348,16 +349,23 @@ class CoroutineCodegenForLambda private constructor(
             load(arraySlot, AsmTypes.OBJECT_TYPE)
         } else {
             var index = 0
+            val fromKotlinTypes =
+                if (!generateErasedCreate && doNotGenerateInvokeBridge) funDescriptor.allValueParameterTypes()
+                else funDescriptor.allValueParameterTypes().map { funDescriptor.module.builtIns.nullableAnyType }
+            val toKotlinTypes =
+                if (!generateErasedCreate && doNotGenerateInvokeBridge) createCoroutineDescriptor.allValueParameterTypes()
+                else descriptor.allValueParameterTypes()
             parameterTypes.withVariableIndices().forEach { (varIndex, type) ->
                 load(varIndex + 1, type)
-                StackValue.coerce(type, createArgumentTypes[index++], this)
+                StackValue.coerce(type, fromKotlinTypes[index], createArgumentTypes[index], toKotlinTypes[index], this)
+                index++
             }
         }
 
         // this.create(..)
         invokevirtual(
             v.thisName,
-            createCoroutineDescriptor.name.identifier,
+            typeMapper.mapFunctionName(createCoroutineDescriptor, null),
             Type.getMethodDescriptor(
                 languageVersionSettings.continuationAsmType(),
                 *createArgumentTypes.toTypedArray()
@@ -439,12 +447,24 @@ class CoroutineCodegenForLambda private constructor(
                         )
                     } else {
                         if (generateErasedCreate) {
-                            load(index, AsmTypes.OBJECT_TYPE)
-                            StackValue.coerce(
-                                AsmTypes.OBJECT_TYPE, builtIns.nullableAnyType,
-                                fieldInfoForCoroutineLambdaParameter.fieldType, fieldInfoForCoroutineLambdaParameter.fieldKotlinType,
-                                this
-                            )
+                            if (parameter.type.isInlineClassType()) {
+                                load(cloneIndex, fieldInfoForCoroutineLambdaParameter.ownerType)
+                                load(index, AsmTypes.OBJECT_TYPE)
+                                StackValue.unboxInlineClass(AsmTypes.OBJECT_TYPE, parameter.type, this)
+                                putfield(
+                                    fieldInfoForCoroutineLambdaParameter.ownerInternalName,
+                                    fieldInfoForCoroutineLambdaParameter.fieldName,
+                                    fieldInfoForCoroutineLambdaParameter.fieldType.descriptor
+                                )
+                                continue
+                            } else {
+                                load(index, AsmTypes.OBJECT_TYPE)
+                                StackValue.coerce(
+                                    AsmTypes.OBJECT_TYPE, builtIns.nullableAnyType,
+                                    fieldInfoForCoroutineLambdaParameter.fieldType, fieldInfoForCoroutineLambdaParameter.fieldKotlinType,
+                                    this
+                                )
+                            }
                         } else {
                             load(index, fieldInfoForCoroutineLambdaParameter.fieldType)
                         }
@@ -831,3 +851,6 @@ private object FailingFunctionGenerationStrategy : FunctionGenerationStrategy()
 fun reportSuspensionPointInsideMonitor(element: KtElement, state: GenerationState, stackTraceElement: String) {
     state.diagnostics.report(ErrorsJvm.SUSPENSION_POINT_INSIDE_MONITOR.on(element, stackTraceElement))
 }
+
+private fun FunctionDescriptor.allValueParameterTypes(): List<KotlinType> =
+    (listOfNotNull(extensionReceiverParameter?.type)) + valueParameters.map { it.type }

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

@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.psi.KtFunction
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import org.jetbrains.kotlin.resolve.inline.isEffectivelyInlineOnly
+import org.jetbrains.kotlin.resolve.isInlineClass
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.OtherOrigin
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
@@ -92,7 +93,9 @@ class SuspendFunctionGenerationStrategy(
             sourceFile = declaration.containingKtFile.name,
             shouldPreserveClassInitialization = constructorCallNormalizationMode.shouldPreserveClassInitialization,
             needDispatchReceiver = originalSuspendDescriptor.dispatchReceiverParameter != null,
-            internalNameForDispatchReceiver = containingClassInternalNameOrNull(),
+            internalNameForDispatchReceiver = (originalSuspendDescriptor.containingDeclaration as? ClassDescriptor)?.let {
+                if (it.isInlineClass()) state.typeMapper.mapType(it).internalName else null
+            } ?: containingClassInternalNameOrNull(),
             languageVersionSettings = languageVersionSettings,
             disableTailCallOptimizationForFunctionReturningUnit = originalSuspendDescriptor.returnType?.isUnit() == true &&
                     originalSuspendDescriptor.overriddenDescriptors.isNotEmpty() &&

compiler/fir/fir2ir/tests/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java

@@ -7743,6 +7743,16 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun.kt");
@@ -7788,6 +7798,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/direct/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_3() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/direct/overrideSuspendFun.kt", "kotlin.coroutines");
@@ -7960,6 +7975,16 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun.kt");
@@ -8005,6 +8030,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resume/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_3() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resume/overrideSuspendFun.kt", "kotlin.coroutines");
@@ -8172,6 +8202,16 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/genericOverrideSuspendFun.kt");
@@ -8207,6 +8247,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_3() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/overrideSuspendFun.kt", "kotlin.coroutines");

compiler/testData/codegen/box/coroutines/inlineClasses/direct/createMangling.kt

@@ -0,0 +1,22 @@
+// WITH_RUNTIME
+
+import kotlin.coroutines.*
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(Continuation(EmptyCoroutineContext) {
+        it.getOrThrow()
+    })
+}
+
+inline class IC(val s: String)
+
+fun box(): String {
+    var res = "FAIL"
+    val lambda: suspend (IC, IC) -> String = { a, b ->
+        a.s + b.s
+    }
+    builder {
+        res = lambda(IC("O"), IC("K"))
+    }
+    return res
+}

compiler/testData/codegen/box/coroutines/inlineClasses/direct/createOverride.kt

@@ -0,0 +1,26 @@
+// WITH_RUNTIME
+// KJS_WITH_FULL_RUNTIME
+
+import kotlin.coroutines.*
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(Continuation(EmptyCoroutineContext) {
+        it.getOrThrow()
+    })
+}
+
+inline class IC(val s: String)
+
+suspend fun <T> List<T>.onEach(c: suspend (T) -> Unit) {
+    for (e in this) {
+        c(e)
+    }
+}
+
+fun box(): String {
+    var res = ""
+    builder {
+        listOf(IC("O"), IC("K")).onEach { res += it.s }
+    }
+    return res
+}

compiler/testData/codegen/box/coroutines/inlineClasses/direct/invokeOperator.kt

@@ -0,0 +1,62 @@
+// WITH_RUNTIME
+
+import kotlin.coroutines.*
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(Continuation(EmptyCoroutineContext) {
+        it.getOrThrow()
+    })
+}
+
+inline class IC(val a: Any?)
+
+class GetResult {
+    suspend operator fun invoke() = IC("OK")
+}
+
+inline class IC1(val a: String) {
+    suspend operator fun invoke() = IC(a)
+}
+
+fun box(): String {
+    var res = "FAIL 1"
+    builder {
+        val getResult = GetResult()
+        res = getResult().a as String
+    }
+    if (res != "OK") return "FAIL 1 $res"
+
+    res = "FAIL 2"
+    builder {
+        val getResult = GetResult()
+        res = getResult.invoke().a as String
+    }
+    if (res != "OK") return "FAIL 2 $res"
+
+    res = "FAIL 3"
+    builder {
+        res = GetResult()().a as String
+    }
+    if (res != "OK") return "FAIL 3 $res"
+
+    res = "FAIL 4"
+    builder {
+        val getResult = IC1("OK")
+        res = getResult().a as String
+    }
+    if (res != "OK") return "FAIL 4 $res"
+
+    res = "FAIL 5"
+    builder {
+        val getResult = IC1("OK")
+        res = getResult.invoke().a as String
+    }
+    if (res != "OK") return "FAIL 5 $res"
+
+    res = "FAIL 6"
+    builder {
+        res = IC1("OK")().a as String
+    }
+    if (res != "OK") return "FAIL 6 $res"
+    return res
+}

compiler/testData/codegen/box/coroutines/inlineClasses/resume/createMangling.kt

@@ -0,0 +1,29 @@
+// WITH_RUNTIME
+
+import kotlin.coroutines.*
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(Continuation(EmptyCoroutineContext) {
+        it.getOrThrow()
+    })
+}
+
+inline class IC(val s: String)
+
+var c: Continuation<Any>? = null
+
+var res = "FAIL"
+
+fun box(): String {
+    val lambda: suspend (IC, IC) -> String = { _, _ ->
+        suspendCoroutine<String> {
+            @Suppress("UNCHECKED_CAST")
+            c = it as Continuation<Any>
+        }
+    }
+    builder {
+        res = lambda(IC("_"), IC("_"))
+    }
+    c?.resume("OK")
+    return res
+}

compiler/testData/codegen/box/coroutines/inlineClasses/resume/createOverride.kt

@@ -0,0 +1,33 @@
+// WITH_RUNTIME
+// KJS_WITH_FULL_RUNTIME
+
+import kotlin.coroutines.*
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(Continuation(EmptyCoroutineContext) {
+        it.getOrThrow()
+    })
+}
+
+inline class IC(val s: String)
+
+suspend fun <T> List<T>.onEach(c: suspend (T) -> Unit) {
+    for (e in this) {
+        c(e)
+    }
+}
+
+var c: Continuation<Any>? = null
+
+fun box(): String {
+    var res = ""
+    builder {
+        listOf(IC("O"), IC("K")).onEach { res += suspendCoroutine<String> { cont ->
+            @Suppress("UNCHECKED_CAST")
+            c = cont as Continuation<Any>
+        }}
+    }
+    c?.resume("O")
+    c?.resume("K")
+    return res
+}

compiler/testData/codegen/box/coroutines/inlineClasses/resume/invokeOperator.kt

@@ -0,0 +1,75 @@
+// WITH_RUNTIME
+
+import kotlin.coroutines.*
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(Continuation(EmptyCoroutineContext) {
+        it.getOrThrow()
+    })
+}
+
+inline class IC(val a: Any?)
+
+var c: Continuation<Any>? = null
+
+suspend fun <T> suspendMe(): T = suspendCoroutine {
+    @Suppress("UNCHECKED_CAST")
+    c = it as Continuation<Any>
+}
+
+class GetResult {
+    suspend operator fun invoke(): IC = suspendMe()
+}
+
+inline class IC1(val a: String) {
+    suspend operator fun invoke(): IC = suspendMe()
+}
+
+fun box(): String {
+    var res = "FAIL 1"
+    builder {
+        val getResult = GetResult()
+        res = getResult().a as String
+    }
+    c?.resume(IC("OK"))
+    if (res != "OK") return "FAIL 1 $res"
+
+    res = "FAIL 2"
+    builder {
+        val getResult = GetResult()
+        res = getResult.invoke().a as String
+    }
+    c?.resume(IC("OK"))
+    if (res != "OK") return "FAIL 2 $res"
+
+    res = "FAIL 3"
+    builder {
+        res = GetResult()().a as String
+    }
+    c?.resume(IC("OK"))
+    if (res != "OK") return "FAIL 3 $res"
+
+    res = "FAIL 4"
+    builder {
+        val getResult = IC1("OK")
+        res = getResult().a as String
+    }
+    c?.resume(IC("OK"))
+    if (res != "OK") return "FAIL 4 $res"
+
+    res = "FAIL 5"
+    builder {
+        val getResult = IC1("OK")
+        res = getResult.invoke().a as String
+    }
+    c?.resume(IC("OK"))
+    if (res != "OK") return "FAIL 5 $res"
+
+    res = "FAIL 6"
+    builder {
+        res = IC1("OK")().a as String
+    }
+    c?.resume(IC("OK"))
+    if (res != "OK") return "FAIL 6 $res"
+    return res
+}

compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createMangling.kt

@@ -0,0 +1,31 @@
+// WITH_RUNTIME
+// WITH_COROUTINES
+
+import kotlin.coroutines.*
+import helpers.*
+
+var result = "FAIL"
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(handleExceptionContinuation {
+        result = it.message!!
+    })
+}
+
+inline class IC(val s: String)
+
+var c: Continuation<Any>? = null
+
+fun box(): String {
+    val lambda: suspend (IC, IC) -> String = { _, _ ->
+        suspendCoroutine<String> {
+            @Suppress("UNCHECKED_CAST")
+            c = it as Continuation<Any>
+        }
+    }
+    builder {
+        lambda(IC("O"), IC("K"))
+    }
+    c?.resumeWithException(IllegalStateException("OK"))
+    return result
+}

compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createOverride.kt

@@ -0,0 +1,35 @@
+// WITH_RUNTIME
+// WITH_COROUTINES
+// KJS_WITH_FULL_RUNTIME
+
+import kotlin.coroutines.*
+import helpers.*
+
+var result = "FAIL"
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(handleExceptionContinuation {
+        result = it.message!!
+    })
+}
+
+inline class IC(val s: String)
+
+suspend fun <T> List<T>.onEach(c: suspend (T) -> Unit) {
+    for (e in this) {
+        c(e)
+    }
+}
+
+var c: Continuation<Any>? = null
+
+fun box(): String {
+    builder {
+        listOf(IC("O"), IC("K")).onEach { suspendCoroutine<String> { cont ->
+            @Suppress("UNCHECKED_CAST")
+            c = cont as Continuation<Any>
+        }}
+    }
+    c?.resumeWithException(IllegalStateException("OK"))
+    return result
+}

compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/invokeOperator.kt

@@ -0,0 +1,78 @@
+// WITH_RUNTIME
+// WITH_COROUTINES
+
+import kotlin.coroutines.*
+import helpers.*
+
+var result = "FAIL"
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(handleExceptionContinuation {
+        result = it.message!!
+    })
+}
+
+inline class IC(val a: Any?)
+
+var c: Continuation<Any>? = null
+
+suspend fun <T> suspendMe(): T = suspendCoroutine {
+    @Suppress("UNCHECKED_CAST")
+    c = it as Continuation<Any>
+}
+
+class GetResult {
+    suspend operator fun invoke(): IC = suspendMe()
+}
+
+inline class IC1(val a: String) {
+    suspend operator fun invoke(): IC = suspendMe()
+}
+
+fun box(): String {
+    builder {
+        val getResult = GetResult()
+        getResult()
+    }
+    c?.resumeWithException(IllegalStateException("OK"))
+    if (result != "OK") return "FAIL 1 $result"
+
+    result = "FAIL 2"
+    builder {
+        val getResult = GetResult()
+        getResult.invoke()
+    }
+    c?.resumeWithException(IllegalStateException("OK"))
+    if (result != "OK") return "FAIL 2 $result"
+
+    result = "FAIL 3"
+    builder {
+        GetResult()()
+    }
+    c?.resumeWithException(IllegalStateException("OK"))
+    if (result != "OK") return "FAIL 3 $result"
+
+    result = "FAIL 4"
+    builder {
+        val getResult = IC1("OK")
+        getResult()
+    }
+    c?.resumeWithException(IllegalStateException("OK"))
+    if (result != "OK") return "FAIL 4 $result"
+
+    result = "FAIL 5"
+    builder {
+        val getResult = IC1("OK")
+        getResult.invoke()
+    }
+    c?.resumeWithException(IllegalStateException("OK"))
+    if (result != "OK") return "FAIL 5 $result"
+
+    result = "FAIL 6"
+    builder {
+        IC1("OK")()
+    }
+    c?.resumeWithException(IllegalStateException("OK"))
+    if (result != "OK") return "FAIL 6 $result"
+    return result
+}

compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java

@@ -8513,6 +8513,16 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun.kt");
@@ -8563,6 +8573,11 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/direct/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_2() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/direct/overrideSuspendFun.kt", "kotlin.coroutines.experimental");
@@ -8815,6 +8830,16 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun.kt");
@@ -8865,6 +8890,11 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resume/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_2() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resume/overrideSuspendFun.kt", "kotlin.coroutines.experimental");
@@ -9112,6 +9142,16 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/genericOverrideSuspendFun.kt");
@@ -9152,6 +9192,11 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_2() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/overrideSuspendFun.kt", "kotlin.coroutines.experimental");

compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java

@@ -8513,6 +8513,16 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun.kt");
@@ -8563,6 +8573,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/direct/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_2() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/direct/overrideSuspendFun.kt", "kotlin.coroutines.experimental");
@@ -8815,6 +8830,16 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun.kt");
@@ -8865,6 +8890,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resume/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_2() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resume/overrideSuspendFun.kt", "kotlin.coroutines.experimental");
@@ -9112,6 +9142,16 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/genericOverrideSuspendFun.kt");
@@ -9152,6 +9192,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_2() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/overrideSuspendFun.kt", "kotlin.coroutines.experimental");

compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java

@@ -7743,6 +7743,16 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun.kt");
@@ -7788,6 +7798,11 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/direct/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_3() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/direct/overrideSuspendFun.kt", "kotlin.coroutines");
@@ -7960,6 +7975,16 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun.kt");
@@ -8005,6 +8030,11 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resume/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_3() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resume/overrideSuspendFun.kt", "kotlin.coroutines");
@@ -8172,6 +8202,16 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/genericOverrideSuspendFun.kt");
@@ -8207,6 +8247,11 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_3() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/overrideSuspendFun.kt", "kotlin.coroutines");

js/js.tests/test/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java

@@ -6498,6 +6498,16 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun.kt");
@@ -6543,6 +6553,11 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/direct/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_3() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/direct/overrideSuspendFun.kt", "kotlin.coroutines");
@@ -6715,6 +6730,16 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun.kt");
@@ -6760,6 +6785,11 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resume/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_3() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resume/overrideSuspendFun.kt", "kotlin.coroutines");
@@ -6927,6 +6957,16 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/genericOverrideSuspendFun.kt");
@@ -6962,6 +7002,11 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_3() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/overrideSuspendFun.kt", "kotlin.coroutines");

js/js.tests/test/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java

@@ -6498,6 +6498,16 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun.kt");
@@ -6543,6 +6553,11 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/direct/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_3() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/direct/overrideSuspendFun.kt", "kotlin.coroutines");
@@ -6715,6 +6730,16 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun.kt");
@@ -6760,6 +6785,11 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resume/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_3() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resume/overrideSuspendFun.kt", "kotlin.coroutines");
@@ -6927,6 +6957,16 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/genericOverrideSuspendFun.kt");
@@ -6962,6 +7002,11 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_3() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/overrideSuspendFun.kt", "kotlin.coroutines");

js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java

@@ -6498,6 +6498,16 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun.kt");
@@ -6543,6 +6553,11 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/direct/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_3() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/direct/overrideSuspendFun.kt", "kotlin.coroutines");
@@ -6715,6 +6730,16 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun.kt");
@@ -6760,6 +6785,11 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resume/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_3() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resume/overrideSuspendFun.kt", "kotlin.coroutines");
@@ -6927,6 +6957,16 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFun_Int.kt");
                 }
 
+                @TestMetadata("createMangling.kt")
+                public void testCreateMangling() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createMangling.kt");
+                }
+
+                @TestMetadata("createOverride.kt")
+                public void testCreateOverride() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createOverride.kt");
+                }
+
                 @TestMetadata("genericOverrideSuspendFun.kt")
                 public void testGenericOverrideSuspendFun() throws Exception {
                     runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/genericOverrideSuspendFun.kt");
@@ -6962,6 +7002,11 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/interfaceDelegateWithInlineClass.kt", "kotlin.coroutines");
                 }
 
+                @TestMetadata("invokeOperator.kt")
+                public void testInvokeOperator() throws Exception {
+                    runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/invokeOperator.kt");
+                }
+
                 @TestMetadata("overrideSuspendFun.kt")
                 public void testOverrideSuspendFun_1_3() throws Exception {
                     runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/overrideSuspendFun.kt", "kotlin.coroutines");