update reachable nodes

#KT-24863 Fixed

compiler/backend-common/src/org/jetbrains/kotlin/backend/common/commonCoroutineCodegenUtil.kt

@@ -5,14 +5,15 @@
 
 package org.jetbrains.kotlin.backend.common
 
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.coroutinesIntrinsicsPackageFqName
+import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.DescriptorEquivalenceForOverrides
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
-import org.jetbrains.kotlin.config.LanguageVersionSettings
 
 val SUSPEND_COROUTINE_OR_RETURN_NAME = Name.identifier("suspendCoroutineOrReturn")
 val INTERCEPTED_NAME = Name.identifier("intercepted")
@@ -21,7 +22,7 @@ val COROUTINE_SUSPENDED_NAME = Name.identifier("COROUTINE_SUSPENDED")
 val SUSPEND_COROUTINE_UNINTERCEPTED_OR_RETURN_NAME = Name.identifier("suspendCoroutineUninterceptedOrReturn")
 
 fun FunctionDescriptor.isBuiltInIntercepted(languageVersionSettings: LanguageVersionSettings): Boolean {
-    if (name != INTERCEPTED_NAME) return false
+    if (name != INTERCEPTED_NAME || languageVersionSettings.isReleaseCoroutines()) return false
     val original =
         module.getPackage(languageVersionSettings.coroutinesIntrinsicsPackageFqName()).memberScope
             .getContributedFunctions(INTERCEPTED_NAME, NoLookupLocation.FROM_BACKEND)
@@ -30,7 +31,7 @@ fun FunctionDescriptor.isBuiltInIntercepted(languageVersionSettings: LanguageVer
 }
 
 fun FunctionDescriptor.isBuiltInSuspendCoroutineOrReturn(languageVersionSettings: LanguageVersionSettings): Boolean {
-    if (name != SUSPEND_COROUTINE_OR_RETURN_NAME) return false
+    if (name != SUSPEND_COROUTINE_OR_RETURN_NAME || languageVersionSettings.isReleaseCoroutines()) return false
 
     val originalDeclaration = getBuiltInSuspendCoroutineOrReturn(languageVersionSettings) ?: return false
 

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

@@ -422,7 +422,7 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
 
             String superClassConstructorDescriptor;
             if (superClassAsmType.equals(LAMBDA) || superClassAsmType.equals(FUNCTION_REFERENCE) ||
-                superClassAsmType.equals(CoroutineCodegenUtilKt.coroutineImplAsmType(state.getLanguageVersionSettings()))) {
+                CoroutineCodegenUtilKt.isCoroutineImpl(state.getLanguageVersionSettings(), superClassAsmType.getInternalName())) {
                 int arity = calculateArity();
                 iv.iconst(arity);
                 if (shouldHaveBoundReferenceReceiver) {

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

@@ -38,7 +38,6 @@ import org.jetbrains.kotlin.load.java.JvmAbi;
 import org.jetbrains.kotlin.load.java.SpecialBuiltinMembers;
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor;
 import org.jetbrains.kotlin.name.FqName;
-import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
@@ -690,7 +689,10 @@ public class FunctionCodegen {
                 }
             } else {
                 FunctionDescriptor lambdaDescriptor = ((ClosureContext) context.getParentContext()).getOriginalSuspendLambdaDescriptor();
-                if (lambdaDescriptor != null && functionDescriptor.getName().equals(Name.identifier("doResume"))) {
+                if (lambdaDescriptor != null &&
+                    CoroutineCodegenUtilKt.isResumeImplMethodName(
+                            parentCodegen.state.getLanguageVersionSettings(), functionDescriptor.getName().asString()
+                    )) {
                     destructuredParametersForSuspendLambda.addAll(lambdaDescriptor.getValueParameters());
                 }
             }

compiler/backend/src/org/jetbrains/kotlin/codegen/JvmRuntimeTypes.kt

@@ -8,9 +8,10 @@ package org.jetbrains.kotlin.codegen
 import org.jetbrains.kotlin.builtins.createFunctionType
 import org.jetbrains.kotlin.codegen.coroutines.coroutinesJvmInternalPackageFqName
 import org.jetbrains.kotlin.codegen.coroutines.getOrCreateJvmSuspendFunctionView
-import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.codegen.coroutines.isSuspendLambdaOrLocalFunction
 import org.jetbrains.kotlin.config.LanguageFeature
-import org.jetbrains.kotlin.coroutines.isSuspendLambda
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor
@@ -19,6 +20,7 @@ import org.jetbrains.kotlin.descriptors.impl.MutableClassDescriptor
 import org.jetbrains.kotlin.descriptors.impl.MutablePackageFragmentDescriptor
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.calls.checkers.isRestrictsSuspensionReceiver
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.types.KotlinType
@@ -34,7 +36,33 @@ class JvmRuntimeTypes(module: ModuleDescriptor, private val languageVersionSetti
     private val functionReference: ClassDescriptor by klass("FunctionReference")
     private val localVariableReference: ClassDescriptor by klass("LocalVariableReference")
     private val mutableLocalVariableReference: ClassDescriptor by klass("MutableLocalVariableReference")
-    private val coroutineImplClass by lazy { createClass(kotlinCoroutinesJvmInternalPackage, "CoroutineImpl") }
+
+    private val coroutineImpl: ClassDescriptor by lazy {
+        createClass(kotlinCoroutinesJvmInternalPackage, "CoroutineImpl")
+    }
+
+    private val continuationImpl by lazy {
+        createReleaseCoroutineSuperClassOrCoroutineImpl("ContinuationImpl")
+    }
+
+    private val restrictedContinuationImpl by lazy {
+        createReleaseCoroutineSuperClassOrCoroutineImpl("RestrictedContinuationImpl")
+    }
+
+    private val suspendLambda by lazy {
+        createReleaseCoroutineSuperClassOrCoroutineImpl("SuspendLambda")
+    }
+
+    private val restrictedSuspendLambda by lazy {
+        createReleaseCoroutineSuperClassOrCoroutineImpl("RestrictedSuspendLambda")
+    }
+
+    private fun createReleaseCoroutineSuperClassOrCoroutineImpl(className: String): ClassDescriptor {
+        return if (languageVersionSettings.isReleaseCoroutines())
+            createClass(kotlinCoroutinesJvmInternalPackage, className)
+        else
+            coroutineImpl
+    }
 
     private val propertyReferences: List<ClassDescriptor> by lazy {
         (0..2).map { i -> createClass(kotlinJvmInternalPackage, "PropertyReference$i") }
@@ -76,8 +104,21 @@ class JvmRuntimeTypes(module: ModuleDescriptor, private val languageVersionSetti
 
         if (descriptor.isSuspend) {
             return mutableListOf<KotlinType>().apply {
-                add(coroutineImplClass.defaultType)
-                if (descriptor.isSuspendLambda) {
+                if (actualFunctionDescriptor.extensionReceiverParameter?.type?.isRestrictsSuspensionReceiver(languageVersionSettings) == true) {
+                    if (descriptor.isSuspendLambdaOrLocalFunction()) {
+                        add(restrictedSuspendLambda.defaultType)
+                    } else {
+                        add(restrictedContinuationImpl.defaultType)
+                    }
+                } else {
+                    if (descriptor.isSuspendLambdaOrLocalFunction()) {
+                        add(suspendLambda.defaultType)
+                    } else {
+                        add(continuationImpl.defaultType)
+                    }
+                }
+
+                if (descriptor.isSuspendLambdaOrLocalFunction()) {
                     add(functionType)
                 }
             }

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

@@ -14,13 +14,16 @@ import org.jetbrains.kotlin.codegen.context.ClosureContext
 import org.jetbrains.kotlin.codegen.context.MethodContext
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializerExtension
 import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
 import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.KtDeclarationWithBody
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtFunction
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
@@ -41,48 +44,60 @@ import org.jetbrains.org.objectweb.asm.commons.Method
 
 
 abstract class AbstractCoroutineCodegen(
-        outerExpressionCodegen: ExpressionCodegen,
-        element: KtElement,
-        closureContext: ClosureContext,
-        classBuilder: ClassBuilder,
-        userDataForDoResume: Map<out FunctionDescriptor.UserDataKey<*>, *>? = null
+    outerExpressionCodegen: ExpressionCodegen,
+    element: KtElement,
+    closureContext: ClosureContext,
+    classBuilder: ClassBuilder,
+    private val userDataForDoResume: Map<out FunctionDescriptor.UserDataKey<*>, *>? = null
 ) : ClosureCodegen(
-        outerExpressionCodegen.state,
-        element, null, closureContext, null,
-        FailingFunctionGenerationStrategy,
-        outerExpressionCodegen.parentCodegen, classBuilder
+    outerExpressionCodegen.state,
+    element, null, closureContext, null,
+    FailingFunctionGenerationStrategy,
+    outerExpressionCodegen.parentCodegen, classBuilder
 ) {
     protected val classDescriptor = closureContext.contextDescriptor
     protected val languageVersionSettings = outerExpressionCodegen.state.languageVersionSettings
 
-    protected val doResumeDescriptor =
-            SimpleFunctionDescriptorImpl.create(
-                    classDescriptor, Annotations.EMPTY, Name.identifier(DO_RESUME_METHOD_NAME), CallableMemberDescriptor.Kind.DECLARATION,
-                    funDescriptor.source
-            ).apply doResume@{
-                initialize(
-                      null,
-                      classDescriptor.thisAsReceiverParameter,
-                      emptyList(),
-                      listOf(
-                              createValueParameterForDoResume(Name.identifier("data"), builtIns.nullableAnyType, 0),
-                              createValueParameterForDoResume(Name.identifier("throwable"), builtIns.throwable.defaultType.makeNullable(), 1)
-                      ),
-                      builtIns.nullableAnyType,
-                      Modality.FINAL,
-                      Visibilities.PUBLIC,
-                      userDataForDoResume
-                )
-            }
+    protected val methodToImplement =
+        if (languageVersionSettings.isReleaseCoroutines())
+            createImplMethod(
+                INVOKE_SUSPEND_METHOD_NAME,
+                "result" to classDescriptor.module.getSuccessOrFailure(classDescriptor.builtIns.anyType)
+            )
+        else
+            createImplMethod(
+                DO_RESUME_METHOD_NAME,
+                "data" to classDescriptor.builtIns.nullableAnyType,
+                "throwable" to classDescriptor.builtIns.throwable.defaultType.makeNullable()
+            )
+
+    private fun createImplMethod(name: String, vararg parameters: Pair<String, KotlinType>) =
+        SimpleFunctionDescriptorImpl.create(
+            classDescriptor, Annotations.EMPTY, Name.identifier(name), CallableMemberDescriptor.Kind.DECLARATION,
+            funDescriptor.source
+        ).apply doResume@{
+            initialize(
+                null,
+                classDescriptor.thisAsReceiverParameter,
+                emptyList(),
+                parameters.withIndex().map { (index, nameAndType) ->
+                    createValueParameterForDoResume(Name.identifier(nameAndType.first), nameAndType.second, index)
+                },
+                builtIns.nullableAnyType,
+                Modality.FINAL,
+                Visibilities.PUBLIC,
+                userDataForDoResume
+            )
+        }
 
     private fun FunctionDescriptor.createValueParameterForDoResume(name: Name, type: KotlinType, index: Int) =
-            ValueParameterDescriptorImpl(
-                    this, null, index, Annotations.EMPTY, name,
-                    type,
-                    false, false,
-                    false,
-                    null, SourceElement.NO_SOURCE
-            )
+        ValueParameterDescriptorImpl(
+            this, null, index, Annotations.EMPTY, name,
+            type,
+            false, false,
+            false,
+            null, SourceElement.NO_SOURCE
+        )
 
     override fun generateConstructor(): Method {
         val args = calculateConstructorParameters(typeMapper, closure, asmType)
@@ -90,8 +105,8 @@ abstract class AbstractCoroutineCodegen(
 
         val constructor = Method("<init>", Type.VOID_TYPE, argTypes)
         val mv = v.newMethod(
-                OtherOrigin(element, funDescriptor), visibilityFlag, "<init>", constructor.descriptor, null,
-                ArrayUtil.EMPTY_STRING_ARRAY
+            OtherOrigin(element, funDescriptor), visibilityFlag, "<init>", constructor.descriptor, null,
+            ArrayUtil.EMPTY_STRING_ARRAY
         )
 
         if (state.classBuilderMode.generateBodies) {
@@ -101,13 +116,22 @@ abstract class AbstractCoroutineCodegen(
             iv.generateClosureFieldsInitializationFromParameters(closure, args)
 
             iv.load(0, AsmTypes.OBJECT_TYPE)
-            iv.iconst(if (passArityToSuperClass) calculateArity() else 0)
+            val hasArityParameter = !languageVersionSettings.isReleaseCoroutines() || passArityToSuperClass
+            if (hasArityParameter) {
+                iv.iconst(if (passArityToSuperClass) calculateArity() else 0)
+            }
+
             iv.load(argTypes.map { it.size }.sum(), AsmTypes.OBJECT_TYPE)
 
+            val parameters =
+                if (hasArityParameter)
+                    listOf(Type.INT_TYPE, languageVersionSettings.continuationAsmType())
+                else
+                    listOf(languageVersionSettings.continuationAsmType())
+
             val superClassConstructorDescriptor = Type.getMethodDescriptor(
                 Type.VOID_TYPE,
-                Type.INT_TYPE,
-                languageVersionSettings.continuationAsmType()
+                *parameters.toTypedArray()
             )
             iv.invokespecial(superClassAsmType.internalName, "<init>", superClassConstructorDescriptor, false)
 
@@ -116,6 +140,10 @@ abstract class AbstractCoroutineCodegen(
             FunctionCodegen.endVisit(iv, "constructor", element)
         }
 
+        if (languageVersionSettings.isReleaseCoroutines()) {
+            v.newField(JvmDeclarationOrigin.NO_ORIGIN, AsmUtil.NO_FLAG_PACKAGE_PRIVATE, "label", "I", null, null)
+        }
+
         return constructor
     }
 
@@ -123,15 +151,15 @@ abstract class AbstractCoroutineCodegen(
 }
 
 class CoroutineCodegenForLambda private constructor(
-        outerExpressionCodegen: ExpressionCodegen,
-        element: KtElement,
-        private val closureContext: ClosureContext,
-        classBuilder: ClassBuilder,
-        private val originalSuspendFunctionDescriptor: FunctionDescriptor,
-        private val forInline: Boolean
+    outerExpressionCodegen: ExpressionCodegen,
+    element: KtElement,
+    private val closureContext: ClosureContext,
+    classBuilder: ClassBuilder,
+    private val originalSuspendFunctionDescriptor: FunctionDescriptor,
+    private val forInline: Boolean
 ) : AbstractCoroutineCodegen(
-        outerExpressionCodegen, element, closureContext, classBuilder,
-        userDataForDoResume = mapOf(INITIAL_SUSPEND_DESCRIPTOR_FOR_DO_RESUME to originalSuspendFunctionDescriptor)
+    outerExpressionCodegen, element, closureContext, classBuilder,
+    userDataForDoResume = mapOf(INITIAL_SUSPEND_DESCRIPTOR_FOR_DO_RESUME to originalSuspendFunctionDescriptor)
 ) {
     private val builtIns = funDescriptor.builtIns
 
@@ -157,10 +185,10 @@ class CoroutineCodegenForLambda private constructor(
         for (parameter in allFunctionParameters()) {
             val fieldInfo = parameter.getFieldInfoForCoroutineLambdaParameter()
             v.newField(
-                    OtherOrigin(parameter),
-                    Opcodes.ACC_PRIVATE,
-                    fieldInfo.fieldName,
-                    fieldInfo.fieldType.descriptor, null, null
+                OtherOrigin(parameter),
+                Opcodes.ACC_PRIVATE,
+                fieldInfo.fieldName,
+                fieldInfo.fieldType.descriptor, null, null
             )
         }
 
@@ -200,24 +228,28 @@ class CoroutineCodegenForLambda private constructor(
         // this
         load(0, AsmTypes.OBJECT_TYPE)
         val parameterTypes = signature.valueParameters.map { it.asmType }
-        parameterTypes.withVariableIndices().forEach {
-            (index, type) -> load(index + 1, type)
+        parameterTypes.withVariableIndices().forEach { (index, type) ->
+            load(index + 1, type)
         }
 
         // this.create(..)
         invokevirtual(
-                v.thisName,
-                createCoroutineDescriptor.name.identifier,
-                Type.getMethodDescriptor(
-                    languageVersionSettings.continuationAsmType(),
-                    *parameterTypes.toTypedArray()
-                ),
-                false
+            v.thisName,
+            createCoroutineDescriptor.name.identifier,
+            Type.getMethodDescriptor(
+                languageVersionSettings.continuationAsmType(),
+                *parameterTypes.toTypedArray()
+            ),
+            false
         )
         checkcast(Type.getObjectType(v.thisName))
 
         // .doResume(Unit)
-        invokeDoResumeWithUnit(v.thisName)
+        if (languageVersionSettings.isReleaseCoroutines()) {
+            invokeInvokeSuspendWithUnit(v.thisName)
+        } else {
+            invokeDoResumeWithUnit(v.thisName)
+        }
         areturn(AsmTypes.OBJECT_TYPE)
     }
 
@@ -269,9 +301,9 @@ class CoroutineCodegenForLambda private constructor(
     private fun ExpressionCodegen.initializeCoroutineParameters() {
         for (parameter in allFunctionParameters()) {
             val fieldStackValue =
-                    StackValue.field(
-                            parameter.getFieldInfoForCoroutineLambdaParameter(), generateThisOrOuter(context.thisDescriptor, false)
-                    )
+                StackValue.field(
+                    parameter.getFieldInfoForCoroutineLambdaParameter(), generateThisOrOuter(context.thisDescriptor, false)
+                )
 
             val mappedType = typeMapper.mapType(parameter.type)
             fieldStackValue.put(mappedType, v)
@@ -284,93 +316,97 @@ class CoroutineCodegenForLambda private constructor(
     }
 
     private fun allFunctionParameters() =
-            originalSuspendFunctionDescriptor.extensionReceiverParameter.let(::listOfNotNull) +
-            originalSuspendFunctionDescriptor.valueParameters
+        originalSuspendFunctionDescriptor.extensionReceiverParameter.let(::listOfNotNull) +
+                originalSuspendFunctionDescriptor.valueParameters
 
     private fun ParameterDescriptor.getFieldInfoForCoroutineLambdaParameter() =
-            createHiddenFieldInfo(type, COROUTINE_LAMBDA_PARAMETER_PREFIX + (this.safeAs<ValueParameterDescriptor>()?.index ?: ""))
+        createHiddenFieldInfo(type, COROUTINE_LAMBDA_PARAMETER_PREFIX + (this.safeAs<ValueParameterDescriptor>()?.index ?: ""))
 
     private fun createHiddenFieldInfo(type: KotlinType, name: String) =
-            FieldInfo.createForHiddenField(
-                    typeMapper.mapClass(closureContext.thisDescriptor),
-                    typeMapper.mapType(type),
-                    name
-            )
+        FieldInfo.createForHiddenField(
+            typeMapper.mapClass(closureContext.thisDescriptor),
+            typeMapper.mapType(type),
+            name
+        )
 
     private fun generateDoResume() {
         functionCodegen.generateMethod(
-                OtherOrigin(element),
-                doResumeDescriptor,
-                object : FunctionGenerationStrategy.FunctionDefault(state, element as KtDeclarationWithBody) {
+            OtherOrigin(element),
+            methodToImplement,
+            object : FunctionGenerationStrategy.FunctionDefault(state, element as KtDeclarationWithBody) {
 
-                    override fun wrapMethodVisitor(mv: MethodVisitor, access: Int, name: String, desc: String): MethodVisitor {
-                        if (forInline) return super.wrapMethodVisitor(mv, access, name, desc)
-                        return CoroutineTransformerMethodVisitor(
-                            mv, access, name, desc, null, null,
-                            obtainClassBuilderForCoroutineState = { v },
-                            lineNumber = CodegenUtil.getLineNumberForElement(element, false) ?: 0,
-                            shouldPreserveClassInitialization = constructorCallNormalizationMode.shouldPreserveClassInitialization,
-                            containingClassInternalName = v.thisName,
-                            isForNamedFunction = false,
-                            languageVersionSettings = languageVersionSettings
-                        )
-                    }
-
-                    override fun doGenerateBody(codegen: ExpressionCodegen, signature: JvmMethodSignature) {
-                        codegen.initializeCoroutineParameters()
-                        super.doGenerateBody(codegen, signature)
-                    }
+                override fun wrapMethodVisitor(mv: MethodVisitor, access: Int, name: String, desc: String): MethodVisitor {
+                    if (forInline) return super.wrapMethodVisitor(mv, access, name, desc)
+                    return CoroutineTransformerMethodVisitor(
+                        mv, access, name, desc, null, null,
+                        obtainClassBuilderForCoroutineState = { v },
+                        lineNumber = CodegenUtil.getLineNumberForElement(element, false) ?: 0,
+                        shouldPreserveClassInitialization = constructorCallNormalizationMode.shouldPreserveClassInitialization,
+                        containingClassInternalName = v.thisName,
+                        isForNamedFunction = false,
+                        languageVersionSettings = languageVersionSettings
+                    )
                 }
+
+                override fun doGenerateBody(codegen: ExpressionCodegen, signature: JvmMethodSignature) {
+                    codegen.initializeCoroutineParameters()
+                    super.doGenerateBody(codegen, signature)
+                }
+            }
         )
     }
 
     companion object {
         @JvmStatic
         fun create(
-                expressionCodegen: ExpressionCodegen,
-                originalSuspendLambdaDescriptor: FunctionDescriptor,
-                declaration: KtElement,
-                classBuilder: ClassBuilder
+            expressionCodegen: ExpressionCodegen,
+            originalSuspendLambdaDescriptor: FunctionDescriptor,
+            declaration: KtElement,
+            classBuilder: ClassBuilder
         ): ClosureCodegen? {
             if (!originalSuspendLambdaDescriptor.isSuspendLambdaOrLocalFunction()) return null
 
             return CoroutineCodegenForLambda(
-                    expressionCodegen,
-                    declaration,
-                    expressionCodegen.context.intoCoroutineClosure(
-                        getOrCreateJvmSuspendFunctionView(
-                            originalSuspendLambdaDescriptor,
-                            expressionCodegen.state.languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines),
-                            expressionCodegen.state.bindingContext
-                        ),
-                        originalSuspendLambdaDescriptor, expressionCodegen, expressionCodegen.state.typeMapper
+                expressionCodegen,
+                declaration,
+                expressionCodegen.context.intoCoroutineClosure(
+                    getOrCreateJvmSuspendFunctionView(
+                        originalSuspendLambdaDescriptor,
+                        expressionCodegen.state.languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines),
+                        expressionCodegen.state.bindingContext
                     ),
-                    classBuilder,
-                    originalSuspendLambdaDescriptor,
-                    // Local suspend lambdas, which call crossinline suspend parameters of containing functions must be generated after inlining
-                    expressionCodegen.bindingContext[CAPTURES_CROSSINLINE_SUSPEND_LAMBDA, originalSuspendLambdaDescriptor] == true
+                    originalSuspendLambdaDescriptor, expressionCodegen, expressionCodegen.state.typeMapper
+                ),
+                classBuilder,
+                originalSuspendLambdaDescriptor,
+                // Local suspend lambdas, which call crossinline suspend parameters of containing functions must be generated after inlining
+                expressionCodegen.bindingContext[CAPTURES_CROSSINLINE_SUSPEND_LAMBDA, originalSuspendLambdaDescriptor] == true
             )
         }
     }
 }
 
 class CoroutineCodegenForNamedFunction private constructor(
-        outerExpressionCodegen: ExpressionCodegen,
-        element: KtElement,
-        closureContext: ClosureContext,
-        classBuilder: ClassBuilder,
-        originalSuspendFunctionDescriptor: FunctionDescriptor
+    outerExpressionCodegen: ExpressionCodegen,
+    element: KtElement,
+    closureContext: ClosureContext,
+    classBuilder: ClassBuilder,
+    originalSuspendFunctionDescriptor: FunctionDescriptor
 ) : AbstractCoroutineCodegen(outerExpressionCodegen, element, closureContext, classBuilder) {
-    private val labelFieldStackValue = StackValue.field(
-        FieldInfo.createForHiddenField(
-            outerExpressionCodegen.state.languageVersionSettings.coroutineImplAsmType(),
-            Type.INT_TYPE,
-            COROUTINE_LABEL_FIELD_NAME
-        ),
-        StackValue.LOCAL_0
-    )
+    private val labelFieldStackValue by lazy {
+        StackValue.field(
+            FieldInfo.createForHiddenField(
+                computeLabelOwner(languageVersionSettings, v.thisName),
+                Type.INT_TYPE,
+                COROUTINE_LABEL_FIELD_NAME
+            ),
+            StackValue.LOCAL_0
+        )
+    }
+
+
     private val suspendFunctionJvmView =
-            bindingContext[CodegenBinding.SUSPEND_FUNCTION_TO_JVM_VIEW, originalSuspendFunctionDescriptor]!!
+        bindingContext[CodegenBinding.SUSPEND_FUNCTION_TO_JVM_VIEW, originalSuspendFunctionDescriptor]!!
 
     override val passArityToSuperClass get() = false
 
@@ -385,85 +421,89 @@ class CoroutineCodegenForNamedFunction private constructor(
         generateSetLabelMethod()
 
         v.newField(
-                JvmDeclarationOrigin.NO_ORIGIN, Opcodes.ACC_SYNTHETIC or AsmUtil.NO_FLAG_PACKAGE_PRIVATE,
-                DATA_FIELD_NAME, AsmTypes.OBJECT_TYPE.descriptor, null, null
+            JvmDeclarationOrigin.NO_ORIGIN, Opcodes.ACC_SYNTHETIC or AsmUtil.NO_FLAG_PACKAGE_PRIVATE,
+            DATA_FIELD_NAME, AsmTypes.OBJECT_TYPE.descriptor, null, null
         )
-        v.newField(
+
+        if (!languageVersionSettings.isReleaseCoroutines()) {
+            v.newField(
                 JvmDeclarationOrigin.NO_ORIGIN, Opcodes.ACC_SYNTHETIC or AsmUtil.NO_FLAG_PACKAGE_PRIVATE,
                 EXCEPTION_FIELD_NAME, AsmTypes.JAVA_THROWABLE_TYPE.descriptor, null, null
-        )
+            )
+        }
     }
 
     private fun generateDoResume() {
         functionCodegen.generateMethod(
-                OtherOrigin(element),
-                doResumeDescriptor,
-                object : FunctionGenerationStrategy.CodegenBased(state) {
-                    override fun doGenerateBody(codegen: ExpressionCodegen, signature: JvmMethodSignature) {
-                        StackValue.field(
-                                AsmTypes.OBJECT_TYPE, Type.getObjectType(v.thisName), DATA_FIELD_NAME, false,
-                                StackValue.LOCAL_0
-                        ).store(StackValue.local(1, AsmTypes.OBJECT_TYPE), codegen.v)
+            OtherOrigin(element),
+            methodToImplement,
+            object : FunctionGenerationStrategy.CodegenBased(state) {
+                override fun doGenerateBody(codegen: ExpressionCodegen, signature: JvmMethodSignature) {
+                    StackValue.field(
+                        AsmTypes.OBJECT_TYPE, Type.getObjectType(v.thisName), DATA_FIELD_NAME, false,
+                        StackValue.LOCAL_0
+                    ).store(StackValue.local(1, AsmTypes.OBJECT_TYPE), codegen.v)
 
+                    if (!languageVersionSettings.isReleaseCoroutines()) {
                         StackValue.field(
-                                AsmTypes.JAVA_THROWABLE_TYPE, Type.getObjectType(v.thisName), EXCEPTION_FIELD_NAME, false,
-                                StackValue.LOCAL_0
+                            AsmTypes.JAVA_THROWABLE_TYPE, Type.getObjectType(v.thisName), EXCEPTION_FIELD_NAME, false,
+                            StackValue.LOCAL_0
                         ).store(StackValue.local(2, AsmTypes.JAVA_THROWABLE_TYPE), codegen.v)
+                    }
 
-                        labelFieldStackValue.store(
-                            StackValue.operation(Type.INT_TYPE) {
-                                labelFieldStackValue.put(Type.INT_TYPE, it)
-                                it.iconst(1 shl 31)
-                                it.or(Type.INT_TYPE)
-                            },
-                            codegen.v
+                    labelFieldStackValue.store(
+                        StackValue.operation(Type.INT_TYPE) {
+                            labelFieldStackValue.put(Type.INT_TYPE, it)
+                            it.iconst(1 shl 31)
+                            it.or(Type.INT_TYPE)
+                        },
+                        codegen.v
+                    )
+
+                    val captureThisType = closure.captureThis?.let(typeMapper::mapType)
+                    if (captureThisType != null) {
+                        StackValue.field(
+                            captureThisType, Type.getObjectType(v.thisName), AsmUtil.CAPTURED_THIS_FIELD,
+                            false, StackValue.LOCAL_0
+                        ).put(captureThisType, codegen.v)
+                    }
+
+                    val isInterfaceMethod = DescriptorUtils.isInterface(suspendFunctionJvmView.containingDeclaration)
+                    val callableMethod =
+                        typeMapper.mapToCallableMethod(
+                            suspendFunctionJvmView,
+                            // Obtain default impls method for interfaces
+                            isInterfaceMethod
                         )
 
-                        val captureThisType = closure.captureThis?.let(typeMapper::mapType)
-                        if (captureThisType != null) {
-                            StackValue.field(
-                                    captureThisType, Type.getObjectType(v.thisName), AsmUtil.CAPTURED_THIS_FIELD,
-                                    false, StackValue.LOCAL_0
-                            ).put(captureThisType, codegen.v)
-                        }
-
-                        val isInterfaceMethod = DescriptorUtils.isInterface(suspendFunctionJvmView.containingDeclaration)
-                        val callableMethod =
-                                typeMapper.mapToCallableMethod(
-                                        suspendFunctionJvmView,
-                                        // Obtain default impls method for interfaces
-                                        isInterfaceMethod
-                                )
-
-                        for (argumentType in callableMethod.getAsmMethod().argumentTypes.dropLast(1)) {
-                            AsmUtil.pushDefaultValueOnStack(argumentType, codegen.v)
-                        }
-
-                        codegen.v.load(0, AsmTypes.OBJECT_TYPE)
-
-                        if (suspendFunctionJvmView.isOverridable && !isInterfaceMethod && captureThisType != null) {
-                            val owner = captureThisType.internalName
-                            val impl = callableMethod.getAsmMethod().getImplForOpenMethod(owner)
-                            codegen.v.invokestatic(owner, impl.name, impl.descriptor, false)
-                        }
-                        else {
-                            callableMethod.genInvokeInstruction(codegen.v)
-                        }
-
-                        codegen.v.visitInsn(Opcodes.ARETURN)
+                    for (argumentType in callableMethod.getAsmMethod().argumentTypes.dropLast(1)) {
+                        AsmUtil.pushDefaultValueOnStack(argumentType, codegen.v)
                     }
+
+                    codegen.v.load(0, AsmTypes.OBJECT_TYPE)
+
+                    if (suspendFunctionJvmView.isOverridable && !isInterfaceMethod && captureThisType != null) {
+                        val owner = captureThisType.internalName
+                        val impl = callableMethod.getAsmMethod().getImplForOpenMethod(owner)
+                        codegen.v.invokestatic(owner, impl.name, impl.descriptor, false)
+                    } else {
+                        callableMethod.genInvokeInstruction(codegen.v)
+                    }
+
+                    codegen.v.visitInsn(Opcodes.ARETURN)
                 }
+            }
         )
     }
 
     private fun generateGetLabelMethod() {
         val mv = v.newMethod(
-                JvmDeclarationOrigin.NO_ORIGIN,
-                Opcodes.ACC_SYNTHETIC or Opcodes.ACC_FINAL or AsmUtil.NO_FLAG_PACKAGE_PRIVATE,
-                "getLabel",
-                Type.getMethodDescriptor(Type.INT_TYPE),
-                null,
-                null
+            JvmDeclarationOrigin.NO_ORIGIN,
+            Opcodes.ACC_SYNTHETIC or Opcodes.ACC_FINAL or AsmUtil.NO_FLAG_PACKAGE_PRIVATE,
+            "getLabel",
+            Type.getMethodDescriptor(Type.INT_TYPE),
+            null,
+            null
         )
 
         mv.visitCode()
@@ -474,12 +514,12 @@ class CoroutineCodegenForNamedFunction private constructor(
 
     private fun generateSetLabelMethod() {
         val mv = v.newMethod(
-                JvmDeclarationOrigin.NO_ORIGIN,
-                Opcodes.ACC_SYNTHETIC or Opcodes.ACC_FINAL or AsmUtil.NO_FLAG_PACKAGE_PRIVATE,
-                "setLabel",
-                Type.getMethodDescriptor(Type.VOID_TYPE, Type.INT_TYPE),
-                null,
-                null
+            JvmDeclarationOrigin.NO_ORIGIN,
+            Opcodes.ACC_SYNTHETIC or Opcodes.ACC_FINAL or AsmUtil.NO_FLAG_PACKAGE_PRIVATE,
+            "setLabel",
+            Type.getMethodDescriptor(Type.VOID_TYPE, Type.INT_TYPE),
+            null,
+            null
         )
 
         mv.visitCode()
@@ -495,36 +535,37 @@ class CoroutineCodegenForNamedFunction private constructor(
             AsmUtil.writeAnnotationData(av, serializer, functionProto)
         }
     }
+
     companion object {
         fun create(
-                cv: ClassBuilder,
-                expressionCodegen: ExpressionCodegen,
-                originalSuspendDescriptor: FunctionDescriptor,
-                declaration: KtFunction
+            cv: ClassBuilder,
+            expressionCodegen: ExpressionCodegen,
+            originalSuspendDescriptor: FunctionDescriptor,
+            declaration: KtFunction
         ): CoroutineCodegenForNamedFunction {
             val bindingContext = expressionCodegen.state.bindingContext
             val closure =
-                    bindingContext[
-                            CodegenBinding.CLOSURE,
-                            bindingContext[CodegenBinding.CLASS_FOR_CALLABLE, originalSuspendDescriptor]
-                    ].sure { "There must be a closure defined for $originalSuspendDescriptor" }
+                bindingContext[
+                        CodegenBinding.CLOSURE,
+                        bindingContext[CodegenBinding.CLASS_FOR_CALLABLE, originalSuspendDescriptor]
+                ].sure { "There must be a closure defined for $originalSuspendDescriptor" }
 
             val suspendFunctionView =
-                    bindingContext[
-                            CodegenBinding.SUSPEND_FUNCTION_TO_JVM_VIEW, originalSuspendDescriptor
-                    ].sure { "There must be a jvm view defined for $originalSuspendDescriptor" }
+                bindingContext[
+                        CodegenBinding.SUSPEND_FUNCTION_TO_JVM_VIEW, originalSuspendDescriptor
+                ].sure { "There must be a jvm view defined for $originalSuspendDescriptor" }
 
             if (suspendFunctionView.dispatchReceiverParameter != null) {
                 closure.setCaptureThis()
             }
 
             return CoroutineCodegenForNamedFunction(
-                    expressionCodegen, declaration,
-                    expressionCodegen.context.intoClosure(
-                            originalSuspendDescriptor, expressionCodegen, expressionCodegen.state.typeMapper
-                    ),
-                    cv,
-                    originalSuspendDescriptor
+                expressionCodegen, declaration,
+                expressionCodegen.context.intoClosure(
+                    originalSuspendDescriptor, expressionCodegen, expressionCodegen.state.typeMapper
+                ),
+                cv,
+                originalSuspendDescriptor
             )
         }
     }
@@ -538,11 +579,11 @@ private object FailingFunctionGenerationStrategy : FunctionGenerationStrategy()
     }
 
     override fun generateBody(
-            mv: MethodVisitor,
-            frameMap: FrameMap,
-            signature: JvmMethodSignature,
-            context: MethodContext,
-            parentCodegen: MemberCodegen<*>
+        mv: MethodVisitor,
+        frameMap: FrameMap,
+        signature: JvmMethodSignature,
+        context: MethodContext,
+        parentCodegen: MemberCodegen<*>
     ) {
         error("This functions must not be called")
     }

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

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.codegen.optimization.fixStack.FixStackMethodTransfor
 import org.jetbrains.kotlin.codegen.optimization.fixStack.top
 import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
 import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.config.isReleaseCoroutines
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.utils.sure
@@ -53,7 +54,7 @@ class CoroutineTransformerMethodVisitor(
 
     private var continuationIndex = if (isForNamedFunction) -1 else 0
     private var dataIndex = if (isForNamedFunction) -1 else 1
-    private var exceptionIndex = if (isForNamedFunction) -1 else 2
+    private var exceptionIndex = if (isForNamedFunction || languageVersionSettings.isReleaseCoroutines()) -1 else 2
 
     override fun performTransformations(methodNode: MethodNode) {
         removeFakeContinuationConstructorCall(methodNode)
@@ -81,7 +82,9 @@ class CoroutineTransformerMethodVisitor(
             }
 
             dataIndex = methodNode.maxLocals++
-            exceptionIndex = methodNode.maxLocals++
+            if (!languageVersionSettings.isReleaseCoroutines()) {
+                exceptionIndex = methodNode.maxLocals++
+            }
             continuationIndex = methodNode.maxLocals++
 
             prepareMethodNodePreludeForNamedFunction(methodNode)
@@ -136,7 +139,9 @@ class CoroutineTransformerMethodVisitor(
                 )
             )
 
-            insert(startLabel, withInstructionAdapter { generateResumeWithExceptionCheck(exceptionIndex) })
+            insert(startLabel, withInstructionAdapter {
+                generateResumeWithExceptionCheck(languageVersionSettings.isReleaseCoroutines(), dataIndex, exceptionIndex)
+            })
             insert(last, defaultLabel)
 
             insert(last, withInstructionAdapter {
@@ -161,7 +166,7 @@ class CoroutineTransformerMethodVisitor(
     }
 
     private fun createInsnForReadingLabel() =
-        if (isForNamedFunction)
+        if (isForNamedFunction && !languageVersionSettings.isReleaseCoroutines())
             MethodInsnNode(
                 Opcodes.INVOKEVIRTUAL,
                 classBuilderForCoroutineState.thisName,
@@ -172,12 +177,12 @@ class CoroutineTransformerMethodVisitor(
         else
             FieldInsnNode(
                 Opcodes.GETFIELD,
-                languageVersionSettings.coroutineImplAsmType().internalName,
+                computeLabelOwner(languageVersionSettings, classBuilderForCoroutineState.thisName).internalName,
                 COROUTINE_LABEL_FIELD_NAME, Type.INT_TYPE.descriptor
             )
 
     private fun createInsnForSettingLabel() =
-        if (isForNamedFunction)
+        if (isForNamedFunction && !languageVersionSettings.isReleaseCoroutines())
             MethodInsnNode(
                 Opcodes.INVOKEVIRTUAL,
                 classBuilderForCoroutineState.thisName,
@@ -188,7 +193,7 @@ class CoroutineTransformerMethodVisitor(
         else
             FieldInsnNode(
                 Opcodes.PUTFIELD,
-                languageVersionSettings.coroutineImplAsmType().internalName,
+                computeLabelOwner(languageVersionSettings, classBuilderForCoroutineState.thisName).internalName,
                 COROUTINE_LABEL_FIELD_NAME, Type.INT_TYPE.descriptor
             )
 
@@ -294,9 +299,11 @@ class CoroutineTransformerMethodVisitor(
             getfield(classBuilderForCoroutineState.thisName, DATA_FIELD_NAME, AsmTypes.OBJECT_TYPE.descriptor)
             visitVarInsn(Opcodes.ASTORE, dataIndex)
 
-            visitVarInsn(Opcodes.ALOAD, continuationIndex)
-            getfield(classBuilderForCoroutineState.thisName, EXCEPTION_FIELD_NAME, AsmTypes.JAVA_THROWABLE_TYPE.descriptor)
-            visitVarInsn(Opcodes.ASTORE, exceptionIndex)
+            if (!languageVersionSettings.isReleaseCoroutines()) {
+                visitVarInsn(Opcodes.ALOAD, continuationIndex)
+                getfield(classBuilderForCoroutineState.thisName, EXCEPTION_FIELD_NAME, AsmTypes.JAVA_THROWABLE_TYPE.descriptor)
+                visitVarInsn(Opcodes.ASTORE, exceptionIndex)
+            }
         })
     }
 
@@ -517,7 +524,7 @@ class CoroutineTransformerMethodVisitor(
             remove(possibleTryCatchBlockStart.previous)
 
             insert(possibleTryCatchBlockStart, withInstructionAdapter {
-                generateResumeWithExceptionCheck(exceptionIndex)
+                generateResumeWithExceptionCheck(languageVersionSettings.isReleaseCoroutines(), dataIndex, exceptionIndex)
 
                 // Load continuation argument just like suspending function returns it
                 load(dataIndex, AsmTypes.OBJECT_TYPE)
@@ -628,12 +635,21 @@ internal fun InstructionAdapter.generateContinuationConstructorCall(
     )
 }
 
-private fun InstructionAdapter.generateResumeWithExceptionCheck(exceptionIndex: Int) {
+private fun InstructionAdapter.generateResumeWithExceptionCheck(isReleaseCoroutines: Boolean, dataIndex: Int, exceptionIndex: Int) {
     // Check if resumeWithException has been called
-    load(exceptionIndex, AsmTypes.OBJECT_TYPE)
+    load(if (isReleaseCoroutines) dataIndex else exceptionIndex, AsmTypes.OBJECT_TYPE)
     dup()
     val noExceptionLabel = Label()
-    ifnull(noExceptionLabel)
+
+    if (isReleaseCoroutines) {
+        instanceOf(AsmTypes.SUCCESS_OR_FAILURE_FAILURE)
+        ifeq(noExceptionLabel)
+        // TODO: do we need this checkcast?
+        checkcast(AsmTypes.SUCCESS_OR_FAILURE_FAILURE)
+        getfield(AsmTypes.SUCCESS_OR_FAILURE_FAILURE.internalName, "exception", AsmTypes.JAVA_THROWABLE_TYPE.descriptor)
+    } else {
+        ifnull(noExceptionLabel)
+    }
     athrow()
 
     mark(noExceptionLabel)
@@ -823,4 +839,4 @@ private fun replaceFakeContinuationsWithRealOnes(methodNode: MethodNode, continu
         methodNode.instructions.removeAll(listOf(fakeContinuation.previous.previous, fakeContinuation.previous))
         methodNode.instructions.set(fakeContinuation, VarInsnNode(Opcodes.ALOAD, continuationIndex))
     }
-}
+}

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

@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
+import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtPsiFactory
@@ -37,7 +38,9 @@ import org.jetbrains.kotlin.resolve.calls.tasks.TracingStrategy
 import org.jetbrains.kotlin.resolve.calls.tower.NewResolvedCallImpl
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.descriptorUtil.module
+import org.jetbrains.kotlin.resolve.descriptorUtil.resolveTopLevelClass
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
+import org.jetbrains.kotlin.types.ErrorUtils
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.KotlinTypeFactory
 import org.jetbrains.kotlin.types.TypeConstructorSubstitution
@@ -53,9 +56,18 @@ import org.jetbrains.org.objectweb.asm.tree.MethodNode
 const val COROUTINE_LABEL_FIELD_NAME = "label"
 const val SUSPEND_FUNCTION_CREATE_METHOD_NAME = "create"
 const val DO_RESUME_METHOD_NAME = "doResume"
+const val INVOKE_SUSPEND_METHOD_NAME = "invokeSuspend"
 const val DATA_FIELD_NAME = "data"
 const val EXCEPTION_FIELD_NAME = "exception"
 
+fun LanguageVersionSettings.isResumeImplMethodName(name: String) =
+    if (isReleaseCoroutines())
+        name == INVOKE_SUSPEND_METHOD_NAME
+    else
+        name == DO_RESUME_METHOD_NAME
+
+fun isResumeImplMethodNameFromAnyLanguageSettings(name: String) = name == INVOKE_SUSPEND_METHOD_NAME || name == DO_RESUME_METHOD_NAME
+
 fun LanguageVersionSettings.coroutinesJvmInternalPackageFqName() =
     coroutinesPackageFqName().child(Name.identifier("jvm")).child(Name.identifier("internal"))
 
@@ -70,8 +82,19 @@ fun continuationAsmTypes() = listOf(
 fun LanguageVersionSettings.coroutineContextAsmType() =
     coroutinesPackageFqName().child(Name.identifier("CoroutineContext")).topLevelClassAsmType()
 
-fun LanguageVersionSettings.coroutineImplAsmType() =
-    coroutinesJvmInternalPackageFqName().child(Name.identifier("CoroutineImpl")).topLevelClassAsmType()
+fun LanguageVersionSettings.isCoroutineImpl(internalName: String): Boolean {
+    val coroutinesJvmInternalPackage = coroutinesJvmInternalPackageFqName()
+
+    return if (isReleaseCoroutines())
+        coroutinesJvmInternalPackage.identifiedChild("ContinuationImpl") == internalName ||
+                coroutinesJvmInternalPackage.identifiedChild("RestrictedContinuationImpl") == internalName ||
+                coroutinesJvmInternalPackage.identifiedChild("SuspendLambda") == internalName ||
+                coroutinesJvmInternalPackage.identifiedChild("RestrictedSuspendLambda") == internalName
+    else
+        coroutinesJvmInternalPackage.identifiedChild("CoroutineImpl") == internalName
+}
+
+private fun FqName.identifiedChild(name: String) = child(Name.identifier(name)).topLevelClassInternalName()
 
 private fun LanguageVersionSettings.coroutinesIntrinsicsFileFacadeInternalName() =
     coroutinesIntrinsicsPackageFqName().child(Name.identifier("IntrinsicsKt")).topLevelClassAsmType()
@@ -79,6 +102,12 @@ private fun LanguageVersionSettings.coroutinesIntrinsicsFileFacadeInternalName()
 private fun LanguageVersionSettings.internalCoroutineIntrinsicsOwnerInternalName() =
     coroutinesJvmInternalPackageFqName().child(Name.identifier("CoroutineIntrinsics")).topLevelClassInternalName()
 
+fun computeLabelOwner(languageVersionSettings: LanguageVersionSettings, thisName: String): Type =
+    if (languageVersionSettings.isReleaseCoroutines())
+        Type.getObjectType(thisName)
+    else
+        languageVersionSettings.coroutinesJvmInternalPackageFqName().child(Name.identifier("CoroutineImpl")).topLevelClassAsmType()
+
 private val NORMALIZE_CONTINUATION_METHOD_NAME = "normalizeContinuation"
 private val GET_CONTEXT_METHOD_NAME = "getContext"
 
@@ -282,6 +311,17 @@ fun ModuleDescriptor.getContinuationOfTypeOrAny(kotlinType: KotlinType, isReleas
         )
     } ?: module.builtIns.nullableAnyType
 
+fun ModuleDescriptor.getSuccessOrFailure(kotlinType: KotlinType) =
+    module.resolveTopLevelClass(
+        DescriptorUtils.SUCCESS_OR_FAILURE_FQ_NAME,
+        NoLookupLocation.FROM_BACKEND
+    )?.defaultType?.let {
+        KotlinTypeFactory.simpleType(
+            it,
+            arguments = listOf(kotlinType.asTypeProjection())
+        )
+    } ?: ErrorUtils.createErrorType("For SuccessOrFailure")
+
 fun FunctionDescriptor.isBuiltInSuspendCoroutineOrReturnInJvm(languageVersionSettings: LanguageVersionSettings) =
     getUserData(INITIAL_DESCRIPTOR_FOR_SUSPEND_FUNCTION)?.isBuiltInSuspendCoroutineOrReturn(languageVersionSettings) == true
 
@@ -468,6 +508,17 @@ fun InstructionAdapter.invokeDoResumeWithUnit(thisName: String) {
     )
 }
 
+fun InstructionAdapter.invokeInvokeSuspendWithUnit(thisName: String) {
+    StackValue.putUnitInstance(this)
+
+    invokevirtual(
+        thisName,
+        INVOKE_SUSPEND_METHOD_NAME,
+        Type.getMethodDescriptor(AsmTypes.OBJECT_TYPE, AsmTypes.OBJECT_TYPE),
+        false
+    )
+}
+
 fun Method.getImplForOpenMethod(ownerInternalName: String) =
     Method("$name\$suspendImpl", returnType, arrayOf(Type.getObjectType(ownerInternalName)) + argumentTypes)
 

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

@@ -10,17 +10,18 @@ import org.jetbrains.kotlin.codegen.AsmUtil
 import org.jetbrains.kotlin.codegen.ClassBuilder
 import org.jetbrains.kotlin.codegen.StackValue
 import org.jetbrains.kotlin.codegen.coroutines.CoroutineTransformerMethodVisitor
+import org.jetbrains.kotlin.codegen.coroutines.isCoroutineImpl
+import org.jetbrains.kotlin.codegen.coroutines.isResumeImplMethodName
 import org.jetbrains.kotlin.codegen.optimization.common.asSequence
 import org.jetbrains.kotlin.codegen.serialization.JvmCodegenStringTable
-import org.jetbrains.kotlin.codegen.coroutines.coroutineImplAsmType
 import org.jetbrains.kotlin.codegen.writeKotlinMetadata
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.load.kotlin.FileBasedKotlinClass
+import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
+import org.jetbrains.kotlin.load.kotlin.header.ReadKotlinClassHeaderAnnotationVisitor
 import org.jetbrains.kotlin.metadata.jvm.JvmProtoBuf
 import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmProtoBufUtil
 import org.jetbrains.kotlin.metadata.jvm.serialization.JvmStringTable
-import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
-import org.jetbrains.kotlin.load.kotlin.header.ReadKotlinClassHeaderAnnotationVisitor
 import org.jetbrains.kotlin.protobuf.MessageLite
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin.Companion.NO_ORIGIN
@@ -55,7 +56,7 @@ class AnonymousObjectTransformer(
         createClassReader().accept(object : ClassVisitor(API, classBuilder.visitor) {
             override fun visit(version: Int, access: Int, name: String, signature: String?, superName: String, interfaces: Array<String>) {
                 classBuilder.defineClass(null, version, access, name, signature, superName, interfaces)
-                if (languageVersionSettings.coroutineImplAsmType().internalName == superName) {
+                if (languageVersionSettings.isCoroutineImpl(superName)) {
                     inliningContext.isContinuation = true
                 }
             }
@@ -152,7 +153,7 @@ class AnonymousObjectTransformer(
             // 2) Suspend named function
             // Iff it captures crossinline suspend lambda
             val generateStateMachineForLambda =
-                next.name == "doResume" && capturesCrossinlineSuspend && inliningContext.isContinuation &&
+                languageVersionSettings.isResumeImplMethodName(next.name) && capturesCrossinlineSuspend && inliningContext.isContinuation &&
                         !isLambdaAlreadyGeneratedAndNotGoingToBeInlined && hasLambdasToInline
             val continuationClassName = findFakeContinuationConstructorClassName(next)
             val generateStateMachineForNamedFunction =

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/AsmTypes.java

@@ -47,6 +47,7 @@ public class AsmTypes {
     public static final Type MUTABLE_PROPERTY_REFERENCE1 = Type.getObjectType("kotlin/jvm/internal/MutablePropertyReference1");
     public static final Type MUTABLE_PROPERTY_REFERENCE2 = Type.getObjectType("kotlin/jvm/internal/MutablePropertyReference2");
 
+    public static final Type SUCCESS_OR_FAILURE_FAILURE = Type.getObjectType("kotlin/Failure");
 
     public static final Type[] PROPERTY_REFERENCE_IMPL = {
             Type.getObjectType("kotlin/jvm/internal/PropertyReference0Impl"),

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/coroutineCallChecker.kt

@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.resolve.scopes.LexicalScopeKind
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.resolve.scopes.utils.parentsWithSelf
+import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.typeUtil.supertypes
 import org.jetbrains.kotlin.utils.addToStdlib.cast
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
@@ -126,15 +127,17 @@ fun checkCoroutinesFeature(languageVersionSettings: LanguageVersionSettings, dia
     }
 }
 
+fun KotlinType.isRestrictsSuspensionReceiver(languageVersionSettings: LanguageVersionSettings) = (listOf(this) + this.supertypes()).any {
+    it.constructor.declarationDescriptor?.annotations?.hasAnnotation(languageVersionSettings.restrictsSuspensionFqName()) == true
+}
+
 private fun checkRestrictsSuspension(
     enclosingSuspendCallableDescriptor: CallableDescriptor,
     resolvedCall: ResolvedCall<*>,
     reportOn: PsiElement,
     context: CallCheckerContext
 ) {
-    fun ReceiverValue.isRestrictsSuspensionReceiver() = (listOf(type) + type.supertypes()).any {
-        it.constructor.declarationDescriptor?.annotations?.hasAnnotation(context.languageVersionSettings.restrictsSuspensionFqName()) == true
-    }
+    fun ReceiverValue.isRestrictsSuspensionReceiver() = type.isRestrictsSuspensionReceiver(context.languageVersionSettings)
 
     infix fun ReceiverValue.sameInstance(other: ReceiverValue?): Boolean {
         if (other == null) return false

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

@@ -27,7 +27,7 @@ fun <T> asyncGenerate(block: suspend AsyncGenerator<T>.() -> Unit): AsyncSequenc
     }
 }
 
-class AsyncGeneratorIterator<T>: AsyncIterator<T>, AsyncGenerator<T>, Continuation<Unit> {
+class AsyncGeneratorIterator<T>: AsyncIterator<T>, AsyncGenerator<T>, ContinuationAdapter<Unit>() {
     var computedNext = false
     var nextValue: T? = null
     var nextStep: Continuation<Unit>? = null

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

@@ -27,7 +27,7 @@ fun <T> asyncGenerate(block: suspend AsyncGenerator<T>.() -> Unit): AsyncSequenc
     }
 }
 
-class AsyncGeneratorIterator<T>: AsyncIterator<T>, AsyncGenerator<T>, Continuation<Unit> {
+class AsyncGeneratorIterator<T>: AsyncIterator<T>, AsyncGenerator<T>, ContinuationAdapter<Unit>() {
     var computedNext = false
     var nextValue: T? = null
     var nextStep: Continuation<Unit>? = null

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

@@ -27,7 +27,7 @@ fun <T> asyncGenerate(block: suspend AsyncGenerator<T>.() -> Unit): AsyncSequenc
     }
 }
 
-class AsyncGeneratorIterator<T>: AsyncIterator<T>, AsyncGenerator<T>, Continuation<Unit> {
+class AsyncGeneratorIterator<T>: AsyncIterator<T>, AsyncGenerator<T>, ContinuationAdapter<Unit>() {
     var computedNext = false
     var nextValue: T? = null
     var nextStep: Continuation<Unit>? = null

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

@@ -11,7 +11,7 @@ suspend fun suspendHere(): Any = suspendCoroutineOrReturn { x -> }
 fun builder(c: suspend () -> Unit) {
     var exception: Throwable? = null
 
-    c.createCoroutine(object : Continuation<Unit> {
+    c.createCoroutine(object : ContinuationAdapter<Unit>() {
         override val context = EmptyCoroutineContext
 
         override fun resume(data: Unit) {

compiler/testData/codegen/box/coroutines/controlFlow/throwFromCatch.kt

@@ -26,7 +26,7 @@ class Controller {
 
 fun builder(c: suspend Controller.() -> Unit): String {
     val controller = Controller()
-    c.startCoroutine(controller, object : Continuation<Unit> {
+    c.startCoroutine(controller, object : ContinuationAdapter<Unit>() {
         override val context = EmptyCoroutineContext
 
         override fun resume(data: Unit) {

compiler/testData/codegen/box/coroutines/controlFlow/throwInTryWithHandleResult.kt

@@ -19,7 +19,7 @@ class Controller {
 
 fun builder(c: suspend Controller.() -> Unit): String {
     val controller = Controller()
-    c.startCoroutine(controller, object : Continuation<Unit> {
+    c.startCoroutine(controller, object : ContinuationAdapter<Unit>() {
         override val context = EmptyCoroutineContext
 
         override fun resume(data: Unit) {}

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

@@ -1,12 +1,11 @@
+// LANGUAGE_VERSION: 1.3
 // IGNORE_BACKEND: JS_IR
 // TARGET_BACKEND: JVM
 // WITH_REFLECT
 // WITH_COROUTINES
-// COMMON_COROUTINES_TEST
-
 import helpers.*
-import COROUTINES_PACKAGE.*
-import COROUTINES_PACKAGE.intrinsics.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
 
 class A<T : String> {
     suspend fun foo() {}
@@ -31,5 +30,5 @@ fun box(): String {
         result = A<String>().bar()
     }
 
-    return if (result == "(COROUTINES_PACKAGE.Continuation<T>) -> kotlin.Any?") "OK" else "Fail: $result"
+    return if (result == "Continuation @ A\$bar\$1") "OK" else "Fail: $result"
 }

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

@@ -0,0 +1,33 @@
+// IGNORE_BACKEND: JS_IR
+// TARGET_BACKEND: JVM
+// WITH_REFLECT
+// WITH_COROUTINES
+import helpers.*
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
+
+class A<T : String> {
+    suspend fun foo() {}
+
+    suspend fun bar(): T {
+        foo()
+        return suspendCoroutineOrReturn { x ->
+            x.resume(x.toString() as T)
+            COROUTINE_SUSPENDED
+        }
+    }
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+fun box(): String {
+    var result = ""
+
+    builder {
+        result = A<String>().bar()
+    }
+
+    return if (result == "(kotlin.coroutines.experimental.Continuation<T>) -> kotlin.Any?") "OK" else "Fail: $result"
+}

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

@@ -1,14 +1,14 @@
+// LANGUAGE_VERSION: 1.3
 // IGNORE_BACKEND: JS_IR
 // WITH_RUNTIME
-// IGNORE_BACKEND: JS
-// COMMON_COROUTINES_TEST
-import COROUTINES_PACKAGE.*
-import COROUTINES_PACKAGE.intrinsics.COROUTINE_SUSPENDED
+// WITH_COROUTINES
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.COROUTINE_SUSPENDED
 
 fun runCustomLambdaAsCoroutine(e: Throwable? = null, x: (Continuation<String>) -> Any?): String {
     var result = "fail"
     var wasIntercepted = false
-    val c = (x as suspend () -> String).createCoroutine(object: Continuation<String> {
+    val c = (x as suspend () -> String).createCoroutine(object: helpers.ContinuationAdapter<String>() {
         override fun resumeWithException(exception: Throwable) {
             throw exception
         }
@@ -26,7 +26,7 @@ fun runCustomLambdaAsCoroutine(e: Throwable? = null, x: (Continuation<String>) -
                     return null
                 }
 
-                override fun <T> interceptContinuation(continuation: Continuation<T>) = object : Continuation<T> {
+                override fun <T> interceptContinuation(continuation: Continuation<T>) = object : helpers.ContinuationAdapter<T>() {
                     override val context: CoroutineContext
                         get() = continuation.context
 

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

@@ -0,0 +1,95 @@
+// IGNORE_BACKEND: JS_IR
+// WITH_RUNTIME
+// WITH_COROUTINES
+// IGNORE_BACKEND: JS
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.COROUTINE_SUSPENDED
+
+fun runCustomLambdaAsCoroutine(e: Throwable? = null, x: (Continuation<String>) -> Any?): String {
+    var result = "fail"
+    var wasIntercepted = false
+    val c = (x as suspend () -> String).createCoroutine(object: helpers.ContinuationAdapter<String>() {
+        override fun resumeWithException(exception: Throwable) {
+            throw exception
+        }
+
+        override val context: CoroutineContext
+            get() = object: ContinuationInterceptor {
+                override fun <R> fold(initial: R, operation: (R, CoroutineContext.Element) -> R): R {
+                    throw IllegalStateException()
+                }
+
+                override fun <E : CoroutineContext.Element> get(key: CoroutineContext.Key<E>): E? {
+                    if (key == ContinuationInterceptor.Key) {
+                        return this as E
+                    }
+                    return null
+                }
+
+                override fun <T> interceptContinuation(continuation: Continuation<T>) = object : helpers.ContinuationAdapter<T>() {
+                    override val context: CoroutineContext
+                        get() = continuation.context
+
+                    override fun resume(value: T) {
+                        wasIntercepted = true
+                        continuation.resume(value)
+                    }
+
+                    override fun resumeWithException(exception: Throwable) {
+                        wasIntercepted = true
+                        continuation.resumeWithException(exception)
+                    }
+                }
+
+                override fun minusKey(key: CoroutineContext.Key<*>): CoroutineContext {
+                    throw IllegalStateException()
+                }
+
+                override fun plus(context: CoroutineContext): CoroutineContext {
+                    throw IllegalStateException()
+                }
+
+                override val key: CoroutineContext.Key<*>
+                    get() = ContinuationInterceptor.Key
+            }
+
+        override fun resume(value: String) {
+            result = value
+        }
+    })
+
+    if (e != null)
+        c.resumeWithException(e)
+    else
+        c.resume(Unit)
+
+    if (!wasIntercepted) return "was not intercepted"
+
+    return result
+}
+
+fun box(): String {
+    val x = runCustomLambdaAsCoroutine {
+        it.resume("OK")
+        COROUTINE_SUSPENDED
+    }
+
+    if (x != "OK") return "fail 1: $x"
+
+    val y = runCustomLambdaAsCoroutine {
+        "OK"
+    }
+
+    if (y != "OK") return "fail 2: $x"
+
+
+    try {
+        runCustomLambdaAsCoroutine(RuntimeException("OK")) {
+            throw RuntimeException("fail 3")
+        }
+    } catch(e: Exception) {
+        return e.message!!
+    }
+
+    return "fail 3"
+}

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

@@ -22,7 +22,7 @@ fun builder(c: suspend () -> Unit) {
 
 fun builderConsumer(c: suspend () -> Consumer): Consumer {
     var res: Consumer? = null
-    c.startCoroutine(object : Continuation<Consumer> {
+    c.startCoroutine(object : ContinuationAdapter<Consumer>() {
         override fun resume(value: Consumer) {
             res = value
         }

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

@@ -32,7 +32,7 @@ abstract class ContinuationDispatcher : AbstractCoroutineContextElement(Continua
 private class DispatchedContinuation<T>(
         val dispatcher: ContinuationDispatcher,
         val continuation: Continuation<T>
-): Continuation<T> {
+): ContinuationAdapter<T>() {
     override val context: CoroutineContext = continuation.context
 
     override fun resume(value: T) {

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

@@ -41,7 +41,7 @@ class GeneratedSequence<out T>(private val block: suspend Generator<T>.() -> Uni
 }
 
 class GeneratedIterator<T>(block: suspend Generator<T>.() -> Unit) : AbstractIterator<T>(), Generator<T> {
-    private var nextStep: Continuation<Unit> = block.createCoroutine(this, object : Continuation<Unit> {
+    private var nextStep: Continuation<Unit> = block.createCoroutine(this, object : ContinuationAdapter<Unit>() {
         override val context = EmptyCoroutineContext
 
         override fun resume(data: Unit) {

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

@@ -1,11 +1,11 @@
+// LANGUAGE_VERSION: 1.3
 // IGNORE_BACKEND: JS_IR
 // WITH_RUNTIME
 // WITH_COROUTINES
-// COMMON_COROUTINES_TEST
-import helpers.*
 // TARGET_BACKEND: JVM
-import COROUTINES_PACKAGE.*
-import COROUTINES_PACKAGE.intrinsics.*
+import helpers.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
 
 suspend fun suspendHere(): Unit = suspendCoroutineOrReturn { x ->
     x.resume(Unit)
@@ -23,7 +23,7 @@ fun builder2(c: suspend () -> Unit) {
     delegateField.setAccessible(true)
     val originalContinuation = delegateField.get(continuation)
 
-    val declaredField = originalContinuation.javaClass.superclass.getDeclaredField("label")
+    val declaredField = originalContinuation.javaClass.getDeclaredField("label")
     declaredField.setAccessible(true)
     declaredField.set(originalContinuation, -3)
     continuation.resume(Unit)

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

@@ -0,0 +1,71 @@
+// IGNORE_BACKEND: JS_IR
+// WITH_RUNTIME
+// WITH_COROUTINES
+import helpers.*
+// TARGET_BACKEND: JVM
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
+
+suspend fun suspendHere(): Unit = suspendCoroutineOrReturn { x ->
+    x.resume(Unit)
+    COROUTINE_SUSPENDED
+}
+
+fun builder1(c: suspend () -> Unit) {
+    (c as Continuation<Unit>).resume(Unit)
+}
+
+fun builder2(c: suspend () -> Unit) {
+    val continuation = c.createCoroutine(EmptyContinuation)
+
+    val delegateField = continuation.javaClass.getDeclaredField("delegate")
+    delegateField.setAccessible(true)
+    val originalContinuation = delegateField.get(continuation)
+
+    val declaredField = originalContinuation.javaClass.superclass.getDeclaredField("label")
+    declaredField.setAccessible(true)
+    declaredField.set(originalContinuation, -3)
+    continuation.resume(Unit)
+}
+
+fun box(): String {
+
+    try {
+        builder1 {
+            suspendHere()
+        }
+        return "fail 1"
+    } catch (e: kotlin.KotlinNullPointerException) {
+    }
+
+    try {
+        builder2 {
+            suspendHere()
+        }
+        return "fail 3"
+    } catch (e: java.lang.IllegalStateException) {
+        if (e.message != "call to 'resume' before 'invoke' with coroutine") return "fail 4: ${e.message!!}"
+    }
+
+    var result = "OK"
+
+    try {
+        builder1 {
+            result = "fail 5"
+        }
+        return "fail 6"
+    } catch (e: kotlin.KotlinNullPointerException) {
+    }
+
+    try {
+        builder2 {
+            result = "fail 8"
+        }
+        return "fail 9"
+    } catch (e: java.lang.IllegalStateException) {
+        if (e.message != "call to 'resume' before 'invoke' with coroutine") return "fail 10: ${e.message!!}"
+        return result
+    }
+
+    return "fail"
+}

compiler/testData/codegen/box/coroutines/intrinsicSemantics/coroutineContext.kt

@@ -21,7 +21,7 @@ suspend fun multipleArgs(a: Any, b: Any, c: Any) =
 fun builder(c: suspend () -> String): String {
     var fromSuspension: String? = null
 
-    val continuation = object : Continuation<String> {
+    val continuation = object : ContinuationAdapter<String>() {
         override val context: CoroutineContext
             get() = EmptyCoroutineContext
 

compiler/testData/codegen/box/coroutines/intrinsicSemantics/coroutineContextReceiver.kt

@@ -22,7 +22,7 @@ class Controller {
     fun builder(c: suspend Controller.() -> String): String {
         var fromSuspension: String? = null
 
-        c.startCoroutine(this, object : Continuation<String> {
+        c.startCoroutine(this, object : ContinuationAdapter<String>() {
             override val context: CoroutineContext
                 get() = EmptyCoroutineContext
 
@@ -60,4 +60,4 @@ fun box(): String {
     }
 
     return "OK"
-}
+}

compiler/testData/codegen/box/coroutines/intrinsicSemantics/coroutineContextReceiverNotIntrinsic.kt

@@ -26,7 +26,7 @@ class Controller {
     fun builder(c: suspend Controller.() -> String): String {
         var fromSuspension: String? = null
 
-        c.startCoroutine(this, object : Continuation<String> {
+        c.startCoroutine(this, object : ContinuationAdapter<String>() {
             override val context: CoroutineContext
                 get() = EmptyCoroutineContext
 
@@ -59,4 +59,4 @@ fun box(): String {
     }
 
     return "OK"
-}
+}

compiler/testData/codegen/box/coroutines/intrinsicSemantics/intercepted.kt

@@ -32,7 +32,7 @@ fun builder(expectedCount: Int, c: suspend () -> String): String {
     var counter = 0
 
     val result = try {
-        c.startCoroutineUninterceptedOrReturn(object: Continuation<String> {
+        c.startCoroutineUninterceptedOrReturn(object: ContinuationAdapter<String>() {
             override val context: CoroutineContext
                 get() =  ContinuationDispatcher { counter++ }
 
@@ -59,7 +59,7 @@ class ContinuationDispatcher(val dispatcher: () -> Unit) : AbstractCoroutineCont
 private class DispatchedContinuation<T>(
         val dispatcher: () -> Unit,
         val continuation: Continuation<T>
-): Continuation<T> {
+): ContinuationAdapter<T>() {
     override val context: CoroutineContext = continuation.context
 
     override fun resume(value: T) {

compiler/testData/codegen/box/coroutines/intrinsicSemantics/startCoroutine.kt

@@ -20,7 +20,7 @@ suspend fun suspendWithException(): String = suspendCoroutineOrReturn { x ->
 fun builder(c: suspend () -> String): String {
     var fromSuspension: String? = null
 
-    c.startCoroutine(object: Continuation<String> {
+    c.startCoroutine(object: ContinuationAdapter<String>() {
         override val context: CoroutineContext
             get() =  EmptyCoroutineContext
 

compiler/testData/codegen/box/coroutines/intrinsicSemantics/startCoroutineUninterceptedOrReturn.kt

@@ -21,7 +21,7 @@ fun builder(shouldSuspend: Boolean, c: suspend () -> String): String {
     var fromSuspension: String? = null
 
     val result = try {
-        c.startCoroutineUninterceptedOrReturn(object: Continuation<String> {
+        c.startCoroutineUninterceptedOrReturn(object: ContinuationAdapter<String>() {
             override val context: CoroutineContext
                 get() =  EmptyCoroutineContext
 

compiler/testData/codegen/box/coroutines/intrinsicSemantics/startCoroutineUninterceptedOrReturnInterception.kt

@@ -22,7 +22,7 @@ fun builder(shouldSuspend: Boolean, expectedCount: Int, c: suspend () -> String)
     var counter = 0
 
     val result = try {
-        c.startCoroutineUninterceptedOrReturn(object: Continuation<String> {
+        c.startCoroutineUninterceptedOrReturn(object: ContinuationAdapter<String>() {
             override val context: CoroutineContext
                 get() =  ContinuationDispatcher { counter++ }
 
@@ -57,7 +57,7 @@ class ContinuationDispatcher(val dispatcher: () -> Unit) : AbstractCoroutineCont
 private class DispatchedContinuation<T>(
         val dispatcher: () -> Unit,
         val continuation: Continuation<T>
-): Continuation<T> {
+): ContinuationAdapter<T>() {
     override val context: CoroutineContext = continuation.context
 
     override fun resume(value: T) {

compiler/testData/codegen/box/coroutines/intrinsicSemantics/suspendCoroutineUninterceptedOrReturn.kt

@@ -22,7 +22,7 @@ fun builder(shouldSuspend: Boolean, c: suspend () -> String): String {
     var counter = 0
 
     val result = try {
-        c.startCoroutineUninterceptedOrReturn(object: Continuation<String> {
+        c.startCoroutineUninterceptedOrReturn(object: ContinuationAdapter<String>() {
             override val context: CoroutineContext
                 get() =  ContinuationDispatcher { counter++ }
 
@@ -57,7 +57,7 @@ class ContinuationDispatcher(val dispatcher: () -> Unit) : AbstractCoroutineCont
 private class DispatchedContinuation<T>(
         val dispatcher: () -> Unit,
         val continuation: Continuation<T>
-): Continuation<T> {
+): ContinuationAdapter<T>() {
     override val context: CoroutineContext = continuation.context
 
     override fun resume(value: T) {

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

@@ -6,7 +6,7 @@ import helpers.*
 
 import COROUTINES_PACKAGE.intrinsics.COROUTINE_SUSPENDED
 import COROUTINES_PACKAGE.intrinsics.suspendCoroutineOrReturn
-import COROUTINES_PACKAGE.startCoroutine
+import COROUTINES_PACKAGE.*
 
 class Bar(val x: Any)
 inline fun Any.map(transform: (Any) -> Any) {

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

@@ -31,7 +31,7 @@ suspend fun callLocal() {
 }
 
 fun builder(c: suspend () -> Unit) {
-    val continuation = object: Continuation<Unit> {
+    val continuation = object: ContinuationAdapter<Unit>() {
         override val context: CoroutineContext
             get() = EmptyCoroutineContext
 

compiler/testData/codegen/box/coroutines/multiModule/inlineFunctionWithOptionalParam.kt

@@ -17,13 +17,7 @@ import COROUTINES_PACKAGE.intrinsics.*
 var result = ""
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object : Continuation<Unit> {
-        override val context = EmptyCoroutineContext
-        override fun resume(value: Unit) {
-        }
-        override fun resumeWithException(exception: Throwable) {
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 fun box(): String {

compiler/testData/codegen/box/coroutines/multiModule/inlineWithJava.kt

@@ -1,6 +1,6 @@
+// LANGUAGE_VERSION: 1.3
 // IGNORE_BACKEND: NATIVE, JS, JS_IR
 // WITH_COROUTINES
-// COMMON_COROUTINES_TEST
 // MODULE: lib
 // FILE: lib.kt
 interface I {}
@@ -9,7 +9,7 @@ suspend inline fun foo() = object : I {}
 
 // MODULE: useLib(lib)
 // FILE: UseLib.java
-import COROUTINES_PACKAGE.*;
+import kotlin.coroutines.*;
 import kotlin.Unit;
 
 public class UseLib {
@@ -23,10 +23,7 @@ class MyContinuation implements Continuation<I> {
     public CoroutineContext getContext() {
         return EmptyCoroutineContext.INSTANCE;
     }
-    public void resume(I value) {}
-    public void resumeWithException(Throwable e) {
-        throw new RuntimeException(e);
-    }
+    public void resumeWith(Object value) {}
 }
 
 // MODULE: main(useLib)

compiler/testData/codegen/box/coroutines/multiModule/inlineWithJava_1_2.kt

@@ -0,0 +1,42 @@
+// IGNORE_BACKEND: NATIVE, JS, JS_IR
+// WITH_COROUTINES
+// WITH_RUNTIME
+// MODULE: lib
+// FILE: lib.kt
+interface I {}
+
+suspend inline fun foo() = object : I {}
+
+// MODULE: useLib(lib)
+// FILE: UseLib.java
+import kotlin.coroutines.experimental.*;
+import kotlin.Unit;
+
+public class UseLib {
+    public static String useFoo() {
+        Object i = LibKt.foo(new MyContinuation());
+        return i.getClass().getName() + " " + i.getClass().getEnclosingClass().getName() + " " + i.getClass().getEnclosingClass().getEnclosingClass();
+    }
+}
+
+class MyContinuation implements Continuation<I> {
+    public CoroutineContext getContext() {
+        return EmptyCoroutineContext.INSTANCE;
+    }
+    public void resume(I value) {}
+    public void resumeWithException(Throwable e) {
+        throw new RuntimeException(e);
+    }
+}
+
+// MODULE: main(useLib)
+// FILE: main.kt
+
+fun box(): String {
+    val res = UseLib.useFoo()
+    if (res == "LibKt\$foo\$2 LibKt null") {
+        return "OK"
+    } else {
+        return res
+    }
+}

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

@@ -49,7 +49,7 @@ suspend fun sleep(): Unit = suspendCoroutine { c ->
 }
 
 fun async(f: suspend () -> Unit) {
-    f.startCoroutine(object : Continuation<Unit> {
+    f.startCoroutine(object : ContinuationAdapter<Unit>() {
         override fun resume(x: Unit) {
             proceed = {
                 result += "done;"
@@ -62,7 +62,7 @@ fun async(f: suspend () -> Unit) {
 }
 
 fun asyncSuspend(f: suspend () -> Unit) {
-    val coroutine = f.createCoroutine(object : Continuation<Unit> {
+    val coroutine = f.createCoroutine(object : ContinuationAdapter<Unit>() {
         override fun resume(x: Unit) {
             proceed = {
                 result += "done;"

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

@@ -6,6 +6,12 @@ import helpers.*
 import COROUTINES_PACKAGE.*
 import COROUTINES_PACKAGE.intrinsics.*
 
+//public suspend inline fun <T> suspendCoroutineOrReturn(crossinline block: (Continuation<T>) -> Any?): T =
+//    suspendCoroutineUninterceptedOrReturn { cont -> block(cont.intercepted()) }
+//
+//public inline fun <T> Continuation<T>.resume(value: T): Unit =
+//    resumeWith(SuccessOrFailure.success(value))
+
 suspend fun suspendHere(): String = suspendCoroutineOrReturn { x ->
     x.resume("OK")
     COROUTINE_SUSPENDED

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

@@ -14,7 +14,7 @@ suspend fun suspendHere(): String = suspendCoroutineOrReturn { x ->
 fun builder(c: suspend () -> Int): Int {
     var res = 0
 
-    c.createCoroutine(object : Continuation<Int> {
+    c.createCoroutine(object : ContinuationAdapter<Int>() {
         override val context = EmptyCoroutineContext
 
         override fun resume(data: Int) {

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

@@ -1,7 +1,7 @@
+// LANGUAGE_VERSION: 1.3
 // TARGET_BACKEND: JVM
 // WITH_RUNTIME
 // WITH_COROUTINES
-// COMMON_COROUTINES_TEST
 
 // FILE: I.kt
 
@@ -14,20 +14,20 @@ interface I {
 
 public class JavaClass implements I {
     @Override
-    public String foo(int x, COROUTINES_PACKAGE.Continuation<? super String> continuation) {
+    public String foo(int x, kotlin.coroutines.Continuation<? super String> continuation) {
         return "O";
     }
 
     @Override
-    public Object bar(int x, COROUTINES_PACKAGE.Continuation<? super String> continuation) {
+    public Object bar(int x, kotlin.coroutines.Continuation<? super String> continuation) {
         return foo(x, continuation);
     }
 }
 
 // FILE: main.kt
 import helpers.*
-import COROUTINES_PACKAGE.*
-import COROUTINES_PACKAGE.intrinsics.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
 
 class K : JavaClass() {
     override suspend fun foo(x: Int): String = super.foo(x) + suspendCoroutine { it.resume("K") }

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

@@ -0,0 +1,48 @@
+// TARGET_BACKEND: JVM
+// WITH_RUNTIME
+// WITH_COROUTINES
+
+// FILE: I.kt
+
+interface I {
+    suspend fun foo(x: Int): String
+    suspend fun bar(x: Int): String
+}
+
+// FILE: JavaClass.java
+
+public class JavaClass implements I {
+    @Override
+    public String foo(int x, kotlin.coroutines.experimental.Continuation<? super String> continuation) {
+        return "O";
+    }
+
+    @Override
+    public Object bar(int x, kotlin.coroutines.experimental.Continuation<? super String> continuation) {
+        return foo(x, continuation);
+    }
+}
+
+// FILE: main.kt
+import helpers.*
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
+
+class K : JavaClass() {
+    override suspend fun foo(x: Int): String = super.foo(x) + suspendCoroutine { it.resume("K") }
+}
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+fun box(): String {
+    var result = "fail"
+
+    builder {
+        // Changing the call to 'K().bar(1)' doesn't work because of KT-25036
+        result = K().foo(1)
+    }
+
+    return result
+}

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

@@ -3,7 +3,7 @@
 // WITH_COROUTINES
 // COMMON_COROUTINES_TEST
 import helpers.*
-import COROUTINES_PACKAGE.startCoroutine
+import COROUTINES_PACKAGE.*
 import COROUTINES_PACKAGE.intrinsics.*
 
 interface TestInterface {

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

@@ -7,6 +7,7 @@
 package stuff
 import helpers.*
 
+import COROUTINES_PACKAGE.*
 import COROUTINES_PACKAGE.intrinsics.*
 
 object Host {

compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/dispatchResume.kt

@@ -32,7 +32,7 @@ abstract class ContinuationDispatcher : AbstractCoroutineContextElement(Continua
 private class DispatchedContinuation<T>(
         val dispatcher: ContinuationDispatcher,
         val continuation: Continuation<T>
-): Continuation<T> {
+): ContinuationAdapter<T>() {
     override val context: CoroutineContext = continuation.context
 
     override fun resume(value: T) {

compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/openFunWithJava.kt

@@ -1,14 +1,12 @@
+// LANGUAGE_VERSION: 1.3
 // IGNORE_BACKEND: JS_IR
 // WITH_RUNTIME
 // WITH_COROUTINES
-// COMMON_COROUTINES_TEST
 // FILE: main.kt
 // TARGET_BACKEND: JVM
 import helpers.*
-import COROUTINES_PACKAGE.*
-import COROUTINES_PACKAGE.intrinsics.*
-
-
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
 
 open class A(val v: String) {
     suspend fun suspendThere(v: String): String = suspendCoroutineOrReturn { x ->
@@ -36,7 +34,7 @@ fun box(): String {
 }
 
 // FILE: JavaClass.java
-import COROUTINES_PACKAGE.*;
+import kotlin.coroutines.*;
 public class JavaClass {
     public static String foo() {
         final String[] res = new String[1];
@@ -48,12 +46,8 @@ public class JavaClass {
             }
 
             @Override
-            public void resume(String s) {
-                res[0] = s;
-            }
-
-            @Override
-            public void resumeWithException(Throwable throwable) {
+            public void resumeWith(Object x) {
+                res[0] = (String) x;
             }
         });
 

compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/openFunWithJava_1_2.kt

@@ -0,0 +1,61 @@
+// IGNORE_BACKEND: JS_IR
+// WITH_RUNTIME
+// WITH_COROUTINES
+// FILE: main.kt
+// TARGET_BACKEND: JVM
+import helpers.*
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
+
+
+
+open class A(val v: String) {
+    suspend fun suspendThere(v: String): String = suspendCoroutineOrReturn { x ->
+        x.resume(v)
+        COROUTINE_SUSPENDED
+    }
+
+    open suspend fun suspendHere(): String = suspendThere("O") + suspendThere(v)
+}
+
+class B(v: String) : A(v) {
+    override suspend fun suspendHere(): String = super.suspendHere() + suspendThere("56")
+}
+
+fun builder(c: suspend A.() -> Unit) {
+    c.startCoroutine(B("K"), EmptyContinuation)
+}
+
+fun box(): String {
+    var result = JavaClass.foo()
+
+    if (result != "OK56") return "fail 1: $result"
+
+    return "OK"
+}
+
+// FILE: JavaClass.java
+import kotlin.coroutines.experimental.*;
+public class JavaClass {
+    public static String foo() {
+        final String[] res = new String[1];
+
+        new B("K").suspendHere(new Continuation<String>() {
+            @Override
+            public CoroutineContext getContext() {
+                return EmptyCoroutineContext.INSTANCE;
+            }
+
+            @Override
+            public void resume(String s) {
+                res[0] = s;
+            }
+
+            @Override
+            public void resumeWithException(Throwable throwable) {
+            }
+        });
+
+        return res[0];
+    }
+}

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

@@ -1,7 +1,7 @@
+// LANGUAGE_VERSION: 1.3
 // TARGET_BACKEND: JVM
 // WITH_RUNTIME
 // WITH_COROUTINES
-// COMMON_COROUTINES_TEST
 
 // FILE: I.kt
 
@@ -13,16 +13,16 @@ interface I {
 
 public class JavaClass implements I {
     @Override
-    public Object foo(int x, COROUTINES_PACKAGE.Continuation<? super String> continuation) {
-        continuation.resume("OK");
-        return COROUTINES_PACKAGE.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED();
+    public Object foo(int x, kotlin.coroutines.Continuation<? super String> continuation) {
+        continuation.resumeWith("OK");
+        return kotlin.coroutines.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED();
     }
 }
 
 // FILE: main.kt
 import helpers.*
-import COROUTINES_PACKAGE.*
-import COROUTINES_PACKAGE.intrinsics.*
+import kotlin.coroutines.*
+import kotlin.coroutines.intrinsics.*
 
 fun builder(c: suspend () -> Unit) {
     c.startCoroutine(EmptyContinuation)

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

@@ -0,0 +1,38 @@
+// TARGET_BACKEND: JVM
+// WITH_RUNTIME
+// WITH_COROUTINES
+
+// FILE: I.kt
+
+interface I {
+    suspend fun foo(x: Int): String
+}
+
+// FILE: JavaClass.java
+
+public class JavaClass implements I {
+    @Override
+    public Object foo(int x, kotlin.coroutines.experimental.Continuation<? super String> continuation) {
+        continuation.resume("OK");
+        return kotlin.coroutines.experimental.intrinsics.IntrinsicsKt.getCOROUTINE_SUSPENDED();
+    }
+}
+
+// FILE: main.kt
+import helpers.*
+import kotlin.coroutines.experimental.*
+import kotlin.coroutines.experimental.intrinsics.*
+
+fun builder(c: suspend () -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+fun box(): String {
+    var result = "fail"
+
+    builder {
+        result = JavaClass().foo(1)
+    }
+
+    return result
+}

compiler/testData/codegen/box/coroutines/tailCallOptimizations/crossinline.txt

@@ -1,68 +1,3 @@
-@kotlin.Metadata
-public final class CrossinlineKt$box$1$doResume$$inlined$filter$1$1 {
-    field L$0: java.lang.Object
-    field L$1: java.lang.Object
-    field L$2: java.lang.Object
-    field L$3: java.lang.Object
-    field L$4: java.lang.Object
-    field L$5: java.lang.Object
-    synthetic field data: java.lang.Object
-    synthetic field exception: java.lang.Throwable
-    synthetic final field this$0: CrossinlineKt$box$1$doResume$$inlined$filter$1
-    inner class CrossinlineKt$box$1$doResume$$inlined$filter$1
-    inner class CrossinlineKt$box$1$doResume$$inlined$filter$1$1
-    public method <init>(p0: CrossinlineKt$box$1$doResume$$inlined$filter$1, p1: COROUTINES_PACKAGE.Continuation): void
-    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
-    synthetic final method getLabel(): int
-    synthetic final method setLabel(p0: int): void
-}
-
-@kotlin.Metadata
-public final class CrossinlineKt$box$1$doResume$$inlined$filter$1$2$1 {
-    field L$0: java.lang.Object
-    field L$1: java.lang.Object
-    field L$2: java.lang.Object
-    synthetic field data: java.lang.Object
-    synthetic field exception: java.lang.Throwable
-    synthetic final field this$0: CrossinlineKt$box$1$doResume$$inlined$filter$1$2
-    inner class CrossinlineKt$box$1$doResume$$inlined$filter$1$2
-    inner class CrossinlineKt$box$1$doResume$$inlined$filter$1$2$1
-    public method <init>(p0: CrossinlineKt$box$1$doResume$$inlined$filter$1$2, p1: COROUTINES_PACKAGE.Continuation): void
-    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
-    synthetic final method getLabel(): int
-    synthetic final method setLabel(p0: int): void
-}
-
-@kotlin.Metadata
-public final class CrossinlineKt$box$1$doResume$$inlined$filter$1$2 {
-    synthetic final field receiver$0$inlined: Sink
-    synthetic final field this$0: CrossinlineKt$box$1$doResume$$inlined$filter$1
-    inner class CrossinlineKt$box$1$doResume$$inlined$filter$1$2
-    inner class CrossinlineKt$box$1$doResume$$inlined$filter$1$2$1
-    public method <init>(p0: Sink, p1: CrossinlineKt$box$1$doResume$$inlined$filter$1): void
-    public method close(@org.jetbrains.annotations.Nullable p0: java.lang.Throwable): void
-    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
-}
-
-@kotlin.Metadata
-public final class CrossinlineKt$box$1$doResume$$inlined$filter$1 {
-    synthetic final field receiver$0$inlined: SourceCrossinline
-    inner class CrossinlineKt$box$1$doResume$$inlined$filter$1
-    inner class CrossinlineKt$box$1$doResume$$inlined$filter$1$1
-    public method <init>(p0: SourceCrossinline): void
-    public @org.jetbrains.annotations.Nullable method consume(@org.jetbrains.annotations.NotNull p0: Sink, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
-}
-
-@kotlin.Metadata
-public final class CrossinlineKt$box$1$doResume$$inlined$fold$1 {
-    synthetic final field $acc$inlined: kotlin.jvm.internal.Ref$ObjectRef
-    inner class CrossinlineKt$box$1$doResume$$inlined$fold$1
-    inner class CrossinlineKt$box$1$fold$$inlined$consumeEach$1$1
-    public method <init>(p0: kotlin.jvm.internal.Ref$ObjectRef): void
-    public method close(@org.jetbrains.annotations.Nullable p0: java.lang.Throwable): void
-    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
-}
-
 @kotlin.Metadata
 public final class CrossinlineKt$box$1$filter$$inlined$source$1$1 {
     field L$0: java.lang.Object
@@ -72,13 +7,13 @@ public final class CrossinlineKt$box$1$filter$$inlined$source$1$1 {
     field L$4: java.lang.Object
     field L$5: java.lang.Object
     synthetic field data: java.lang.Object
-    synthetic field exception: java.lang.Throwable
+    field label: int
     synthetic final field this$0: CrossinlineKt$box$1$filter$$inlined$source$1
     inner class CrossinlineKt$box$1$filter$$inlined$source$1
     inner class CrossinlineKt$box$1$filter$$inlined$source$1$1
-    public method <init>(p0: CrossinlineKt$box$1$filter$$inlined$source$1, p1: COROUTINES_PACKAGE.Continuation): void
-    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    public method <init>(p0: CrossinlineKt$box$1$filter$$inlined$source$1, p1: kotlin.coroutines.Continuation): void
     synthetic final method getLabel(): int
+    public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
     synthetic final method setLabel(p0: int): void
 }
 
@@ -88,13 +23,13 @@ public final class CrossinlineKt$box$1$filter$$inlined$source$1$lambda$1$1 {
     field L$1: java.lang.Object
     field L$2: java.lang.Object
     synthetic field data: java.lang.Object
-    synthetic field exception: java.lang.Throwable
+    field label: int
     synthetic final field this$0: CrossinlineKt$box$1$filter$$inlined$source$1$lambda$1
     inner class CrossinlineKt$box$1$filter$$inlined$source$1$lambda$1
     inner class CrossinlineKt$box$1$filter$$inlined$source$1$lambda$1$1
-    public method <init>(p0: CrossinlineKt$box$1$filter$$inlined$source$1$lambda$1, p1: COROUTINES_PACKAGE.Continuation): void
-    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    public method <init>(p0: CrossinlineKt$box$1$filter$$inlined$source$1$lambda$1, p1: kotlin.coroutines.Continuation): void
     synthetic final method getLabel(): int
+    public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
     synthetic final method setLabel(p0: int): void
 }
 
@@ -106,7 +41,7 @@ public final class CrossinlineKt$box$1$filter$$inlined$source$1$lambda$1 {
     inner class CrossinlineKt$box$1$filter$$inlined$source$1$lambda$1$1
     public method <init>(p0: Sink, p1: CrossinlineKt$box$1$filter$$inlined$source$1): void
     public method close(@org.jetbrains.annotations.Nullable p0: java.lang.Throwable): void
-    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -116,19 +51,19 @@ public final class CrossinlineKt$box$1$filter$$inlined$source$1 {
     inner class CrossinlineKt$box$1$filter$$inlined$source$1
     inner class CrossinlineKt$box$1$filter$$inlined$source$1$1
     public method <init>(p0: SourceCrossinline, p1: kotlin.jvm.functions.Function1): void
-    public @org.jetbrains.annotations.Nullable method consume(@org.jetbrains.annotations.NotNull p0: Sink, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    public @org.jetbrains.annotations.Nullable method consume(@org.jetbrains.annotations.NotNull p0: Sink, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
 public final class CrossinlineKt$box$1$fold$$inlined$consumeEach$1$1 {
     synthetic field data: java.lang.Object
-    synthetic field exception: java.lang.Throwable
+    field label: int
     synthetic final field this$0: CrossinlineKt$box$1$fold$$inlined$consumeEach$1
     inner class CrossinlineKt$box$1$fold$$inlined$consumeEach$1
     inner class CrossinlineKt$box$1$fold$$inlined$consumeEach$1$1
-    public method <init>(p0: CrossinlineKt$box$1$fold$$inlined$consumeEach$1, p1: COROUTINES_PACKAGE.Continuation): void
-    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    public method <init>(p0: CrossinlineKt$box$1$fold$$inlined$consumeEach$1, p1: kotlin.coroutines.Continuation): void
     synthetic final method getLabel(): int
+    public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
     synthetic final method setLabel(p0: int): void
 }
 
@@ -140,7 +75,72 @@ public final class CrossinlineKt$box$1$fold$$inlined$consumeEach$1 {
     inner class CrossinlineKt$box$1$fold$$inlined$consumeEach$1$1
     public method <init>(p0: kotlin.jvm.internal.Ref$ObjectRef, p1: kotlin.jvm.functions.Function3): void
     public method close(@org.jetbrains.annotations.Nullable p0: java.lang.Throwable): void
-    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$box$1$invokeSuspend$$inlined$filter$1$1 {
+    field L$0: java.lang.Object
+    field L$1: java.lang.Object
+    field L$2: java.lang.Object
+    field L$3: java.lang.Object
+    field L$4: java.lang.Object
+    field L$5: java.lang.Object
+    synthetic field data: java.lang.Object
+    field label: int
+    synthetic final field this$0: CrossinlineKt$box$1$invokeSuspend$$inlined$filter$1
+    inner class CrossinlineKt$box$1$invokeSuspend$$inlined$filter$1
+    inner class CrossinlineKt$box$1$invokeSuspend$$inlined$filter$1$1
+    public method <init>(p0: CrossinlineKt$box$1$invokeSuspend$$inlined$filter$1, p1: kotlin.coroutines.Continuation): void
+    synthetic final method getLabel(): int
+    public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
+    synthetic final method setLabel(p0: int): void
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$box$1$invokeSuspend$$inlined$filter$1$2$1 {
+    field L$0: java.lang.Object
+    field L$1: java.lang.Object
+    field L$2: java.lang.Object
+    synthetic field data: java.lang.Object
+    field label: int
+    synthetic final field this$0: CrossinlineKt$box$1$invokeSuspend$$inlined$filter$1$2
+    inner class CrossinlineKt$box$1$invokeSuspend$$inlined$filter$1$2
+    inner class CrossinlineKt$box$1$invokeSuspend$$inlined$filter$1$2$1
+    public method <init>(p0: CrossinlineKt$box$1$invokeSuspend$$inlined$filter$1$2, p1: kotlin.coroutines.Continuation): void
+    synthetic final method getLabel(): int
+    public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
+    synthetic final method setLabel(p0: int): void
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$box$1$invokeSuspend$$inlined$filter$1$2 {
+    synthetic final field receiver$0$inlined: Sink
+    synthetic final field this$0: CrossinlineKt$box$1$invokeSuspend$$inlined$filter$1
+    inner class CrossinlineKt$box$1$invokeSuspend$$inlined$filter$1$2
+    inner class CrossinlineKt$box$1$invokeSuspend$$inlined$filter$1$2$1
+    public method <init>(p0: Sink, p1: CrossinlineKt$box$1$invokeSuspend$$inlined$filter$1): void
+    public method close(@org.jetbrains.annotations.Nullable p0: java.lang.Throwable): void
+    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$box$1$invokeSuspend$$inlined$filter$1 {
+    synthetic final field receiver$0$inlined: SourceCrossinline
+    inner class CrossinlineKt$box$1$invokeSuspend$$inlined$filter$1
+    inner class CrossinlineKt$box$1$invokeSuspend$$inlined$filter$1$1
+    public method <init>(p0: SourceCrossinline): void
+    public @org.jetbrains.annotations.Nullable method consume(@org.jetbrains.annotations.NotNull p0: Sink, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$box$1$invokeSuspend$$inlined$fold$1 {
+    synthetic final field $acc$inlined: kotlin.jvm.internal.Ref$ObjectRef
+    inner class CrossinlineKt$box$1$fold$$inlined$consumeEach$1$1
+    inner class CrossinlineKt$box$1$invokeSuspend$$inlined$fold$1
+    public method <init>(p0: kotlin.jvm.internal.Ref$ObjectRef): void
+    public method close(@org.jetbrains.annotations.Nullable p0: java.lang.Throwable): void
+    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -151,24 +151,25 @@ final class CrossinlineKt$box$1 {
     field L$2: java.lang.Object
     field L$3: java.lang.Object
     field L$4: java.lang.Object
+    field label: int
     inner class CrossinlineKt$box$1
-    method <init>(p0: kotlin.jvm.internal.Ref$IntRef, p1: COROUTINES_PACKAGE.Continuation): void
-    public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): COROUTINES_PACKAGE.Continuation
-    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    method <init>(p0: kotlin.jvm.internal.Ref$IntRef, p1: kotlin.coroutines.Continuation): void
+    public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation
+    public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object
     public synthetic method invoke(p0: java.lang.Object): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
 }
 
 @kotlin.Metadata
 public final class CrossinlineKt$consumeEach$2$send$1 {
     synthetic field data: java.lang.Object
-    synthetic field exception: java.lang.Throwable
+    field label: int
     synthetic final field this$0: CrossinlineKt$consumeEach$2
     inner class CrossinlineKt$consumeEach$2
     inner class CrossinlineKt$consumeEach$2$send$1
-    public method <init>(p0: CrossinlineKt$consumeEach$2, p1: COROUTINES_PACKAGE.Continuation): void
-    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    public method <init>(p0: CrossinlineKt$consumeEach$2, p1: kotlin.coroutines.Continuation): void
     synthetic final method getLabel(): int
+    public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
     synthetic final method setLabel(p0: int): void
 }
 
@@ -179,7 +180,7 @@ public final class CrossinlineKt$consumeEach$2 {
     inner class CrossinlineKt$consumeEach$2$send$1
     public method <init>(p0: kotlin.jvm.functions.Function2): void
     public method close(@org.jetbrains.annotations.Nullable p0: java.lang.Throwable): void
-    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -191,13 +192,13 @@ public final class CrossinlineKt$filter$$inlined$source$1$1 {
     field L$4: java.lang.Object
     field L$5: java.lang.Object
     synthetic field data: java.lang.Object
-    synthetic field exception: java.lang.Throwable
+    field label: int
     synthetic final field this$0: CrossinlineKt$filter$$inlined$source$1
     inner class CrossinlineKt$filter$$inlined$source$1
     inner class CrossinlineKt$filter$$inlined$source$1$1
-    public method <init>(p0: CrossinlineKt$filter$$inlined$source$1, p1: COROUTINES_PACKAGE.Continuation): void
-    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    public method <init>(p0: CrossinlineKt$filter$$inlined$source$1, p1: kotlin.coroutines.Continuation): void
     synthetic final method getLabel(): int
+    public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
     synthetic final method setLabel(p0: int): void
 }
 
@@ -207,13 +208,13 @@ public final class CrossinlineKt$filter$$inlined$source$1$lambda$1$1 {
     field L$1: java.lang.Object
     field L$2: java.lang.Object
     synthetic field data: java.lang.Object
-    synthetic field exception: java.lang.Throwable
+    field label: int
     synthetic final field this$0: CrossinlineKt$filter$$inlined$source$1$lambda$1
     inner class CrossinlineKt$filter$$inlined$source$1$lambda$1
     inner class CrossinlineKt$filter$$inlined$source$1$lambda$1$1
-    public method <init>(p0: CrossinlineKt$filter$$inlined$source$1$lambda$1, p1: COROUTINES_PACKAGE.Continuation): void
-    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    public method <init>(p0: CrossinlineKt$filter$$inlined$source$1$lambda$1, p1: kotlin.coroutines.Continuation): void
     synthetic final method getLabel(): int
+    public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
     synthetic final method setLabel(p0: int): void
 }
 
@@ -225,7 +226,7 @@ public final class CrossinlineKt$filter$$inlined$source$1$lambda$1 {
     inner class CrossinlineKt$filter$$inlined$source$1$lambda$1$1
     public method <init>(p0: Sink, p1: CrossinlineKt$filter$$inlined$source$1): void
     public method close(@org.jetbrains.annotations.Nullable p0: java.lang.Throwable): void
-    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -235,19 +236,19 @@ public final class CrossinlineKt$filter$$inlined$source$1 {
     inner class CrossinlineKt$filter$$inlined$source$1
     inner class CrossinlineKt$filter$$inlined$source$1$1
     public method <init>(p0: SourceCrossinline, p1: kotlin.jvm.functions.Function1): void
-    public @org.jetbrains.annotations.Nullable method consume(@org.jetbrains.annotations.NotNull p0: Sink, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    public @org.jetbrains.annotations.Nullable method consume(@org.jetbrains.annotations.NotNull p0: Sink, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
 public final class CrossinlineKt$fold$$inlined$consumeEach$1$1 {
     synthetic field data: java.lang.Object
-    synthetic field exception: java.lang.Throwable
+    field label: int
     synthetic final field this$0: CrossinlineKt$fold$$inlined$consumeEach$1
     inner class CrossinlineKt$fold$$inlined$consumeEach$1
     inner class CrossinlineKt$fold$$inlined$consumeEach$1$1
-    public method <init>(p0: CrossinlineKt$fold$$inlined$consumeEach$1, p1: COROUTINES_PACKAGE.Continuation): void
-    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    public method <init>(p0: CrossinlineKt$fold$$inlined$consumeEach$1, p1: kotlin.coroutines.Continuation): void
     synthetic final method getLabel(): int
+    public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
     synthetic final method setLabel(p0: int): void
 }
 
@@ -259,7 +260,7 @@ public final class CrossinlineKt$fold$$inlined$consumeEach$1 {
     inner class CrossinlineKt$fold$$inlined$consumeEach$1$1
     public method <init>(p0: kotlin.jvm.internal.Ref$ObjectRef, p1: kotlin.jvm.functions.Function3): void
     public method close(@org.jetbrains.annotations.Nullable p0: java.lang.Throwable): void
-    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -272,13 +273,13 @@ public final class CrossinlineKt$range$$inlined$source$1$1 {
     field L$3: java.lang.Object
     field L$4: java.lang.Object
     synthetic field data: java.lang.Object
-    synthetic field exception: java.lang.Throwable
+    field label: int
     synthetic final field this$0: CrossinlineKt$range$$inlined$source$1
     inner class CrossinlineKt$range$$inlined$source$1
     inner class CrossinlineKt$range$$inlined$source$1$1
-    public method <init>(p0: CrossinlineKt$range$$inlined$source$1, p1: COROUTINES_PACKAGE.Continuation): void
-    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    public method <init>(p0: CrossinlineKt$range$$inlined$source$1, p1: kotlin.coroutines.Continuation): void
     synthetic final method getLabel(): int
+    public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
     synthetic final method setLabel(p0: int): void
 }
 
@@ -289,19 +290,19 @@ public final class CrossinlineKt$range$$inlined$source$1 {
     inner class CrossinlineKt$range$$inlined$source$1
     inner class CrossinlineKt$range$$inlined$source$1$1
     public method <init>(p0: int, p1: int): void
-    public @org.jetbrains.annotations.Nullable method consume(@org.jetbrains.annotations.NotNull p0: Sink, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    public @org.jetbrains.annotations.Nullable method consume(@org.jetbrains.annotations.NotNull p0: Sink, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
 public final class CrossinlineKt$source$1$consume$1 {
     synthetic field data: java.lang.Object
-    synthetic field exception: java.lang.Throwable
+    field label: int
     synthetic final field this$0: CrossinlineKt$source$1
     inner class CrossinlineKt$source$1
     inner class CrossinlineKt$source$1$consume$1
-    public method <init>(p0: CrossinlineKt$source$1, p1: COROUTINES_PACKAGE.Continuation): void
-    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    public method <init>(p0: CrossinlineKt$source$1, p1: kotlin.coroutines.Continuation): void
     synthetic final method getLabel(): int
+    public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
     synthetic final method setLabel(p0: int): void
 }
 
@@ -311,7 +312,7 @@ public final class CrossinlineKt$source$1 {
     inner class CrossinlineKt$source$1
     inner class CrossinlineKt$source$1$consume$1
     public method <init>(p0: kotlin.jvm.functions.Function2): void
-    public @org.jetbrains.annotations.Nullable method consume(@org.jetbrains.annotations.NotNull p0: Sink, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    public @org.jetbrains.annotations.Nullable method consume(@org.jetbrains.annotations.NotNull p0: Sink, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -321,9 +322,9 @@ public final class CrossinlineKt {
     inner class CrossinlineKt$source$1
     public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
     public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void
-    private final static method consumeEach(@org.jetbrains.annotations.NotNull p0: SourceCrossinline, p1: kotlin.jvm.functions.Function2, p2: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    private final static method consumeEach(@org.jetbrains.annotations.NotNull p0: SourceCrossinline, p1: kotlin.jvm.functions.Function2, p2: kotlin.coroutines.Continuation): java.lang.Object
     public final static @org.jetbrains.annotations.NotNull method filter(@org.jetbrains.annotations.NotNull p0: SourceCrossinline, @org.jetbrains.annotations.NotNull p1: kotlin.jvm.functions.Function1): SourceCrossinline
-    private final static method fold(@org.jetbrains.annotations.NotNull p0: SourceCrossinline, p1: java.lang.Object, p2: kotlin.jvm.functions.Function3, p3: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    private final static method fold(@org.jetbrains.annotations.NotNull p0: SourceCrossinline, p1: java.lang.Object, p2: kotlin.jvm.functions.Function3, p3: kotlin.coroutines.Continuation): java.lang.Object
     public final static method isGood(p0: int): boolean
     public final static @org.jetbrains.annotations.NotNull method range(@org.jetbrains.annotations.NotNull p0: SourceCrossinline$Factory, p1: int, p2: int): SourceCrossinline
     public final static @org.jetbrains.annotations.NotNull method source(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function2): SourceCrossinline
@@ -332,7 +333,7 @@ public final class CrossinlineKt {
 @kotlin.Metadata
 public interface Sink {
     public abstract method close(@org.jetbrains.annotations.Nullable p0: java.lang.Throwable): void
-    public abstract @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    public abstract @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -348,5 +349,5 @@ public interface SourceCrossinline {
     public final static field Factory: SourceCrossinline$Factory
     inner class SourceCrossinline$Factory
     static method <clinit>(): void
-    public abstract @org.jetbrains.annotations.Nullable method consume(@org.jetbrains.annotations.NotNull p0: Sink, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    public abstract @org.jetbrains.annotations.Nullable method consume(@org.jetbrains.annotations.NotNull p0: Sink, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
 }

compiler/testData/codegen/box/coroutines/tailCallOptimizations/crossinline_1_2.txt

@@ -0,0 +1,352 @@
+@kotlin.Metadata
+public final class CrossinlineKt$box$1$doResume$$inlined$filter$1$1 {
+    field L$0: java.lang.Object
+    field L$1: java.lang.Object
+    field L$2: java.lang.Object
+    field L$3: java.lang.Object
+    field L$4: java.lang.Object
+    field L$5: java.lang.Object
+    synthetic field data: java.lang.Object
+    synthetic field exception: java.lang.Throwable
+    synthetic final field this$0: CrossinlineKt$box$1$doResume$$inlined$filter$1
+    inner class CrossinlineKt$box$1$doResume$$inlined$filter$1
+    inner class CrossinlineKt$box$1$doResume$$inlined$filter$1$1
+    public method <init>(p0: CrossinlineKt$box$1$doResume$$inlined$filter$1, p1: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    synthetic final method getLabel(): int
+    synthetic final method setLabel(p0: int): void
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$box$1$doResume$$inlined$filter$1$2$1 {
+    field L$0: java.lang.Object
+    field L$1: java.lang.Object
+    field L$2: java.lang.Object
+    synthetic field data: java.lang.Object
+    synthetic field exception: java.lang.Throwable
+    synthetic final field this$0: CrossinlineKt$box$1$doResume$$inlined$filter$1$2
+    inner class CrossinlineKt$box$1$doResume$$inlined$filter$1$2
+    inner class CrossinlineKt$box$1$doResume$$inlined$filter$1$2$1
+    public method <init>(p0: CrossinlineKt$box$1$doResume$$inlined$filter$1$2, p1: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    synthetic final method getLabel(): int
+    synthetic final method setLabel(p0: int): void
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$box$1$doResume$$inlined$filter$1$2 {
+    synthetic final field receiver$0$inlined: Sink
+    synthetic final field this$0: CrossinlineKt$box$1$doResume$$inlined$filter$1
+    inner class CrossinlineKt$box$1$doResume$$inlined$filter$1$2
+    inner class CrossinlineKt$box$1$doResume$$inlined$filter$1$2$1
+    public method <init>(p0: Sink, p1: CrossinlineKt$box$1$doResume$$inlined$filter$1): void
+    public method close(@org.jetbrains.annotations.Nullable p0: java.lang.Throwable): void
+    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$box$1$doResume$$inlined$filter$1 {
+    synthetic final field receiver$0$inlined: SourceCrossinline
+    inner class CrossinlineKt$box$1$doResume$$inlined$filter$1
+    inner class CrossinlineKt$box$1$doResume$$inlined$filter$1$1
+    public method <init>(p0: SourceCrossinline): void
+    public @org.jetbrains.annotations.Nullable method consume(@org.jetbrains.annotations.NotNull p0: Sink, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$box$1$doResume$$inlined$fold$1 {
+    synthetic final field $acc$inlined: kotlin.jvm.internal.Ref$ObjectRef
+    inner class CrossinlineKt$box$1$doResume$$inlined$fold$1
+    inner class CrossinlineKt$box$1$fold$$inlined$consumeEach$1$1
+    public method <init>(p0: kotlin.jvm.internal.Ref$ObjectRef): void
+    public method close(@org.jetbrains.annotations.Nullable p0: java.lang.Throwable): void
+    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$box$1$filter$$inlined$source$1$1 {
+    field L$0: java.lang.Object
+    field L$1: java.lang.Object
+    field L$2: java.lang.Object
+    field L$3: java.lang.Object
+    field L$4: java.lang.Object
+    field L$5: java.lang.Object
+    synthetic field data: java.lang.Object
+    synthetic field exception: java.lang.Throwable
+    synthetic final field this$0: CrossinlineKt$box$1$filter$$inlined$source$1
+    inner class CrossinlineKt$box$1$filter$$inlined$source$1
+    inner class CrossinlineKt$box$1$filter$$inlined$source$1$1
+    public method <init>(p0: CrossinlineKt$box$1$filter$$inlined$source$1, p1: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    synthetic final method getLabel(): int
+    synthetic final method setLabel(p0: int): void
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$box$1$filter$$inlined$source$1$lambda$1$1 {
+    field L$0: java.lang.Object
+    field L$1: java.lang.Object
+    field L$2: java.lang.Object
+    synthetic field data: java.lang.Object
+    synthetic field exception: java.lang.Throwable
+    synthetic final field this$0: CrossinlineKt$box$1$filter$$inlined$source$1$lambda$1
+    inner class CrossinlineKt$box$1$filter$$inlined$source$1$lambda$1
+    inner class CrossinlineKt$box$1$filter$$inlined$source$1$lambda$1$1
+    public method <init>(p0: CrossinlineKt$box$1$filter$$inlined$source$1$lambda$1, p1: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    synthetic final method getLabel(): int
+    synthetic final method setLabel(p0: int): void
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$box$1$filter$$inlined$source$1$lambda$1 {
+    synthetic final field receiver$0$inlined: Sink
+    synthetic final field this$0: CrossinlineKt$box$1$filter$$inlined$source$1
+    inner class CrossinlineKt$box$1$filter$$inlined$source$1$lambda$1
+    inner class CrossinlineKt$box$1$filter$$inlined$source$1$lambda$1$1
+    public method <init>(p0: Sink, p1: CrossinlineKt$box$1$filter$$inlined$source$1): void
+    public method close(@org.jetbrains.annotations.Nullable p0: java.lang.Throwable): void
+    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$box$1$filter$$inlined$source$1 {
+    synthetic final field $predicate$inlined: kotlin.jvm.functions.Function1
+    synthetic final field receiver$0$inlined: SourceCrossinline
+    inner class CrossinlineKt$box$1$filter$$inlined$source$1
+    inner class CrossinlineKt$box$1$filter$$inlined$source$1$1
+    public method <init>(p0: SourceCrossinline, p1: kotlin.jvm.functions.Function1): void
+    public @org.jetbrains.annotations.Nullable method consume(@org.jetbrains.annotations.NotNull p0: Sink, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$box$1$fold$$inlined$consumeEach$1$1 {
+    synthetic field data: java.lang.Object
+    synthetic field exception: java.lang.Throwable
+    synthetic final field this$0: CrossinlineKt$box$1$fold$$inlined$consumeEach$1
+    inner class CrossinlineKt$box$1$fold$$inlined$consumeEach$1
+    inner class CrossinlineKt$box$1$fold$$inlined$consumeEach$1$1
+    public method <init>(p0: CrossinlineKt$box$1$fold$$inlined$consumeEach$1, p1: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    synthetic final method getLabel(): int
+    synthetic final method setLabel(p0: int): void
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$box$1$fold$$inlined$consumeEach$1 {
+    synthetic final field $acc$inlined: kotlin.jvm.internal.Ref$ObjectRef
+    synthetic final field $operation$inlined: kotlin.jvm.functions.Function3
+    inner class CrossinlineKt$box$1$fold$$inlined$consumeEach$1
+    inner class CrossinlineKt$box$1$fold$$inlined$consumeEach$1$1
+    public method <init>(p0: kotlin.jvm.internal.Ref$ObjectRef, p1: kotlin.jvm.functions.Function3): void
+    public method close(@org.jetbrains.annotations.Nullable p0: java.lang.Throwable): void
+    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+}
+
+@kotlin.Metadata
+final class CrossinlineKt$box$1 {
+    synthetic final field $res: kotlin.jvm.internal.Ref$IntRef
+    field L$0: java.lang.Object
+    field L$1: java.lang.Object
+    field L$2: java.lang.Object
+    field L$3: java.lang.Object
+    field L$4: java.lang.Object
+    inner class CrossinlineKt$box$1
+    method <init>(p0: kotlin.jvm.internal.Ref$IntRef, p1: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): kotlin.coroutines.experimental.Continuation
+    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): java.lang.Object
+    public synthetic method invoke(p0: java.lang.Object): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$consumeEach$2$send$1 {
+    synthetic field data: java.lang.Object
+    synthetic field exception: java.lang.Throwable
+    synthetic final field this$0: CrossinlineKt$consumeEach$2
+    inner class CrossinlineKt$consumeEach$2
+    inner class CrossinlineKt$consumeEach$2$send$1
+    public method <init>(p0: CrossinlineKt$consumeEach$2, p1: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    synthetic final method getLabel(): int
+    synthetic final method setLabel(p0: int): void
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$consumeEach$2 {
+    synthetic final field $action: kotlin.jvm.functions.Function2
+    inner class CrossinlineKt$consumeEach$2
+    inner class CrossinlineKt$consumeEach$2$send$1
+    public method <init>(p0: kotlin.jvm.functions.Function2): void
+    public method close(@org.jetbrains.annotations.Nullable p0: java.lang.Throwable): void
+    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$filter$$inlined$source$1$1 {
+    field L$0: java.lang.Object
+    field L$1: java.lang.Object
+    field L$2: java.lang.Object
+    field L$3: java.lang.Object
+    field L$4: java.lang.Object
+    field L$5: java.lang.Object
+    synthetic field data: java.lang.Object
+    synthetic field exception: java.lang.Throwable
+    synthetic final field this$0: CrossinlineKt$filter$$inlined$source$1
+    inner class CrossinlineKt$filter$$inlined$source$1
+    inner class CrossinlineKt$filter$$inlined$source$1$1
+    public method <init>(p0: CrossinlineKt$filter$$inlined$source$1, p1: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    synthetic final method getLabel(): int
+    synthetic final method setLabel(p0: int): void
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$filter$$inlined$source$1$lambda$1$1 {
+    field L$0: java.lang.Object
+    field L$1: java.lang.Object
+    field L$2: java.lang.Object
+    synthetic field data: java.lang.Object
+    synthetic field exception: java.lang.Throwable
+    synthetic final field this$0: CrossinlineKt$filter$$inlined$source$1$lambda$1
+    inner class CrossinlineKt$filter$$inlined$source$1$lambda$1
+    inner class CrossinlineKt$filter$$inlined$source$1$lambda$1$1
+    public method <init>(p0: CrossinlineKt$filter$$inlined$source$1$lambda$1, p1: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    synthetic final method getLabel(): int
+    synthetic final method setLabel(p0: int): void
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$filter$$inlined$source$1$lambda$1 {
+    synthetic final field receiver$0$inlined: Sink
+    synthetic final field this$0: CrossinlineKt$filter$$inlined$source$1
+    inner class CrossinlineKt$filter$$inlined$source$1$lambda$1
+    inner class CrossinlineKt$filter$$inlined$source$1$lambda$1$1
+    public method <init>(p0: Sink, p1: CrossinlineKt$filter$$inlined$source$1): void
+    public method close(@org.jetbrains.annotations.Nullable p0: java.lang.Throwable): void
+    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$filter$$inlined$source$1 {
+    synthetic final field $predicate$inlined: kotlin.jvm.functions.Function1
+    synthetic final field receiver$0$inlined: SourceCrossinline
+    inner class CrossinlineKt$filter$$inlined$source$1
+    inner class CrossinlineKt$filter$$inlined$source$1$1
+    public method <init>(p0: SourceCrossinline, p1: kotlin.jvm.functions.Function1): void
+    public @org.jetbrains.annotations.Nullable method consume(@org.jetbrains.annotations.NotNull p0: Sink, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$fold$$inlined$consumeEach$1$1 {
+    synthetic field data: java.lang.Object
+    synthetic field exception: java.lang.Throwable
+    synthetic final field this$0: CrossinlineKt$fold$$inlined$consumeEach$1
+    inner class CrossinlineKt$fold$$inlined$consumeEach$1
+    inner class CrossinlineKt$fold$$inlined$consumeEach$1$1
+    public method <init>(p0: CrossinlineKt$fold$$inlined$consumeEach$1, p1: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    synthetic final method getLabel(): int
+    synthetic final method setLabel(p0: int): void
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$fold$$inlined$consumeEach$1 {
+    synthetic final field $acc$inlined: kotlin.jvm.internal.Ref$ObjectRef
+    synthetic final field $operation$inlined: kotlin.jvm.functions.Function3
+    inner class CrossinlineKt$fold$$inlined$consumeEach$1
+    inner class CrossinlineKt$fold$$inlined$consumeEach$1$1
+    public method <init>(p0: kotlin.jvm.internal.Ref$ObjectRef, p1: kotlin.jvm.functions.Function3): void
+    public method close(@org.jetbrains.annotations.Nullable p0: java.lang.Throwable): void
+    public @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$range$$inlined$source$1$1 {
+    field I$0: int
+    field I$1: int
+    field L$0: java.lang.Object
+    field L$1: java.lang.Object
+    field L$2: java.lang.Object
+    field L$3: java.lang.Object
+    field L$4: java.lang.Object
+    synthetic field data: java.lang.Object
+    synthetic field exception: java.lang.Throwable
+    synthetic final field this$0: CrossinlineKt$range$$inlined$source$1
+    inner class CrossinlineKt$range$$inlined$source$1
+    inner class CrossinlineKt$range$$inlined$source$1$1
+    public method <init>(p0: CrossinlineKt$range$$inlined$source$1, p1: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    synthetic final method getLabel(): int
+    synthetic final method setLabel(p0: int): void
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$range$$inlined$source$1 {
+    synthetic final field $count$inlined: int
+    synthetic final field $start$inlined: int
+    inner class CrossinlineKt$range$$inlined$source$1
+    inner class CrossinlineKt$range$$inlined$source$1$1
+    public method <init>(p0: int, p1: int): void
+    public @org.jetbrains.annotations.Nullable method consume(@org.jetbrains.annotations.NotNull p0: Sink, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$source$1$consume$1 {
+    synthetic field data: java.lang.Object
+    synthetic field exception: java.lang.Throwable
+    synthetic final field this$0: CrossinlineKt$source$1
+    inner class CrossinlineKt$source$1
+    inner class CrossinlineKt$source$1$consume$1
+    public method <init>(p0: CrossinlineKt$source$1, p1: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    synthetic final method getLabel(): int
+    synthetic final method setLabel(p0: int): void
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt$source$1 {
+    synthetic final field $action: kotlin.jvm.functions.Function2
+    inner class CrossinlineKt$source$1
+    inner class CrossinlineKt$source$1$consume$1
+    public method <init>(p0: kotlin.jvm.functions.Function2): void
+    public @org.jetbrains.annotations.Nullable method consume(@org.jetbrains.annotations.NotNull p0: Sink, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class CrossinlineKt {
+    inner class CrossinlineKt$box$1
+    inner class CrossinlineKt$consumeEach$2
+    inner class CrossinlineKt$source$1
+    public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
+    public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void
+    private final static method consumeEach(@org.jetbrains.annotations.NotNull p0: SourceCrossinline, p1: kotlin.jvm.functions.Function2, p2: kotlin.coroutines.experimental.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.NotNull method filter(@org.jetbrains.annotations.NotNull p0: SourceCrossinline, @org.jetbrains.annotations.NotNull p1: kotlin.jvm.functions.Function1): SourceCrossinline
+    private final static method fold(@org.jetbrains.annotations.NotNull p0: SourceCrossinline, p1: java.lang.Object, p2: kotlin.jvm.functions.Function3, p3: kotlin.coroutines.experimental.Continuation): java.lang.Object
+    public final static method isGood(p0: int): boolean
+    public final static @org.jetbrains.annotations.NotNull method range(@org.jetbrains.annotations.NotNull p0: SourceCrossinline$Factory, p1: int, p2: int): SourceCrossinline
+    public final static @org.jetbrains.annotations.NotNull method source(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function2): SourceCrossinline
+}
+
+@kotlin.Metadata
+public interface Sink {
+    public abstract method close(@org.jetbrains.annotations.Nullable p0: java.lang.Throwable): void
+    public abstract @org.jetbrains.annotations.Nullable method send(p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class SourceCrossinline$Factory {
+    synthetic final static field $$INSTANCE: SourceCrossinline$Factory
+    inner class SourceCrossinline$Factory
+    static method <clinit>(): void
+    private method <init>(): void
+}
+
+@kotlin.Metadata
+public interface SourceCrossinline {
+    public final static field Factory: SourceCrossinline$Factory
+    inner class SourceCrossinline$Factory
+    static method <clinit>(): void
+    public abstract @org.jetbrains.annotations.Nullable method consume(@org.jetbrains.annotations.NotNull p0: Sink, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+}

compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine.txt

@@ -2,12 +2,13 @@
 final class InlineWithStateMachineKt$box$1 {
     synthetic final field $result: kotlin.jvm.internal.Ref$ObjectRef
     field L$0: java.lang.Object
+    field label: int
     inner class InlineWithStateMachineKt$box$1
-    method <init>(p0: kotlin.jvm.internal.Ref$ObjectRef, p1: COROUTINES_PACKAGE.Continuation): void
-    public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): COROUTINES_PACKAGE.Continuation
-    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    method <init>(p0: kotlin.jvm.internal.Ref$ObjectRef, p1: kotlin.coroutines.Continuation): void
+    public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation
+    public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object
     public synthetic method invoke(p0: java.lang.Object): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -15,11 +16,11 @@ final class InlineWithStateMachineKt$mainSuspend$1 {
     field L$0: java.lang.Object
     field L$1: java.lang.Object
     synthetic field data: java.lang.Object
-    synthetic field exception: java.lang.Throwable
+    field label: int
     inner class InlineWithStateMachineKt$mainSuspend$1
-    method <init>(p0: COROUTINES_PACKAGE.Continuation): void
-    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    method <init>(p0: kotlin.coroutines.Continuation): void
     synthetic final method getLabel(): int
+    public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
     synthetic final method setLabel(p0: int): void
 }
 
@@ -28,11 +29,11 @@ public final class InlineWithStateMachineKt$suspendHere$1 {
     field L$0: java.lang.Object
     field L$1: java.lang.Object
     synthetic field data: java.lang.Object
-    synthetic field exception: java.lang.Throwable
+    field label: int
     inner class InlineWithStateMachineKt$suspendHere$1
-    public method <init>(p0: COROUTINES_PACKAGE.Continuation): void
-    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    public method <init>(p0: kotlin.coroutines.Continuation): void
     synthetic final method getLabel(): int
+    public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
     synthetic final method setLabel(p0: int): void
 }
 
@@ -43,9 +44,9 @@ public final class InlineWithStateMachineKt {
     inner class InlineWithStateMachineKt$suspendHere$1
     public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
     public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void
-    public final static @org.jetbrains.annotations.Nullable method mainSuspend(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object
-    private final static @org.jetbrains.annotations.Nullable method suspendHere$$forInline(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object
-    public final static @org.jetbrains.annotations.Nullable method suspendHere(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object
-    private final static @org.jetbrains.annotations.Nullable method suspendThere$$forInline(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
-    public final static @org.jetbrains.annotations.Nullable method suspendThere(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method mainSuspend(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object
+    private final static @org.jetbrains.annotations.Nullable method suspendHere$$forInline(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method suspendHere(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object
+    private final static @org.jetbrains.annotations.Nullable method suspendThere$$forInline(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method suspendThere(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
 }

compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithStateMachine_1_2.txt

@@ -0,0 +1,51 @@
+@kotlin.Metadata
+final class InlineWithStateMachineKt$box$1 {
+    synthetic final field $result: kotlin.jvm.internal.Ref$ObjectRef
+    field L$0: java.lang.Object
+    inner class InlineWithStateMachineKt$box$1
+    method <init>(p0: kotlin.jvm.internal.Ref$ObjectRef, p1: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): kotlin.coroutines.experimental.Continuation
+    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): java.lang.Object
+    public synthetic method invoke(p0: java.lang.Object): java.lang.Object
+}
+
+@kotlin.Metadata
+final class InlineWithStateMachineKt$mainSuspend$1 {
+    field L$0: java.lang.Object
+    field L$1: java.lang.Object
+    synthetic field data: java.lang.Object
+    synthetic field exception: java.lang.Throwable
+    inner class InlineWithStateMachineKt$mainSuspend$1
+    method <init>(p0: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    synthetic final method getLabel(): int
+    synthetic final method setLabel(p0: int): void
+}
+
+@kotlin.Metadata
+public final class InlineWithStateMachineKt$suspendHere$1 {
+    field L$0: java.lang.Object
+    field L$1: java.lang.Object
+    synthetic field data: java.lang.Object
+    synthetic field exception: java.lang.Throwable
+    inner class InlineWithStateMachineKt$suspendHere$1
+    public method <init>(p0: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    synthetic final method getLabel(): int
+    synthetic final method setLabel(p0: int): void
+}
+
+@kotlin.Metadata
+public final class InlineWithStateMachineKt {
+    inner class InlineWithStateMachineKt$box$1
+    inner class InlineWithStateMachineKt$mainSuspend$1
+    inner class InlineWithStateMachineKt$suspendHere$1
+    public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
+    public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void
+    public final static @org.jetbrains.annotations.Nullable method mainSuspend(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): java.lang.Object
+    private final static @org.jetbrains.annotations.Nullable method suspendHere$$forInline(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method suspendHere(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): java.lang.Object
+    private final static @org.jetbrains.annotations.Nullable method suspendThere$$forInline(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method suspendThere(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+}

compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithoutStateMachine.txt

@@ -3,23 +3,24 @@ final class InlineWithoutStateMachineKt$box$1 {
     synthetic final field $result: kotlin.jvm.internal.Ref$ObjectRef
     field L$0: java.lang.Object
     field L$1: java.lang.Object
+    field label: int
     inner class InlineWithoutStateMachineKt$box$1
-    method <init>(p0: kotlin.jvm.internal.Ref$ObjectRef, p1: COROUTINES_PACKAGE.Continuation): void
-    public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): COROUTINES_PACKAGE.Continuation
-    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    method <init>(p0: kotlin.jvm.internal.Ref$ObjectRef, p1: kotlin.coroutines.Continuation): void
+    public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation
+    public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object
     public synthetic method invoke(p0: java.lang.Object): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
 }
 
 @kotlin.Metadata
 final class InlineWithoutStateMachineKt$complexSuspend$1 {
     field L$0: java.lang.Object
     synthetic field data: java.lang.Object
-    synthetic field exception: java.lang.Throwable
+    field label: int
     inner class InlineWithoutStateMachineKt$complexSuspend$1
-    method <init>(p0: COROUTINES_PACKAGE.Continuation): void
-    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    method <init>(p0: kotlin.coroutines.Continuation): void
     synthetic final method getLabel(): int
+    public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
     synthetic final method setLabel(p0: int): void
 }
 
@@ -29,8 +30,8 @@ public final class InlineWithoutStateMachineKt {
     inner class InlineWithoutStateMachineKt$complexSuspend$1
     public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
     public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void
-    public final static @org.jetbrains.annotations.Nullable method complexSuspend(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object
-    public final static @org.jetbrains.annotations.Nullable method suspendHere(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object
-    private final static @org.jetbrains.annotations.Nullable method suspendThere$$forInline(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
-    public final static @org.jetbrains.annotations.Nullable method suspendThere(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method complexSuspend(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method suspendHere(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object
+    private final static @org.jetbrains.annotations.Nullable method suspendThere$$forInline(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method suspendThere(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
 }

compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithoutStateMachine_1_2.txt

@@ -0,0 +1,36 @@
+@kotlin.Metadata
+final class InlineWithoutStateMachineKt$box$1 {
+    synthetic final field $result: kotlin.jvm.internal.Ref$ObjectRef
+    field L$0: java.lang.Object
+    field L$1: java.lang.Object
+    inner class InlineWithoutStateMachineKt$box$1
+    method <init>(p0: kotlin.jvm.internal.Ref$ObjectRef, p1: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): kotlin.coroutines.experimental.Continuation
+    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): java.lang.Object
+    public synthetic method invoke(p0: java.lang.Object): java.lang.Object
+}
+
+@kotlin.Metadata
+final class InlineWithoutStateMachineKt$complexSuspend$1 {
+    field L$0: java.lang.Object
+    synthetic field data: java.lang.Object
+    synthetic field exception: java.lang.Throwable
+    inner class InlineWithoutStateMachineKt$complexSuspend$1
+    method <init>(p0: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    synthetic final method getLabel(): int
+    synthetic final method setLabel(p0: int): void
+}
+
+@kotlin.Metadata
+public final class InlineWithoutStateMachineKt {
+    inner class InlineWithoutStateMachineKt$box$1
+    inner class InlineWithoutStateMachineKt$complexSuspend$1
+    public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
+    public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void
+    public final static @org.jetbrains.annotations.Nullable method complexSuspend(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method suspendHere(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): java.lang.Object
+    private final static @org.jetbrains.annotations.Nullable method suspendThere$$forInline(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method suspendThere(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+}

compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple.txt

@@ -2,12 +2,13 @@
 final class SimpleKt$box$1 {
     synthetic final field $result: kotlin.jvm.internal.Ref$ObjectRef
     field L$0: java.lang.Object
+    field label: int
     inner class SimpleKt$box$1
-    method <init>(p0: kotlin.jvm.internal.Ref$ObjectRef, p1: COROUTINES_PACKAGE.Continuation): void
-    public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): COROUTINES_PACKAGE.Continuation
-    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    method <init>(p0: kotlin.jvm.internal.Ref$ObjectRef, p1: kotlin.coroutines.Continuation): void
+    public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation
+    public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object
     public synthetic method invoke(p0: java.lang.Object): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -15,6 +16,6 @@ public final class SimpleKt {
     inner class SimpleKt$box$1
     public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
     public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void
-    public final static @org.jetbrains.annotations.Nullable method suspendHere(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object
-    public final static @org.jetbrains.annotations.Nullable method suspendThere(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method suspendHere(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method suspendThere(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
 }

compiler/testData/codegen/box/coroutines/tailCallOptimizations/simple_1_2.txt

@@ -0,0 +1,20 @@
+@kotlin.Metadata
+final class SimpleKt$box$1 {
+    synthetic final field $result: kotlin.jvm.internal.Ref$ObjectRef
+    field L$0: java.lang.Object
+    inner class SimpleKt$box$1
+    method <init>(p0: kotlin.jvm.internal.Ref$ObjectRef, p1: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): kotlin.coroutines.experimental.Continuation
+    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): java.lang.Object
+    public synthetic method invoke(p0: java.lang.Object): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class SimpleKt {
+    inner class SimpleKt$box$1
+    public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
+    public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void
+    public final static @org.jetbrains.annotations.Nullable method suspendHere(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method suspendThere(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+}

compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit.txt

@@ -1,11 +1,12 @@
 @kotlin.Metadata
 final class WhenUnitKt$box$1 {
+    field label: int
     inner class WhenUnitKt$box$1
-    method <init>(p0: COROUTINES_PACKAGE.Continuation): void
-    public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): COROUTINES_PACKAGE.Continuation
-    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    method <init>(p0: kotlin.coroutines.Continuation): void
+    public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation
+    public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object
     public synthetic method invoke(p0: java.lang.Object): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -16,9 +17,9 @@ public final class WhenUnitKt {
     public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
     public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void
     public final static @org.jetbrains.annotations.NotNull method getLog(): java.lang.String
-    public final static @org.jetbrains.annotations.Nullable method process(@org.jetbrains.annotations.NotNull p0: X$A, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
-    public final static @org.jetbrains.annotations.Nullable method process(@org.jetbrains.annotations.NotNull p0: X$B, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
-    public final static @org.jetbrains.annotations.Nullable method process(@org.jetbrains.annotations.NotNull p0: X, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method process(@org.jetbrains.annotations.NotNull p0: X$A, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method process(@org.jetbrains.annotations.NotNull p0: X$B, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method process(@org.jetbrains.annotations.NotNull p0: X, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
     public final static method setLog(@org.jetbrains.annotations.NotNull p0: java.lang.String): void
 }
 

compiler/testData/codegen/box/coroutines/tailCallOptimizations/whenUnit_1_2.txt

@@ -0,0 +1,43 @@
+@kotlin.Metadata
+final class WhenUnitKt$box$1 {
+    inner class WhenUnitKt$box$1
+    method <init>(p0: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): kotlin.coroutines.experimental.Continuation
+    public final @org.jetbrains.annotations.Nullable method doResume(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.Nullable p1: java.lang.Throwable): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.experimental.Continuation): java.lang.Object
+    public synthetic method invoke(p0: java.lang.Object): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class WhenUnitKt {
+    private static @org.jetbrains.annotations.NotNull field log: java.lang.String
+    inner class WhenUnitKt$box$1
+    static method <clinit>(): void
+    public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
+    public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void
+    public final static @org.jetbrains.annotations.NotNull method getLog(): java.lang.String
+    public final static @org.jetbrains.annotations.Nullable method process(@org.jetbrains.annotations.NotNull p0: X$A, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method process(@org.jetbrains.annotations.NotNull p0: X$B, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method process(@org.jetbrains.annotations.NotNull p0: X, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+    public final static method setLog(@org.jetbrains.annotations.NotNull p0: java.lang.String): void
+}
+
+@kotlin.Metadata
+public final class X$A {
+    inner class X$A
+    public method <init>(): void
+}
+
+@kotlin.Metadata
+public final class X$B {
+    inner class X$B
+    public method <init>(): void
+}
+
+@kotlin.Metadata
+public abstract class X {
+    inner class X$A
+    inner class X$B
+    private method <init>(): void
+    public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
+}

compiler/testData/codegen/box/coroutines/tailOperations/tailInlining.kt

@@ -39,7 +39,7 @@ suspend fun bar(x: Int): Int = suspendCoroutine { c ->
 inline suspend fun foo(x: Int) = bar(x)
 
 fun async(a: suspend () -> Unit) {
-    a.startCoroutine(object : Continuation<Unit> {
+    a.startCoroutine(object : ContinuationAdapter<Unit>() {
         override fun resume(value: Unit) {
             proceed = {
                 log("done")

compiler/testData/codegen/box/coroutines/unitTypeReturn/coroutineNonLocalReturn.kt

@@ -13,7 +13,7 @@ suspend fun suspendHere(): String = suspendCoroutineOrReturn { x ->
 
 fun builder(c: suspend () -> Unit) {
     var wasResumeCalled = false
-    c.startCoroutine(object : Continuation<Unit> {
+    c.startCoroutine(object : ContinuationAdapter<Unit>() {
         override val context = EmptyCoroutineContext
 
         override fun resume(value: Unit) {

compiler/testData/codegen/box/coroutines/unitTypeReturn/coroutineReturn.kt

@@ -13,7 +13,7 @@ suspend fun suspendHere(): String = suspendCoroutineOrReturn { x ->
 
 fun builder(c: suspend () -> Unit) {
     var wasResumeCalled = false
-    c.startCoroutine(object : Continuation<Unit> {
+    c.startCoroutine(object : ContinuationAdapter<Unit>() {
         override val context = EmptyCoroutineContext
 
         override fun resume(value: Unit) {

compiler/testData/codegen/boxInline/suspend/capturedVariables.kt

@@ -1,8 +1,10 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 suspend inline fun test1(c: suspend () -> Unit) {
     c()
@@ -18,19 +20,10 @@ suspend inline fun test2(crossinline c: suspend () -> Unit) {
 
 import COROUTINES_PACKAGE.*
 import COROUTINES_PACKAGE.intrinsics.*
+import helpers.*
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 suspend fun calculate() = suspendCoroutineOrReturn<String> {

compiler/testData/codegen/boxInline/suspend/crossinlineSuspendLambdaInsideCrossinlineSuspendLambda.kt

@@ -1,8 +1,10 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 inline suspend fun foo(crossinline a: suspend () -> Unit, crossinline b: suspend () -> Unit) {
     var x = "OK"
@@ -15,17 +17,7 @@ inline suspend fun bar(crossinline l: suspend () -> Unit) {
 }
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 // FILE: box.kt

compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultValueCrossinline.kt

@@ -1,9 +1,11 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 class Controller {
     var res = "FAIL 1"
@@ -39,19 +41,10 @@ suspend inline fun test3(controller: Controller = defaultController, crossinline
 // COMMON_COROUTINES_TEST
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 suspend fun calculate() = "OK"

compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultValueInline.kt

@@ -1,9 +1,11 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 class Controller {
     var res = "FAIL 1"
@@ -19,19 +21,10 @@ suspend inline fun test(controller: Controller = defaultController, c: suspend C
 // COMMON_COROUTINES_TEST
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 suspend fun calculate() = "OK"

compiler/testData/codegen/boxInline/suspend/inlineOrdinaryOfCrossinlineSuspend.kt

@@ -1,8 +1,10 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 // Block is allowed to be called from nested classes/lambdas (as common crossinlines)
 // Are suspend calls possible inside lambda matching to the parameter
@@ -26,17 +28,7 @@ inline fun test2(crossinline c: suspend () -> Unit) {
 }
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 // FILE: box.kt

compiler/testData/codegen/boxInline/suspend/inlineOrdinaryOfNoinlineSuspend.kt

@@ -1,8 +1,10 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 // Block is allowed to be called from nested classes/lambdas (as common crossinlines)
 // Start coroutine call is possible
@@ -13,18 +15,6 @@ inline fun test1(noinline c: suspend () -> Unit)  {
     builder { l() }
 }
 
-val EmptyContinuation = object: Continuation<Unit> {
-    override val context: CoroutineContext
-        get() = EmptyCoroutineContext
-
-    override fun resume(value: Unit) {
-    }
-
-    override fun resumeWithException(exception: Throwable) {
-        throw exception
-    }
-}
-
 inline fun test2(noinline c: suspend () -> Unit) {
     c.startCoroutine(EmptyContinuation)
 }

compiler/testData/codegen/boxInline/suspend/inlineSuspendContinuation.kt

@@ -1,6 +1,7 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 suspend inline fun test1(c: () -> Unit) {
@@ -38,19 +39,9 @@ suspend inline fun test5(crossinline c: suspend() -> Unit) {
 
 import COROUTINES_PACKAGE.*
 import COROUTINES_PACKAGE.intrinsics.*
+import helpers.*
 import COROUTINES_PACKAGE.jvm.internal.*
 
-object EmptyContinuation: Continuation<Unit> {
-    override val context: CoroutineContext
-        get() = EmptyCoroutineContext
-
-    override fun resume(value: Unit) {
-    }
-
-    override fun resumeWithException(exception: Throwable) {
-        throw exception
-    }
-}
 
 fun builder(c: suspend () -> Unit) {
     c.startCoroutine(EmptyContinuation)

compiler/testData/codegen/boxInline/suspend/inlineSuspendOfCrossinlineOrdinary.kt

@@ -1,8 +1,10 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 // Block is allowed to be called inside the body of owner inline function
 // Block is allowed to be called from nested classes/lambdas (as common crossinlines)
@@ -30,23 +32,14 @@ inline fun transform(crossinline c: suspend () -> Unit) {
 }
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 // FILE: box.kt
 // COMMON_COROUTINES_TEST
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 fun box() : String {
     var res = "FAIL 1"

compiler/testData/codegen/boxInline/suspend/inlineSuspendOfCrossinlineSuspend.kt

@@ -1,8 +1,10 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 // Block is allowed to be called inside the body of owner inline function
 // Block is allowed to be called from nested classes/lambdas (as common crossinlines)
@@ -34,19 +36,10 @@ suspend inline fun test3(crossinline c: suspend () -> Unit) {
 // COMMON_COROUTINES_TEST
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 suspend fun calculate() = "OK"

compiler/testData/codegen/boxInline/suspend/inlineSuspendOfNoinlineOrdinary.kt

@@ -1,8 +1,10 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 // Block is allowed to be called inside the body of owner inline function
 // Block is allowed to be called from nested classes/lambdas (as common crossinlines)
@@ -30,23 +32,14 @@ inline fun transform(crossinline c: suspend () -> Unit) {
 }
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 // FILE: box.kt
 // COMMON_COROUTINES_TEST
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 fun box() : String {
     var res = "FAIL 1"

compiler/testData/codegen/boxInline/suspend/inlineSuspendOfNoinlineSuspend.kt

@@ -1,8 +1,10 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 // Block is allowed to be called from nested classes/lambdas (as common crossinlines)
 // Are suspend calls possible inside lambda matching to the parameter
@@ -14,17 +16,6 @@ suspend inline fun test1(noinline c: suspend () -> Unit)  {
     builder { l() }
 }
 
-object EmptyContinuation: Continuation<Unit> {
-    override val context: CoroutineContext
-        get() = EmptyCoroutineContext
-
-    override fun resume(value: Unit) {
-    }
-
-    override fun resumeWithException(exception: Throwable) {
-        throw exception
-    }
-}
 
 suspend inline fun test2(noinline c: suspend () -> Unit) {
     c.startCoroutine(EmptyContinuation)
@@ -55,6 +46,7 @@ suspend inline fun test4(noinline c: suspend () -> Unit) {
 // COMMON_COROUTINES_TEST
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 suspend fun calculate() = "OK"
 

compiler/testData/codegen/boxInline/suspend/inlineSuspendOfOrdinary.kt

@@ -1,9 +1,11 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 // Block is allowed to be called inside the body of owner inline function
 // suspend calls possible inside lambda matching to the parameter
@@ -13,17 +15,7 @@ suspend inline fun test(c: () -> Unit) {
 }
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 inline fun transform(crossinline c: suspend () -> Unit) {
@@ -34,6 +26,7 @@ inline fun transform(crossinline c: suspend () -> Unit) {
 // COMMON_COROUTINES_TEST
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 suspend fun calculate() = "OK"
 

compiler/testData/codegen/boxInline/suspend/inlineSuspendOfSuspend.kt

@@ -1,9 +1,11 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 // Block is allowed to be called inside the body of owner inline function
 // suspend calls possible inside lambda matching to the parameter
@@ -16,19 +18,10 @@ suspend inline fun test(c: suspend () -> Unit) {
 // COMMON_COROUTINES_TEST
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 suspend fun calculate() = "OK"

compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline/inlineOnly.kt

@@ -1,6 +1,7 @@
 // IGNORE_BACKEND: JVM_IR
 // FILE: inlined.kt
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 import kotlin.coroutines.experimental.*
@@ -33,7 +34,7 @@ import kotlin.coroutines.experimental.*
 import kotlin.coroutines.experimental.intrinsics.*
 
 fun builder(c: suspend () -> Unit) {
-    val continuation = object: Continuation<Unit> {
+    val continuation = object: helpers.ContinuationAdapter<Unit>() {
         override val context: CoroutineContext
             get() = EmptyCoroutineContext
 
@@ -69,4 +70,4 @@ fun box(): String {
     proceed()
     if (!finished) return "resume on root continuation is not called"
     return result
-}
+}

compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline/simpleNamed.kt

@@ -1,6 +1,7 @@
 // IGNORE_BACKEND: JVM_IR
 // FILE: inlined.kt
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 import kotlin.coroutines.experimental.*
@@ -31,7 +32,7 @@ import kotlin.coroutines.experimental.*
 import kotlin.coroutines.experimental.intrinsics.*
 
 fun builder(c: suspend () -> Unit) {
-    val continuation = object: Continuation<Unit> {
+    val continuation = object: helpers.ContinuationAdapter<Unit>() {
         override val context: CoroutineContext
             get() = EmptyCoroutineContext
 
@@ -67,4 +68,4 @@ fun box(): String {
     proceed()
     if (!finished) return "resume on root continuation is not called"
     return result
-}
+}

compiler/testData/codegen/boxInline/suspend/multipleLocals.kt

@@ -1,6 +1,7 @@
 // FILE: inlined.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 object Result {
@@ -58,19 +59,10 @@ suspend inline fun crossinlineMe(crossinline c: suspend () -> Unit) {
 // COMMON_COROUTINES_TEST
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 suspend fun dummy() {

compiler/testData/codegen/boxInline/suspend/multipleSuspensionPoints.kt

@@ -1,6 +1,7 @@
 // FILE: inlined.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 suspend inline fun inlineMe(c: suspend () -> Unit) {
@@ -29,19 +30,10 @@ suspend inline fun crossinlineMe(crossinline c: suspend () -> Unit) {
 // COMMON_COROUTINES_TEST
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 var i = 0;

compiler/testData/codegen/boxInline/suspend/receiver/inlineOrdinaryOfCrossinlineSuspend.kt

@@ -1,8 +1,10 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 // Block is allowed to be called from nested classes/lambdas (as common crossinlines)
 // Are suspend calls possible inside lambda matching to the parameter
@@ -30,17 +32,7 @@ class Controller {
 }
 
 fun builder(controller: Controller, c: suspend Controller.() -> Unit) {
-    c.startCoroutine(controller, object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(controller, EmptyContinuation)
 }
 
 // FILE: box.kt

compiler/testData/codegen/boxInline/suspend/receiver/inlineOrdinaryOfNoinlineSuspend.kt

@@ -1,8 +1,10 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 // Block is allowed to be called from nested classes/lambdas (as common crossinlines)
 // Start coroutine call is possible
@@ -12,18 +14,6 @@ interface SuspendRunnable {
     suspend fun run()
 }
 
-val EmptyContinuation = object: Continuation<Unit> {
-    override val context: CoroutineContext
-        get() = EmptyCoroutineContext
-
-    override fun resume(value: Unit) {
-    }
-
-    override fun resumeWithException(exception: Throwable) {
-        throw exception
-    }
-}
-
 class Controller {
     var res = "FAIL 1"
 

compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfCrossinlineOrdinary.kt

@@ -1,8 +1,10 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 // Block is allowed to be called inside the body of owner inline function
 // Block is allowed to be called from nested classes/lambdas (as common crossinlines)
@@ -34,23 +36,14 @@ class Controller {
 }
 
 fun builder(controller : Controller, c: suspend Controller.() -> Unit) {
-    c.startCoroutine(controller, object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(controller, EmptyContinuation)
 }
 
 // FILE: box.kt
 // COMMON_COROUTINES_TEST
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 fun box() : String {
     val controller = Controller()

compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfCrossinlineSuspend.kt

@@ -1,8 +1,10 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 // Block is allowed to be called inside the body of owner inline function
 // Block is allowed to be called from nested classes/lambdas (as common crossinlines)
@@ -38,19 +40,10 @@ class Controller {
 // COMMON_COROUTINES_TEST
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 fun builder(controller: Controller, c: suspend Controller.() -> Unit) {
-    c.startCoroutine(controller, object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(controller, EmptyContinuation)
 }
 
 suspend fun calculate() = "OK"

compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfNoinlineOrdinary.kt

@@ -1,8 +1,10 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 // Block is allowed to be called inside the body of owner inline function
 // Block is allowed to be called from nested classes/lambdas (as common crossinlines)
@@ -34,23 +36,14 @@ class Controller {
 }
 
 fun builder(controller: Controller, c: suspend Controller.() -> Unit) {
-    c.startCoroutine(controller, object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(controller, EmptyContinuation)
 }
 
 // FILE: box.kt
 // COMMON_COROUTINES_TEST
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 fun box() : String {
     val controller = Controller()

compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfNoinlineSuspend.kt

@@ -1,8 +1,10 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 // Block is allowed to be called from nested classes/lambdas (as common crossinlines)
 // Are suspend calls possible inside lambda matching to the parameter
@@ -13,17 +15,6 @@ interface SuspendRunnable {
     suspend fun run()
 }
 
-object EmptyContinuation: Continuation<Unit> {
-    override val context: CoroutineContext
-        get() = EmptyCoroutineContext
-
-    override fun resume(value: Unit) {
-    }
-
-    override fun resumeWithException(exception: Throwable) {
-        throw exception
-    }
-}
 
 class Controller {
     var res = "FAIL 1"
@@ -59,6 +50,7 @@ fun builder(controller: Controller, c: suspend Controller.() -> Unit) {
 // COMMON_COROUTINES_TEST
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 suspend fun calculate() = "OK"
 

compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfOrdinary.kt

@@ -1,9 +1,11 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 // Block is allowed to be called inside the body of owner inline function
 // suspend calls possible inside lambda matching to the parameter
@@ -21,23 +23,14 @@ class Controller {
 }
 
 fun builder(controller: Controller, c: suspend Controller.() -> Unit) {
-    c.startCoroutine(controller, object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(controller, EmptyContinuation)
 }
 
 // FILE: box.kt
 // COMMON_COROUTINES_TEST
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 suspend fun calculate() = "OK"
 

compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfSuspend.kt

@@ -1,9 +1,11 @@
 // FILE: test.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 // Block is allowed to be called inside the body of owner inline function
 // suspend calls possible inside lambda matching to the parameter
@@ -20,19 +22,10 @@ class Controller {
 // COMMON_COROUTINES_TEST
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 fun builder(controller: Controller, c: suspend Controller.() -> Unit) {
-    c.startCoroutine(controller, object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(controller, EmptyContinuation)
 }
 
 suspend fun calculate() = "OK"

compiler/testData/codegen/boxInline/suspend/returnValue.kt

@@ -1,9 +1,11 @@
 // FILE: inlined.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 import COROUTINES_PACKAGE.*
 import COROUTINES_PACKAGE.intrinsics.*
+import helpers.*
 
 inline suspend fun suspendThere(v: String): String = suspendCoroutineOrReturn { x ->
     x.resume(v)
@@ -20,19 +22,10 @@ suspend inline fun complexSuspend(crossinline c: suspend () -> String): String {
 // COMMON_COROUTINES_TEST
 import COROUTINES_PACKAGE.*
 import COROUTINES_PACKAGE.intrinsics.*
+import helpers.*
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 suspend fun suspendHere(): String = suspendThere("O")

compiler/testData/codegen/boxInline/suspend/stateMachine/innerLambda.kt

@@ -1,6 +1,7 @@
 // FILE: inlined.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 suspend inline fun crossinlineMe(crossinline c: suspend () -> Unit) {
@@ -13,19 +14,10 @@ suspend inline fun crossinlineMe(crossinline c: suspend () -> Unit) {
 
 import COROUTINES_PACKAGE.*
 import COROUTINES_PACKAGE.intrinsics.*
+import helpers.*
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 var i = 0;

compiler/testData/codegen/boxInline/suspend/stateMachine/innerLambdaInsideLambda.kt

@@ -1,6 +1,7 @@
 // FILE: inlined.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 suspend inline fun crossinlineMe(crossinline c: suspend () -> Unit) {
@@ -18,19 +19,10 @@ suspend inline fun crossinlineMe(crossinline c: suspend () -> Unit) {
 
 import COROUTINES_PACKAGE.*
 import COROUTINES_PACKAGE.intrinsics.*
+import helpers.*
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 var i = 0;

compiler/testData/codegen/boxInline/suspend/stateMachine/innerLambdaWithoutCrossinline.kt

@@ -1,9 +1,11 @@
 // FILE: inlined.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 import COROUTINES_PACKAGE.intrinsics.*
+import helpers.*
 
 var i = 0;
 
@@ -27,19 +29,10 @@ suspend inline fun crossinlineMe(crossinline c: suspend () -> Unit) {
 // COMMON_COROUTINES_TEST
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 fun box(): String {

compiler/testData/codegen/boxInline/suspend/stateMachine/innerMadness.kt

@@ -1,6 +1,7 @@
 // FILE: inlined.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 interface SuspendRunnable {
@@ -40,19 +41,10 @@ suspend inline fun crossinlineMe(crossinline c: suspend () -> Unit) {
 
 import COROUTINES_PACKAGE.*
 import COROUTINES_PACKAGE.intrinsics.*
+import helpers.*
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 var i = 0;

compiler/testData/codegen/boxInline/suspend/stateMachine/innerMadnessCallSite.kt

@@ -1,6 +1,7 @@
 // FILE: inlined.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 interface SuspendRunnable {
@@ -19,19 +20,10 @@ suspend inline fun crossinlineMe(crossinline c: suspend () -> Unit) {
 
 import COROUTINES_PACKAGE.*
 import COROUTINES_PACKAGE.intrinsics.*
+import helpers.*
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 var i = 0;

compiler/testData/codegen/boxInline/suspend/stateMachine/innerObject.kt

@@ -1,6 +1,7 @@
 // FILE: inlined.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 interface SuspendRunnable {
@@ -21,19 +22,10 @@ suspend inline fun crossinlineMe(crossinline c: suspend () -> Unit) {
 
 import COROUTINES_PACKAGE.*
 import COROUTINES_PACKAGE.intrinsics.*
+import helpers.*
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 var i = 0;

compiler/testData/codegen/boxInline/suspend/stateMachine/innerObjectInsideInnerObject.kt

@@ -1,6 +1,7 @@
 // FILE: inlined.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 interface SuspendRunnable {
@@ -26,19 +27,10 @@ suspend inline fun crossinlineMe(crossinline c: suspend () -> Unit) {
 
 import COROUTINES_PACKAGE.*
 import COROUTINES_PACKAGE.intrinsics.*
+import helpers.*
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 var i = 0;

compiler/testData/codegen/boxInline/suspend/stateMachine/innerObjectSeveralFunctions.kt

@@ -1,6 +1,7 @@
 // FILE: inlined.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 interface SuspendRunnable {
@@ -26,19 +27,10 @@ suspend inline fun crossinlineMe(crossinline c1: suspend () -> Unit, crossinline
 
 import COROUTINES_PACKAGE.*
 import COROUTINES_PACKAGE.intrinsics.*
+import helpers.*
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 var i = 0;

compiler/testData/codegen/boxInline/suspend/stateMachine/innerObjectWithoutCapturingCrossinline.kt

@@ -1,9 +1,11 @@
 // FILE: inlined.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 import COROUTINES_PACKAGE.intrinsics.*
+import helpers.*
 
 var i = 0;
 
@@ -33,19 +35,10 @@ suspend inline fun crossinlineMe(crossinline c: suspend () -> Unit) {
 // COMMON_COROUTINES_TEST
 
 import COROUTINES_PACKAGE.*
+import helpers.*
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 fun box(): String {

compiler/testData/codegen/boxInline/suspend/stateMachine/normalInline.kt

@@ -1,6 +1,7 @@
 // FILE: inlined.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 suspend inline fun crossinlineMe(crossinline c: suspend () -> Unit) {
@@ -13,19 +14,10 @@ suspend inline fun crossinlineMe(crossinline c: suspend () -> Unit) {
 
 import COROUTINES_PACKAGE.*
 import COROUTINES_PACKAGE.intrinsics.*
+import helpers.*
 
 fun builder(c: suspend () -> Unit) {
-    c.startCoroutine(object: Continuation<Unit> {
-        override val context: CoroutineContext
-            get() = EmptyCoroutineContext
-
-        override fun resume(value: Unit) {
-        }
-
-        override fun resumeWithException(exception: Throwable) {
-            throw exception
-        }
-    })
+    c.startCoroutine(EmptyContinuation)
 }
 
 var i = 0;

compiler/testData/codegen/boxInline/suspend/stateMachine/numberOfSuspentions.kt

@@ -1,6 +1,7 @@
 // FILE: inlined.kt
 // COMMON_COROUTINES_TEST
 // WITH_RUNTIME
+// WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING
 
 suspend inline fun crossinlineMe(crossinline c: suspend () -> Unit) {
@@ -17,6 +18,7 @@ suspend inline fun crossinlineMe2(crossinline c: suspend () -> Unit) {
 
 import COROUTINES_PACKAGE.*
 import COROUTINES_PACKAGE.intrinsics.*
+import helpers.*
 
 var result = "FAIL"
 var i = 0
@@ -30,7 +32,7 @@ suspend fun suspendHere() = suspendCoroutine<Unit> { c ->
 }
 
 fun builder(c: suspend () -> Unit) {
-    val continuation = object: Continuation<Unit> {
+    val continuation = object: ContinuationAdapter<Unit>() {
         override val context: CoroutineContext
             get() = EmptyCoroutineContext
 
@@ -67,4 +69,4 @@ fun box(): String {
     proceed()
     if (!finished) return "resume on root continuation is not called"
     return result
-}
+}