Get rid of typed create and invoke wherever possible

in coroutine lambdas.
 #KT-26243 Fixed

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
  * that can be found in the license/LICENSE.txt file.
  */
 
@@ -37,6 +37,7 @@ import org.jetbrains.kotlin.resolve.InlineClassesUtilsKt;
 import org.jetbrains.kotlin.resolve.annotations.AnnotationUtilKt;
 import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker;
 import org.jetbrains.kotlin.resolve.inline.InlineUtil;
+import org.jetbrains.kotlin.resolve.jvm.AsmTypes;
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName;
 import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType;
 import org.jetbrains.kotlin.resolve.jvm.RuntimeAssertionInfo;
@@ -504,19 +505,25 @@ public class AsmUtil {
     }
 
     public static int genAssignInstanceFieldFromParam(FieldInfo info, int index, InstructionAdapter iv) {
-        return genAssignInstanceFieldFromParam(info, index, iv, 0);
+        return genAssignInstanceFieldFromParam(info, index, iv, 0, false);
     }
 
     public static int genAssignInstanceFieldFromParam(
             FieldInfo info,
             int index,
             InstructionAdapter iv,
-            int ownerIndex
+            int ownerIndex,
+            boolean cast
     ) {
         assert !info.isStatic();
         Type fieldType = info.getFieldType();
         iv.load(ownerIndex, info.getOwnerType());//this
-        iv.load(index, fieldType); //param
+        if (cast) {
+            iv.load(index, AsmTypes.OBJECT_TYPE); //param
+            StackValue.coerce(AsmTypes.OBJECT_TYPE, fieldType, iv);
+        } else {
+            iv.load(index, fieldType); //param
+        }
         iv.visitFieldInsn(PUTFIELD, info.getOwnerInternalName(), info.getFieldName(), fieldType.getDescriptor());
         index += fieldType.getSize();
         return index;

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

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.codegen.binding.CodegenBinding
 import org.jetbrains.kotlin.codegen.binding.CodegenBinding.CAPTURES_CROSSINLINE_SUSPEND_LAMBDA
 import org.jetbrains.kotlin.codegen.context.ClosureContext
 import org.jetbrains.kotlin.codegen.context.MethodContext
+import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.METHOD_FOR_FUNCTION
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializerExtension
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.isReleaseCoroutines
@@ -19,6 +20,7 @@ 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.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtCallableReferenceExpression
@@ -165,9 +167,17 @@ class CoroutineCodegenForLambda private constructor(
 
     private val constructorCallNormalizationMode = outerExpressionCodegen.state.constructorCallNormalizationMode
 
+    private val erasedInvokeFunction by lazy {
+        getErasedInvokeFunction(funDescriptor).createCustomCopy { setModality(Modality.FINAL) }
+    }
+
     private lateinit var constructorToUseFromInvoke: Method
 
-    private val createCoroutineDescriptor = SimpleFunctionDescriptorImpl.create(
+    private val createCoroutineDescriptor by lazy {
+        if (generateErasedCreate) getErasedCreateFunction() else getCreateFunction()
+    }
+
+    private fun getCreateFunction(): SimpleFunctionDescriptor = SimpleFunctionDescriptorImpl.create(
         funDescriptor.containingDeclaration,
         Annotations.EMPTY,
         Name.identifier(SUSPEND_FUNCTION_CREATE_METHOD_NAME),
@@ -188,6 +198,28 @@ class CoroutineCodegenForLambda private constructor(
         )
     }
 
+    private fun getErasedCreateFunction(): SimpleFunctionDescriptor {
+        val typedCreate = getCreateFunction()
+        assert(generateErasedCreate) { "cannot create erased create function: $typedCreate" }
+        val argumentsNum = typeMapper.mapSignatureSkipGeneric(typedCreate).asmMethod.argumentTypes.size
+        assert(argumentsNum == 1 || argumentsNum == 2) {
+            "too many arguments of create to have an erased signature: $argumentsNum: $typedCreate"
+        }
+        return typedCreate.module.resolveClassByFqName(
+            languageVersionSettings.coroutinesJvmInternalPackageFqName().child(
+                if (languageVersionSettings.isReleaseCoroutines())
+                    Name.identifier("BaseContinuationImpl")
+                else
+                    Name.identifier("CoroutineImpl")
+            ),
+            NoLookupLocation.FROM_BACKEND
+        ).sure { "BaseContinuationImpl or CoroutineImpl is not found" }.defaultType.memberScope
+            .getContributedFunctions(typedCreate.name, NoLookupLocation.FROM_BACKEND)
+            .find { it.valueParameters.size == argumentsNum }
+            .sure { "erased parent of $typedCreate is not found" }
+            .createCustomCopy { setModality(Modality.FINAL) }
+    }
+
     override fun generateClosureBody() {
         for (parameter in allFunctionParameters()) {
             val fieldInfo = parameter.getFieldInfoForCoroutineLambdaParameter()
@@ -202,9 +234,21 @@ class CoroutineCodegenForLambda private constructor(
         generateResumeImpl()
     }
 
+    private val generateErasedCreate: Boolean = allFunctionParameters().size <= 1
+
+    private val doNotGenerateInvokeBridge: Boolean = !originalSuspendFunctionDescriptor.isLocalSuspendFunctionNotSuspendLambda()
+
     override fun generateBody() {
         super.generateBody()
 
+        if (doNotGenerateInvokeBridge) {
+            v.serializationBindings.put<FunctionDescriptor, Method>(
+                METHOD_FOR_FUNCTION,
+                originalSuspendFunctionDescriptor,
+                typeMapper.mapAsmMethod(erasedInvokeFunction)
+            )
+        }
+
         // create() = ...
         functionCodegen.generateMethod(JvmDeclarationOrigin.NO_ORIGIN, createCoroutineDescriptor,
                                        object : FunctionGenerationStrategy.CodegenBased(state) {
@@ -213,39 +257,52 @@ class CoroutineCodegenForLambda private constructor(
                                            }
                                        })
 
-        // invoke(..) = create(..).resume(Unit)
+        if (doNotGenerateInvokeBridge) {
-        functionCodegen.generateMethod(JvmDeclarationOrigin.NO_ORIGIN, funDescriptor,
+            generateUntypedInvokeMethod()
-                                       object : FunctionGenerationStrategy.CodegenBased(state) {
+        } else {
-                                           override fun doGenerateBody(codegen: ExpressionCodegen, signature: JvmMethodSignature) {
+            // invoke(..) = create(..).resume(Unit)
-                                               codegen.v.generateInvokeMethod(signature)
+            functionCodegen.generateMethod(JvmDeclarationOrigin.NO_ORIGIN, funDescriptor,
-                                           }
+                                           object : FunctionGenerationStrategy.CodegenBased(state) {
-                                       })
+                                               override fun doGenerateBody(codegen: ExpressionCodegen, signature: JvmMethodSignature) {
-
+                                                   codegen.v.generateInvokeMethod(signature)
-        if (allFunctionParameters().size <= 1) {
+                                               }
-            val delegate = typeMapper.mapSignatureSkipGeneric(createCoroutineDescriptor).asmMethod
+                                           })
-
-            val bridgeParameterAsmTypes =
-                List(delegate.argumentTypes.size - 1) { AsmTypes.OBJECT_TYPE } + delegate.argumentTypes.last()
-
-            val bridgeParameterKotlinTypes =
-                List(delegate.argumentTypes.size - 1) { builtIns.nullableAnyType } + createCoroutineDescriptor.valueParameters.last().type
-
-            val bridge = Method(delegate.name, delegate.returnType, bridgeParameterAsmTypes.toTypedArray())
-
-            generateBridge(
-                bridge, bridgeParameterKotlinTypes, createCoroutineDescriptor.returnType,
-                delegate, createCoroutineDescriptor.returnType,
-                false
-            )
         }
     }
 
+    override fun generateBridges() {
+        if (!doNotGenerateInvokeBridge) {
+            super.generateBridges()
+        }
+    }
+
+    private fun generateUntypedInvokeMethod() {
+        val untypedDescriptor = getErasedInvokeFunction(funDescriptor)
+        val untypedAsmMethod = typeMapper.mapAsmMethod(untypedDescriptor)
+        val jvmMethodSignature = typeMapper.mapSignatureSkipGeneric(untypedDescriptor)
+        val mv = v.newMethod(
+            OtherOrigin(element, funDescriptor), AsmUtil.getVisibilityAccessFlag(untypedDescriptor) or Opcodes.ACC_FINAL,
+            untypedAsmMethod.name, untypedAsmMethod.descriptor, null, ArrayUtil.EMPTY_STRING_ARRAY
+        )
+        mv.visitCode()
+        with(InstructionAdapter(mv)) {
+            generateInvokeMethod(jvmMethodSignature)
+        }
+
+        FunctionCodegen.endVisit(mv, "invoke", element)
+    }
+
     private fun InstructionAdapter.generateInvokeMethod(signature: JvmMethodSignature) {
         // this
         load(0, AsmTypes.OBJECT_TYPE)
         val parameterTypes = signature.valueParameters.map { it.asmType }
-        parameterTypes.withVariableIndices().forEach { (index, type) ->
+        val createArgumentTypes =
-            load(index + 1, type)
+            if (generateErasedCreate || doNotGenerateInvokeBridge) typeMapper.mapAsmMethod(createCoroutineDescriptor).argumentTypes.asList()
+            else parameterTypes
+        var index = 0
+        parameterTypes.withVariableIndices().forEach { (varIndex, type) ->
+            load(varIndex + 1, type)
+            StackValue.coerce(type, createArgumentTypes[index++], this)
         }
 
         // this.create(..)
@@ -254,7 +311,7 @@ class CoroutineCodegenForLambda private constructor(
             createCoroutineDescriptor.name.identifier,
             Type.getMethodDescriptor(
                 languageVersionSettings.continuationAsmType(),
-                *parameterTypes.toTypedArray()
+                *createArgumentTypes.toTypedArray()
             ),
             false
         )
@@ -293,7 +350,11 @@ class CoroutineCodegenForLambda private constructor(
             }
 
             // load resultContinuation
-            load(allFunctionParameters().map { typeMapper.mapType(it.type).size }.sum() + 1, AsmTypes.OBJECT_TYPE)
+            if (generateErasedCreate) {
+                load(allFunctionParameters().size + 1, AsmTypes.OBJECT_TYPE)
+            } else {
+                load(allFunctionParameters().map { typeMapper.mapType(it.type).size }.sum() + 1, AsmTypes.OBJECT_TYPE)
+            }
 
             invokespecial(owner.internalName, constructorToUseFromInvoke.name, constructorToUseFromInvoke.descriptor, false)
 
@@ -304,8 +365,19 @@ class CoroutineCodegenForLambda private constructor(
             var index = 1
             for (parameter in allFunctionParameters()) {
                 val fieldInfoForCoroutineLambdaParameter = parameter.getFieldInfoForCoroutineLambdaParameter()
-                load(index, fieldInfoForCoroutineLambdaParameter.fieldType)
+                if (generateErasedCreate) {
-                AsmUtil.genAssignInstanceFieldFromParam(fieldInfoForCoroutineLambdaParameter, index, this, cloneIndex)
+                    load(index, AsmTypes.OBJECT_TYPE)
+                    StackValue.coerce(AsmTypes.OBJECT_TYPE, fieldInfoForCoroutineLambdaParameter.fieldType, this)
+                } else {
+                    load(index, fieldInfoForCoroutineLambdaParameter.fieldType)
+                }
+                AsmUtil.genAssignInstanceFieldFromParam(
+                    fieldInfoForCoroutineLambdaParameter,
+                    index,
+                    this,
+                    cloneIndex,
+                    generateErasedCreate
+                )
                 index += fieldInfoForCoroutineLambdaParameter.fieldType.size
             }
 

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

@@ -496,3 +496,5 @@ fun FunctionDescriptor.isSuspendLambdaOrLocalFunction() = this.isSuspend && when
     is SimpleFunctionDescriptor -> this.visibility == Visibilities.LOCAL
     else -> false
 }
+
+fun FunctionDescriptor.isLocalSuspendFunctionNotSuspendLambda() = isSuspendLambdaOrLocalFunction() && this !is AnonymousFunctionDescriptor

compiler/testData/codegen/box/coroutines/bridges/lambdaWithMultipleParameters.kt

@@ -0,0 +1,28 @@
+// IGNORE_BACKEND: JS_IR
+// IGNORE_BACKEND: JVM_IR
+// WITH_RUNTIME
+// WITH_COROUTINES
+// COMMON_COROUTINES_TEST
+// CHECK_BYTECODE_LISTING
+
+import helpers.*
+import COROUTINES_PACKAGE.*
+
+fun builder(c: suspend() -> Unit) {
+    c.startCoroutine(EmptyContinuation)
+}
+
+suspend fun call(c: suspend(String, Long, Long, Long, Long, Long) -> String): String {
+    return c("OK", 1, 2, 3, 4, 5)
+}
+
+fun box(): String {
+    var res = ""
+    builder {
+        res = call { a, b, c, d, e, f ->
+            "$a$b$c$d$e$f"
+        }
+    }
+    if (res != "OK12345") return res
+    return "OK"
+}

compiler/testData/codegen/box/coroutines/bridges/lambdaWithMultipleParameters.txt

@@ -0,0 +1,37 @@
+@kotlin.Metadata
+final class LambdaWithMultipleParametersKt$box$1$1 {
+    field label: int
+    private field p$0: java.lang.String
+    private field p$1: long
+    private field p$2: long
+    private field p$3: long
+    private field p$4: long
+    private field p$5: long
+    inner class LambdaWithMultipleParametersKt$box$1
+    inner class LambdaWithMultipleParametersKt$box$1$1
+    method <init>(p0: kotlin.coroutines.Continuation): void
+    public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: java.lang.String, p1: long, p2: long, p3: long, p4: long, p5: long, @org.jetbrains.annotations.NotNull p6: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation
+    public final method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object, p4: java.lang.Object, p5: java.lang.Object, p6: 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 LambdaWithMultipleParametersKt$box$1 {
+    synthetic final field $res: kotlin.jvm.internal.Ref$ObjectRef
+    field L$0: java.lang.Object
+    field label: int
+    inner class LambdaWithMultipleParametersKt$box$1
+    inner class LambdaWithMultipleParametersKt$box$1$1
+    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 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 LambdaWithMultipleParametersKt {
+    inner class LambdaWithMultipleParametersKt$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 call(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function7, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
+}

compiler/testData/codegen/box/coroutines/bridges/lambdaWithMultipleParameters_1_2.txt

@@ -0,0 +1,35 @@
+@kotlin.Metadata
+final class LambdaWithMultipleParametersKt$box$1$1 {
+    private field p$0: java.lang.String
+    private field p$1: long
+    private field p$2: long
+    private field p$3: long
+    private field p$4: long
+    private field p$5: long
+    inner class LambdaWithMultipleParametersKt$box$1
+    inner class LambdaWithMultipleParametersKt$box$1$1
+    method <init>(p0: kotlin.coroutines.experimental.Continuation): void
+    public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: java.lang.String, p1: long, p2: long, p3: long, p4: long, p5: long, @org.jetbrains.annotations.NotNull p6: 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 method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object, p4: java.lang.Object, p5: java.lang.Object, p6: java.lang.Object): java.lang.Object
+}
+
+@kotlin.Metadata
+final class LambdaWithMultipleParametersKt$box$1 {
+    synthetic final field $res: kotlin.jvm.internal.Ref$ObjectRef
+    field L$0: java.lang.Object
+    inner class LambdaWithMultipleParametersKt$box$1
+    inner class LambdaWithMultipleParametersKt$box$1$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 method invoke(p0: java.lang.Object): java.lang.Object
+}
+
+@kotlin.Metadata
+public final class LambdaWithMultipleParametersKt {
+    inner class LambdaWithMultipleParametersKt$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 call(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function7, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.experimental.Continuation): java.lang.Object
+}

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

@@ -147,8 +147,7 @@ final class CrossinlineKt$box$1 {
     inner class CrossinlineKt$box$1
     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 final method invoke(p0: java.lang.Object): 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
 }
 

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

@@ -157,8 +157,7 @@ final 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 final method invoke(p0: java.lang.Object): java.lang.Object
-    public synthetic method invoke(p0: java.lang.Object): java.lang.Object
 }
 
 @kotlin.Metadata

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

@@ -6,8 +6,7 @@ final class InlineWithStateMachineKt$box$1 {
     inner class InlineWithStateMachineKt$box$1
     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 final method invoke(p0: java.lang.Object): 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
 }
 

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

@@ -6,8 +6,7 @@ final 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 final method invoke(p0: java.lang.Object): java.lang.Object
-    public synthetic method invoke(p0: java.lang.Object): java.lang.Object
 }
 
 @kotlin.Metadata

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

@@ -7,8 +7,7 @@ final class InlineWithoutStateMachineKt$box$1 {
     inner class InlineWithoutStateMachineKt$box$1
     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 final method invoke(p0: java.lang.Object): 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
 }
 

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

@@ -7,8 +7,7 @@ final 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 final method invoke(p0: java.lang.Object): java.lang.Object
-    public synthetic method invoke(p0: java.lang.Object): java.lang.Object
 }
 
 @kotlin.Metadata

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

@@ -6,8 +6,7 @@ final class SimpleKt$box$1 {
     inner class SimpleKt$box$1
     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 final method invoke(p0: java.lang.Object): 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
 }
 

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

@@ -6,8 +6,7 @@ final 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 final method invoke(p0: java.lang.Object): java.lang.Object
-    public synthetic method invoke(p0: java.lang.Object): java.lang.Object
 }
 
 @kotlin.Metadata

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

@@ -4,8 +4,7 @@ final class WhenUnitKt$box$1 {
     inner class WhenUnitKt$box$1
     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 final method invoke(p0: java.lang.Object): 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
 }
 

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

@@ -4,8 +4,7 @@ final 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 final method invoke(p0: java.lang.Object): java.lang.Object
-    public synthetic method invoke(p0: java.lang.Object): java.lang.Object
 }
 
 @kotlin.Metadata

compiler/testData/codegen/bytecodeListing/coroutineFields.txt

@@ -44,11 +44,9 @@ final class CoroutineFieldsKt$box$1 {
     private field p$: Controller
     inner class CoroutineFieldsKt$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: Controller, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): COROUTINES_PACKAGE.Continuation
+    public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): COROUTINES_PACKAGE.Continuation
-    public synthetic method create(p0: java.lang.Object, p1: 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: Controller, @org.jetbrains.annotations.NotNull p1: COROUTINES_PACKAGE.Continuation): java.lang.Object
+    public final method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public synthetic method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
 }
 
 @kotlin.Metadata

compiler/testData/codegen/bytecodeListing/coroutineFields_1_3.txt

@@ -41,10 +41,8 @@ final class CoroutineFieldsKt$box$1 {
     private field p$: Controller
     inner class CoroutineFieldsKt$box$1
     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: Controller, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation
+    public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation
-    public synthetic method create(p0: java.lang.Object, p1: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation
+    public final method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: Controller, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object
-    public synthetic method invoke(p0: java.lang.Object, p1: 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
 }
 

compiler/testData/codegen/bytecodeListing/tailcall/tailSuspendUnitFun.txt

@@ -45,8 +45,7 @@ final class TailSuspendUnitFunKt$multipleExitPointsWhen$2 {
     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
+    public final method invoke(p0: java.lang.Object): java.lang.Object
-    public synthetic method invoke(p0: java.lang.Object): java.lang.Object
 }
 
 @kotlin.Metadata

compiler/testData/codegen/bytecodeListing/tailcall/tailSuspendUnitFun_1_3.txt

@@ -39,8 +39,7 @@ final class TailSuspendUnitFunKt$multipleExitPointsWhen$2 {
     inner class TailSuspendUnitFunKt$multipleExitPointsWhen$2
     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 final method invoke(p0: java.lang.Object): 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
 }
 

compiler/testData/codegen/bytecodeListing/tailcall/unreachable.txt

@@ -45,8 +45,7 @@ final class UnreachableKt$multipleExitPointsWhen$2 {
     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
+    public final method invoke(p0: java.lang.Object): java.lang.Object
-    public synthetic method invoke(p0: java.lang.Object): java.lang.Object
 }
 
 @kotlin.Metadata

compiler/testData/codegen/bytecodeListing/tailcall/unreachable_1_3.txt

@@ -39,8 +39,7 @@ final class UnreachableKt$multipleExitPointsWhen$2 {
     inner class UnreachableKt$multipleExitPointsWhen$2
     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 final method invoke(p0: java.lang.Object): 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
 }
 

compiler/testData/codegen/dumpDeclarations/suspendLambda.json

@@ -4,12 +4,11 @@
 		"visibility": "local",
 		"class": "SuspendLambdaKt$invokeCoroutineBuilder$1",
 		"members": [
-			{"visibility": "local",	"declaration": "final suspend fun kotlin.Any.<anonymous>(): kotlin.Unit", "name": "invoke", "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;"},
 			{"visibility": "local",	"declaration": "<this>", "name": "p$", "desc": "Ljava/lang/Object;"},
 			{"name": "doResume", "desc": "(Ljava/lang/Object;Ljava/lang/Throwable;)Ljava/lang/Object;"},
 			{"visibility": "local",	"declaration": "final suspend fun kotlin.Any.<anonymous>(): kotlin.Unit", "name": "<init>", "desc": "(Lkotlin/coroutines/experimental/Continuation;)V"},
 			{"name": "create", "desc": "(Ljava/lang/Object;Lkotlin/coroutines/experimental/Continuation;)Lkotlin/coroutines/experimental/Continuation;"},
-			{"name": "invoke", "desc": "(Ljava/lang/Object;Lkotlin/coroutines/experimental/Continuation;)Ljava/lang/Object;"}
+			{"visibility": "local",	"declaration": "final suspend fun kotlin.Any.<anonymous>(): kotlin.Unit", "name": "invoke", "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;"}
 		]
 	},
 	{

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

@@ -6190,6 +6190,33 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
             runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/varValueConflictsWithTable.kt", "kotlin.coroutines");
         }
 
+        @TestMetadata("compiler/testData/codegen/box/coroutines/bridges")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Bridges extends AbstractBlackBoxCodegenTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
+            }
+
+            private void runTestWithPackageReplacement(String testDataFilePath, String packageName) throws Exception {
+                KotlinTestUtils.runTest(filePath -> doTestWithCoroutinesPackageReplacement(filePath, packageName), TargetBackend.JVM, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInBridges() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
+            }
+
+            @TestMetadata("lambdaWithMultipleParameters.kt")
+            public void testLambdaWithMultipleParameters_1_2() throws Exception {
+                runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/bridges/lambdaWithMultipleParameters.kt", "kotlin.coroutines.experimental");
+            }
+
+            @TestMetadata("lambdaWithMultipleParameters.kt")
+            public void testLambdaWithMultipleParameters_1_3() throws Exception {
+                runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/bridges/lambdaWithMultipleParameters.kt", "kotlin.coroutines");
+            }
+        }
+
         @TestMetadata("compiler/testData/codegen/box/coroutines/controlFlow")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)

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

@@ -6190,6 +6190,33 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
             runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/varValueConflictsWithTable.kt", "kotlin.coroutines");
         }
 
+        @TestMetadata("compiler/testData/codegen/box/coroutines/bridges")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Bridges extends AbstractLightAnalysisModeTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath);
+            }
+
+            private void runTestWithPackageReplacement(String testDataFilePath, String packageName) throws Exception {
+                KotlinTestUtils.runTest(filePath -> doTestWithCoroutinesPackageReplacement(filePath, packageName), TargetBackend.JVM, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInBridges() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM, true);
+            }
+
+            @TestMetadata("lambdaWithMultipleParameters.kt")
+            public void testLambdaWithMultipleParameters_1_2() throws Exception {
+                runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/bridges/lambdaWithMultipleParameters.kt", "kotlin.coroutines.experimental");
+            }
+
+            @TestMetadata("lambdaWithMultipleParameters.kt")
+            public void testLambdaWithMultipleParameters_1_3() throws Exception {
+                runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/bridges/lambdaWithMultipleParameters.kt", "kotlin.coroutines");
+            }
+        }
+
         @TestMetadata("compiler/testData/codegen/box/coroutines/controlFlow")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)

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

@@ -6190,6 +6190,33 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
             runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/varValueConflictsWithTable.kt", "kotlin.coroutines");
         }
 
+        @TestMetadata("compiler/testData/codegen/box/coroutines/bridges")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Bridges extends AbstractIrBlackBoxCodegenTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            private void runTestWithPackageReplacement(String testDataFilePath, String packageName) throws Exception {
+                KotlinTestUtils.runTest(filePath -> doTestWithCoroutinesPackageReplacement(filePath, packageName), TargetBackend.JVM_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInBridges() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JVM_IR, true);
+            }
+
+            @TestMetadata("lambdaWithMultipleParameters.kt")
+            public void testLambdaWithMultipleParameters_1_2() throws Exception {
+                runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/bridges/lambdaWithMultipleParameters.kt", "kotlin.coroutines.experimental");
+            }
+
+            @TestMetadata("lambdaWithMultipleParameters.kt")
+            public void testLambdaWithMultipleParameters_1_3() throws Exception {
+                runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/bridges/lambdaWithMultipleParameters.kt", "kotlin.coroutines");
+            }
+        }
+
         @TestMetadata("compiler/testData/codegen/box/coroutines/controlFlow")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)

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

@@ -5485,6 +5485,28 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest {
             runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/varValueConflictsWithTable.kt", "kotlin.coroutines.experimental");
         }
 
+        @TestMetadata("compiler/testData/codegen/box/coroutines/bridges")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Bridges extends AbstractIrJsCodegenBoxTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS_IR, testDataFilePath);
+            }
+
+            private void runTestWithPackageReplacement(String testDataFilePath, String packageName) throws Exception {
+                KotlinTestUtils.runTest0(filePath -> doTestWithCoroutinesPackageReplacement(filePath, packageName), TargetBackend.JS_IR, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInBridges() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JS_IR, true);
+            }
+
+            @TestMetadata("lambdaWithMultipleParameters.kt")
+            public void testLambdaWithMultipleParameters_1_2() throws Exception {
+                runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/bridges/lambdaWithMultipleParameters.kt", "kotlin.coroutines.experimental");
+            }
+        }
+
         @TestMetadata("compiler/testData/codegen/box/coroutines/controlFlow")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)

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

@@ -5910,6 +5910,33 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest {
             runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/varValueConflictsWithTable.kt", "kotlin.coroutines");
         }
 
+        @TestMetadata("compiler/testData/codegen/box/coroutines/bridges")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(JUnit3RunnerWithInners.class)
+        public static class Bridges extends AbstractJsCodegenBoxTest {
+            private void runTest(String testDataFilePath) throws Exception {
+                KotlinTestUtils.runTest0(this::doTest, TargetBackend.JS, testDataFilePath);
+            }
+
+            private void runTestWithPackageReplacement(String testDataFilePath, String packageName) throws Exception {
+                KotlinTestUtils.runTest0(filePath -> doTestWithCoroutinesPackageReplacement(filePath, packageName), TargetBackend.JS, testDataFilePath);
+            }
+
+            public void testAllFilesPresentInBridges() throws Exception {
+                KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.JS, true);
+            }
+
+            @TestMetadata("lambdaWithMultipleParameters.kt")
+            public void testLambdaWithMultipleParameters_1_2() throws Exception {
+                runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/bridges/lambdaWithMultipleParameters.kt", "kotlin.coroutines.experimental");
+            }
+
+            @TestMetadata("lambdaWithMultipleParameters.kt")
+            public void testLambdaWithMultipleParameters_1_3() throws Exception {
+                runTestWithPackageReplacement("compiler/testData/codegen/box/coroutines/bridges/lambdaWithMultipleParameters.kt", "kotlin.coroutines");
+            }
+        }
+
         @TestMetadata("compiler/testData/codegen/box/coroutines/controlFlow")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)