Allow calling some pieces of the experimental coroutine API

- Calling suspend functions is allowed - Presence of suspend function type still makes declaration unusable unless it belongs to a value parameter as a top-level type containing less then three parameters Still, warning should be emitted because they will become unsupported in 1.4 #KT-25683 In Progress
2018-08-20 11:30:32 +03:00
parent c94b72680a
commit 944b0d058a
13 changed files with 272 additions and 89 deletions
@@ -44,6 +44,7 @@ import org.jetbrains.kotlin.resolve.constants.StringValue
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedMemberDescriptor
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedMemberDescriptor.CoroutinesCompatibilityMode.*
 import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeUtils
@@ -104,10 +105,14 @@ private data class DeprecatedByOverridden(private val deprecations: Collection<D
 }

 private data class DeprecatedExperimentalCoroutine(
-    override val target: DeclarationDescriptor
+    override val target: DeclarationDescriptor,
+    override val deprecationLevel: DeprecationLevelValue
 ) : Deprecation {
-    override val deprecationLevel: DeprecationLevelValue = DeprecationLevelValue.ERROR
-    override val message: String? = "Experimental coroutine cannot be used with API version 1.3"
+    override val message: String? =
+        if (deprecationLevel == WARNING)
+            "Experimental coroutines support will be dropped in 1.4"
+        else
+            "Experimental coroutine cannot be used with API version 1.3"
 }

 private data class DeprecatedByVersionRequirement(
@@ -300,7 +305,7 @@ class DeprecationResolver(

        fun addDeprecationIfPresent(target: DeclarationDescriptor) {
            val annotation = target.annotations.findAnnotation(KotlinBuiltIns.FQ_NAMES.deprecated)
-                    ?: target.annotations.findAnnotation(JAVA_DEPRECATED)
+                ?: target.annotations.findAnnotation(JAVA_DEPRECATED)
            if (annotation != null) {
                val deprecatedByAnnotation = DeprecatedByAnnotation(annotation, target)
                val deprecation = when (target) {
@@ -323,7 +328,7 @@ class DeprecationResolver(
                    useSiteTarget,
                    KotlinBuiltIns.FQ_NAMES.deprecated
                )
-                        ?: Annotations.findUseSiteTargetedAnnotation(annotatedDescriptor.annotations, useSiteTarget, JAVA_DEPRECATED)
+                    ?: Annotations.findUseSiteTargetedAnnotation(annotatedDescriptor.annotations, useSiteTarget, JAVA_DEPRECATED)
                if (annotation != null) {
                    result.add(DeprecatedByAnnotation(annotation, this))
                }
@@ -353,10 +358,14 @@ class DeprecationResolver(
        return result.distinct()
    }

-    private fun getDeprecationByCoroutinesVersion(target: DeclarationDescriptor): DeprecatedExperimentalCoroutine? =
-        if (target is DeserializedMemberDescriptor && target.isExperimentalCoroutineInReleaseEnvironment)
-            DeprecatedExperimentalCoroutine(target)
-        else null
+    private fun getDeprecationByCoroutinesVersion(target: DeclarationDescriptor): DeprecatedExperimentalCoroutine? {
+        if (target !is DeserializedMemberDescriptor) return null
+        return when (target.coroutinesExperimentalCompatibilityMode) {
+            COMPATIBLE -> null
+            NEEDS_WRAPPER -> DeprecatedExperimentalCoroutine(target, WARNING)
+            INCOMPATIBLE -> DeprecatedExperimentalCoroutine(target, ERROR)
+        }
+    }

    private fun getDeprecationByVersionRequirement(target: DeclarationDescriptor): List<DeprecatedByVersionRequirement> {
        fun createVersion(version: String): MavenComparableVersion? = try {
@@ -1,27 +1,14 @@
-suspend fun dummy() {}
-
-class C {
-    suspend fun dummy() = "OK"
-}
-
-class WithNested {
-    class Nested {
-        suspend fun dummy() = "OK"
-    }
-}
-
-class WithInner {
-    inner class Inner {
-        suspend fun dummy() = "OK"
-    }
-}
-
 val c: suspend () -> Unit = {}

 class WithTypeParameter<T: suspend() -> Unit> {}

 fun returnsSuspend() : suspend() -> Unit = {}

-fun builder(c: suspend () -> Unit) {}
+fun <T: suspend () -> Unit> withTypeParameter() = {}

-fun <T: suspend () -> Unit> withTypeParameter() = {}
+fun suspendFunctionNested(x: List<suspend () -> Unit>) {}
+fun suspendFunctionNestedInFunctionType(x: (suspend () -> Unit) -> Unit) {}
+
+fun suspendFunctionType3(x: suspend (Int, Int, Int) -> Unit) {}
+
+fun suspendVarargs(vararg x: suspend () -> Unit) {}
@@ -1,29 +1,30 @@
 warning: language version 1.3 is experimental, there are no backwards compatibility guarantees for new language and library features
-compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:2:5: error: using 'c: suspend () -> Unit' is an error. Experimental coroutine cannot be used with API version 1.3
-    c()
-    ^
-compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:3:5: error: using 'constructor WithTypeParameter<T : suspend () -> Unit>()' is an error. Experimental coroutine cannot be used with API version 1.3
+warning: runtime JAR files in the classpath should have the same version. These files were found in the classpath:
+    $DIST_DIR$/kotlin-stdlib-coroutines.jar (version 1.3)
+    $PROJECT_DIR$/lib/kotlin-stdlib.jar (version 1.2)
+    $PROJECT_DIR$/lib/kotlin-script-runtime.jar (version 1.2)
+    $PROJECT_DIR$/lib/kotlin-reflect.jar (version 1.2)
+warning: consider providing an explicit dependency on kotlin-reflect 1.3 to prevent strange errors
+warning: some runtime JAR files in the classpath have an incompatible version. Consider removing them from the classpath
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:2:5: error: using 'constructor WithTypeParameter<T : suspend () -> Unit>()' is an error. Experimental coroutine cannot be used with API version 1.3
    WithTypeParameter<suspend () -> Unit>()
    ^
-compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:4:5: error: using 'returnsSuspend(): suspend () -> Unit' is an error. Experimental coroutine cannot be used with API version 1.3
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:3:5: error: using 'returnsSuspend(): suspend () -> Unit' is an error. Experimental coroutine cannot be used with API version 1.3
    returnsSuspend()
    ^
-compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:5:5: error: using 'builder(suspend () -> Unit): Unit' is an error. Experimental coroutine cannot be used with API version 1.3
-    builder {}
-    ^
-compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:6:5: error: using 'withTypeParameter(): () -> Unit' is an error. Experimental coroutine cannot be used with API version 1.3
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:4:5: error: using 'withTypeParameter(): () -> Unit' is an error. Experimental coroutine cannot be used with API version 1.3
    withTypeParameter<suspend () -> Unit>()
    ^
-compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:8:5: error: using 'dummy(): Unit' is an error. Experimental coroutine cannot be used with API version 1.3
-    dummy()
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:6:5: error: using 'suspendFunctionNested(List<suspend () -> Unit>): Unit' is an error. Experimental coroutine cannot be used with API version 1.3
+    suspendFunctionNested(listOf(suspend {  }))
+    ^
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:7:5: error: using 'suspendFunctionNestedInFunctionType((suspend () -> Unit) -> Unit): Unit' is an error. Experimental coroutine cannot be used with API version 1.3
+    suspendFunctionNestedInFunctionType {}
+    ^
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:8:5: error: using 'suspendFunctionType3(suspend (Int, Int, Int) -> Unit): Unit' is an error. Experimental coroutine cannot be used with API version 1.3
+    suspendFunctionType3 { x, y, z -> }
+    ^
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:10:5: error: using 'suspendVarargs(vararg suspend () -> Unit): Unit' is an error. Experimental coroutine cannot be used with API version 1.3
+    suspendVarargs({}, {})
    ^
-compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:9:9: error: using 'dummy(): String' is an error. Experimental coroutine cannot be used with API version 1.3
-    C().dummy()
-        ^
-compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:10:25: error: using 'dummy(): String' is an error. Experimental coroutine cannot be used with API version 1.3
-    WithNested.Nested().dummy()
-                        ^
-compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromRelease/release.kt:11:25: error: using 'dummy(): String' is an error. Experimental coroutine cannot be used with API version 1.3
-    WithInner().Inner().dummy()
-                        ^
 COMPILATION_ERROR
@@ -1,12 +1,11 @@
 suspend fun callRelease() {
-    c()
    WithTypeParameter<suspend () -> Unit>()
    returnsSuspend()
-    builder {}
    withTypeParameter<suspend () -> Unit>()

-    dummy()
-    C().dummy()
-    WithNested.Nested().dummy()
-    WithInner().Inner().dummy()
+    suspendFunctionNested(listOf(suspend {  }))
+    suspendFunctionNestedInFunctionType {}
+    suspendFunctionType3 { x, y, z -> }
+
+    suspendVarargs({}, {})
 }
@@ -0,0 +1,24 @@
+suspend fun dummy() {}
+
+class C {
+    suspend fun dummy() = "OK"
+}
+
+class WithNested {
+    class Nested {
+        suspend fun dummy() = "OK"
+    }
+}
+
+class WithInner {
+    inner class Inner {
+        suspend fun dummy() = "OK"
+    }
+}
+
+fun builder(c: suspend () -> Unit) {}
+fun builder2(c: suspend Int.(String) -> Unit) {}
+
+fun (suspend (Int) -> Unit).start() {}
+
+suspend fun suspendAcceptsSuspend(x: suspend () -> Unit) {}
@@ -0,0 +1,33 @@
+warning: language version 1.3 is experimental, there are no backwards compatibility guarantees for new language and library features
+warning: runtime JAR files in the classpath should have the same version. These files were found in the classpath:
+    $DIST_DIR$/kotlin-stdlib-coroutines.jar (version 1.3)
+    $PROJECT_DIR$/lib/kotlin-stdlib.jar (version 1.2)
+    $PROJECT_DIR$/lib/kotlin-script-runtime.jar (version 1.2)
+    $PROJECT_DIR$/lib/kotlin-reflect.jar (version 1.2)
+warning: consider providing an explicit dependency on kotlin-reflect 1.3 to prevent strange errors
+warning: some runtime JAR files in the classpath have an incompatible version. Consider removing them from the classpath
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromReleaseWarnings/release.kt:2:5: warning: 'builder(suspend () -> Unit): Unit' is deprecated. Experimental coroutines support will be dropped in 1.4
+    builder {}
+    ^
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromReleaseWarnings/release.kt:3:5: warning: 'builder2(suspend Int.(String) -> Unit): Unit' is deprecated. Experimental coroutines support will be dropped in 1.4
+    builder2 { }
+    ^
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromReleaseWarnings/release.kt:6:7: warning: 'start(): Unit' is deprecated. Experimental coroutines support will be dropped in 1.4
+    x.start()
+      ^
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromReleaseWarnings/release.kt:8:5: warning: 'dummy(): Unit' is deprecated. Experimental coroutines support will be dropped in 1.4
+    dummy()
+    ^
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromReleaseWarnings/release.kt:9:9: warning: 'dummy(): String' is deprecated. Experimental coroutines support will be dropped in 1.4
+    C().dummy()
+        ^
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromReleaseWarnings/release.kt:10:25: warning: 'dummy(): String' is deprecated. Experimental coroutines support will be dropped in 1.4
+    WithNested.Nested().dummy()
+                        ^
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromReleaseWarnings/release.kt:11:25: warning: 'dummy(): String' is deprecated. Experimental coroutines support will be dropped in 1.4
+    WithInner().Inner().dummy()
+                        ^
+compiler/testData/compileKotlinAgainstCustomBinaries/experimentalCoroutineCallFromReleaseWarnings/release.kt:13:5: warning: 'suspendAcceptsSuspend(suspend () -> Unit): Unit' is deprecated. Experimental coroutines support will be dropped in 1.4
+    suspendAcceptsSuspend {
+    ^
+OK
@@ -0,0 +1,16 @@
+suspend fun callRelease() {
+    builder {}
+    builder2 { }
+
+    val x: suspend (Int) -> Unit = {}
+    x.start()
+
+    dummy()
+    C().dummy()
+    WithNested.Nested().dummy()
+    WithInner().Inner().dummy()
+
+    suspendAcceptsSuspend {
+        callRelease()
+    }
+}
@@ -24,14 +24,14 @@ fun builder(c: <!UNSUPPORTED!>suspend<!> () -> Unit) {}
 }

 fun test2() {
-    kotlin.coroutines.experimental.<!DEPRECATION_ERROR, UNSUPPORTED!>buildSequence<!><Int> {
-        <!DEPRECATION_ERROR!>yield<!>(1)
+    kotlin.coroutines.experimental.<!DEPRECATION, UNSUPPORTED!>buildSequence<!><Int> {
+        <!DEPRECATION!>yield<!>(1)
    }
    kotlin.sequences.<!UNRESOLVED_REFERENCE!>buildSequence<!><Int> {
        <!UNRESOLVED_REFERENCE!>yield<!>(1)
    }
 }

-<!UNSUPPORTED!>suspend<!> fun test3(): Unit = kotlin.coroutines.experimental.<!DEPRECATION_ERROR!>suspendCoroutine<!> { _ -> Unit }
+<!UNSUPPORTED!>suspend<!> fun test3(): Unit = kotlin.coroutines.experimental.<!DEPRECATION!>suspendCoroutine<!> { _ -> Unit }

-<!UNSUPPORTED!>suspend<!> fun test4(): Unit = kotlin.coroutines.<!UNRESOLVED_REFERENCE!>suspendCoroutine<!> { <!CANNOT_INFER_PARAMETER_TYPE!>_<!> -> Unit }
+<!UNSUPPORTED!>suspend<!> fun test4(): Unit = kotlin.coroutines.<!UNRESOLVED_REFERENCE!>suspendCoroutine<!> { <!CANNOT_INFER_PARAMETER_TYPE!>_<!> -> Unit }
@@ -79,6 +79,7 @@ public abstract class AbstractCliTest extends TestCaseWithTmpdir {
                .replace(testDataAbsoluteDir, TESTDATA_DIR)
                .replace(FileUtil.toSystemIndependentName(testDataAbsoluteDir), TESTDATA_DIR)
                .replace(PathUtil.getKotlinPathsForDistDirectory().getHomePath().getAbsolutePath(), "$PROJECT_DIR$")
+                .replace(PathUtil.getKotlinPathsForDistDirectory().getHomePath().getParentFile().getAbsolutePath(), "$DIST_DIR$")
                .replace("expected version is " + JvmMetadataVersion.INSTANCE, "expected version is $ABI_VERSION$")
                .replace("expected version is " + JsMetadataVersion.INSTANCE, "expected version is $ABI_VERSION$")
                .replace("\\", "/")
@@ -484,6 +484,14 @@ class CompileKotlinAgainstCustomBinariesTest : AbstractKotlinCompilerIntegration
    }

    fun testExperimentalCoroutineCallFromRelease() {
+        doTestExperimentalCoroutineCallFromRelease()
+    }
+
+    fun testExperimentalCoroutineCallFromReleaseWarnings() {
+        doTestExperimentalCoroutineCallFromRelease()
+    }
+
+    private fun doTestExperimentalCoroutineCallFromRelease() {
        val library = compileLibrary(
            "library",
            additionalOptions = listOf("-language-version", "1.2"),
@@ -492,7 +500,7 @@ class CompileKotlinAgainstCustomBinariesTest : AbstractKotlinCompilerIntegration
        compileKotlin(
            "release.kt",
            tmpdir,
-            listOf(library),
+            listOf(library, ForTestCompileRuntime.coroutinesJarForTests()),
            additionalOptions = listOf("-language-version", "1.3", "-api-version", "1.3")
        )
    }
@@ -5,6 +5,7 @@

 package org.jetbrains.kotlin.serialization.deserialization

+import org.jetbrains.kotlin.builtins.isSuspendFunctionType
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget
@@ -17,7 +18,12 @@ import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.deserialization.*
 import org.jetbrains.kotlin.protobuf.MessageLite
 import org.jetbrains.kotlin.resolve.DescriptorFactory
+import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameOrNull
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.*
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedMemberDescriptor.CoroutinesCompatibilityMode
+import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlin.types.UnwrappedType
+import org.jetbrains.kotlin.types.typeUtil.contains

 class MemberDeserializer(private val c: DeserializationContext) {
    private val annotationDeserializer = AnnotationDeserializer(c.components.moduleDescriptor, c.components.notFoundClasses)
@@ -130,12 +136,97 @@ class MemberDeserializer(private val c: DeserializationContext) {
        return property
    }

-    private fun DeserializedMemberDescriptor.checkExperimentalCoroutine(typeDeserializer: TypeDeserializer): Boolean {
-        // Calculate checkExperimentalCoroutine for type parameters
-        typeDeserializer.ownTypeParameters.forEach { it.upperBounds }
-        return typeDeserializer.experimentalSuspendFunctionTypeEncountered && versionAndReleaseCoroutinesMismatch()
+    private fun DeserializedMemberDescriptor.checkExperimentalCoroutine(
+        typeDeserializer: TypeDeserializer
+    ): DeserializedMemberDescriptor.CoroutinesCompatibilityMode {
+        if (!versionAndReleaseCoroutinesMismatch()) return CoroutinesCompatibilityMode.COMPATIBLE
+
+        forceUpperBoundsComputation(typeDeserializer)
+
+        return if (typeDeserializer.experimentalSuspendFunctionTypeEncountered)
+            CoroutinesCompatibilityMode.INCOMPATIBLE
+        else
+            CoroutinesCompatibilityMode.COMPATIBLE
    }

+    private fun forceUpperBoundsComputation(typeDeserializer: TypeDeserializer) {
+        typeDeserializer.ownTypeParameters.forEach { it.upperBounds }
+    }
+
+    private fun DeserializedSimpleFunctionDescriptor.initializeWithCoroutinesExperimentalityStatus(
+        receiverParameterType: KotlinType?,
+        dispatchReceiverParameter: ReceiverParameterDescriptor?,
+        typeParameters: List<TypeParameterDescriptor>,
+        unsubstitutedValueParameters: List<ValueParameterDescriptor>,
+        unsubstitutedReturnType: KotlinType?,
+        modality: Modality?,
+        visibility: Visibility,
+        userDataMap: Map<out FunctionDescriptor.UserDataKey<*>, *>,
+        isSuspend: Boolean
+    ) {
+        initialize(
+            receiverParameterType,
+            dispatchReceiverParameter,
+            typeParameters,
+            unsubstitutedValueParameters,
+            unsubstitutedReturnType,
+            modality,
+            visibility,
+            userDataMap,
+            computeExperimentalityModeForFunctions(
+                receiverParameterType,
+                unsubstitutedValueParameters,
+                typeParameters,
+                unsubstitutedReturnType,
+                isSuspend
+            )
+        )
+    }
+
+    private fun DeserializedCallableMemberDescriptor.computeExperimentalityModeForFunctions(
+        extensionReceiverType: KotlinType?,
+        parameters: Collection<ValueParameterDescriptor>,
+        typeParameters: Collection<TypeParameterDescriptor>,
+        returnType: KotlinType?,
+        isSuspend: Boolean
+    ): DeserializedMemberDescriptor.CoroutinesCompatibilityMode {
+        if (!versionAndReleaseCoroutinesMismatch()) return CoroutinesCompatibilityMode.COMPATIBLE
+        if (fqNameOrNull() == KOTLIN_SUSPEND_BUILT_IN_FUNCTION_FQ_NAME) return CoroutinesCompatibilityMode.COMPATIBLE
+
+        val types = parameters.map { it.type } + listOfNotNull(extensionReceiverType)
+
+        if (returnType?.containsSuspendFunctionType() == true) return CoroutinesCompatibilityMode.INCOMPATIBLE
+        if (typeParameters.any { typeParameter -> typeParameter.upperBounds.any { it.containsSuspendFunctionType() } }) {
+            return CoroutinesCompatibilityMode.INCOMPATIBLE
+        }
+
+        val maxFromParameters = types.map { type ->
+            when {
+                type.isSuspendFunctionType && type.arguments.size <= 3 ->
+                    if (type.arguments.any { it.type.containsSuspendFunctionType() })
+                        CoroutinesCompatibilityMode.INCOMPATIBLE
+                    else
+                        CoroutinesCompatibilityMode.NEEDS_WRAPPER
+
+                type.containsSuspendFunctionType() -> CoroutinesCompatibilityMode.INCOMPATIBLE
+
+                else -> CoroutinesCompatibilityMode.COMPATIBLE
+            }
+        }.max() ?: CoroutinesCompatibilityMode.COMPATIBLE
+
+        return maxOf(
+            if (isSuspend)
+                CoroutinesCompatibilityMode.NEEDS_WRAPPER
+            else
+                CoroutinesCompatibilityMode.COMPATIBLE,
+            maxFromParameters
+        )
+    }
+
+
+    private fun KotlinType.containsSuspendFunctionType() = contains(UnwrappedType::isSuspendFunctionType)
+
+
    private fun DeserializedMemberDescriptor.versionAndReleaseCoroutinesMismatch(): Boolean =
        c.components.configuration.releaseCoroutines && versionRequirements.none {
            it.version == VersionRequirement.Version(1, 3) && it.kind == ProtoBuf.VersionRequirement.VersionKind.LANGUAGE_VERSION
@@ -160,7 +251,7 @@ class MemberDeserializer(private val c: DeserializationContext) {
        )
        val local = c.childContext(function, proto.typeParameterList)

-        function.initialize(
+        function.initializeWithCoroutinesExperimentalityStatus(
            proto.receiverType(c.typeTable)?.let { local.typeDeserializer.type(it, receiverAnnotations) },
            getDispatchReceiverParameter(),
            local.typeDeserializer.ownTypeParameters,
@@ -169,8 +260,7 @@ class MemberDeserializer(private val c: DeserializationContext) {
            ProtoEnumFlags.modality(Flags.MODALITY.get(flags)),
            ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
            emptyMap<FunctionDescriptor.UserDataKey<*>, Any?>(),
-            (Flags.IS_SUSPEND.get(flags) && function.versionAndReleaseCoroutinesMismatch()) ||
-                    function.checkExperimentalCoroutine(local.typeDeserializer)
+            Flags.IS_SUSPEND.get(flags)
        )
        function.isOperator = Flags.IS_OPERATOR.get(flags)
        function.isInfix = Flags.IS_INFIX.get(flags)
@@ -227,11 +317,18 @@ class MemberDeserializer(private val c: DeserializationContext) {
        )
        descriptor.returnType = classDescriptor.defaultType

-        // Calculate isExperimentalCoroutineInReleaseEnvironment for type parameters
-        descriptor.typeParameters.forEach { it.upperBounds }
-        descriptor.isExperimentalCoroutineInReleaseEnvironment = local.typeDeserializer.experimentalSuspendFunctionTypeEncountered ||
-                ((c.containingDeclaration as? DeserializedClassDescriptor)?.c?.typeDeserializer?.experimentalSuspendFunctionTypeEncountered == true &&
-                        descriptor.versionAndReleaseCoroutinesMismatch())
+        val doesClassContainIncompatibility =
+            (c.containingDeclaration as? DeserializedClassDescriptor)
+                ?.c?.typeDeserializer?.experimentalSuspendFunctionTypeEncountered == true
+                    && descriptor.versionAndReleaseCoroutinesMismatch()
+
+        descriptor.coroutinesExperimentalCompatibilityMode =
+                if (doesClassContainIncompatibility)
+                    CoroutinesCompatibilityMode.INCOMPATIBLE
+                else descriptor.computeExperimentalityModeForFunctions(
+                    null, descriptor.valueParameters, descriptor.typeParameters,
+                    descriptor.returnType, isSuspend = false
+                )

        return descriptor
    }
@@ -23,8 +23,6 @@ interface DeserializedMemberDescriptor : MemberDescriptor {

    val typeTable: TypeTable

-    val isExperimentalCoroutineInReleaseEnvironment: Boolean
-
    val versionRequirementTable: VersionRequirementTable

    val versionRequirements: List<VersionRequirement>
@@ -33,6 +31,14 @@ interface DeserializedMemberDescriptor : MemberDescriptor {
    // Information about the origin of this callable's container (class or package part on JVM) or null if there's no such information.
    // TODO: merge with sourceElement of containingDeclaration
    val containerSource: DeserializedContainerSource?
+
+    val coroutinesExperimentalCompatibilityMode: CoroutinesCompatibilityMode
+
+    enum class CoroutinesCompatibilityMode {
+        COMPATIBLE,
+        NEEDS_WRAPPER,
+        INCOMPATIBLE
+    }
 }

 interface DeserializedContainerSource : SourceElement {
@@ -66,7 +72,7 @@ class DeserializedSimpleFunctionDescriptor(
        source ?: SourceElement.NO_SOURCE
    ) {

-    override var isExperimentalCoroutineInReleaseEnvironment: Boolean = false
+    override var coroutinesExperimentalCompatibilityMode = DeserializedMemberDescriptor.CoroutinesCompatibilityMode.COMPATIBLE
        private set

    fun initialize(
@@ -78,7 +84,7 @@ class DeserializedSimpleFunctionDescriptor(
        modality: Modality?,
        visibility: Visibility,
        userDataMap: Map<out FunctionDescriptor.UserDataKey<*>, *>,
-        isExperimentalCoroutineInReleaseEnvironment: Boolean
+        isExperimentalCoroutineInReleaseEnvironment: DeserializedMemberDescriptor.CoroutinesCompatibilityMode
    ): SimpleFunctionDescriptorImpl {
        return super.initialize(
            receiverParameterType,
@@ -90,7 +96,7 @@ class DeserializedSimpleFunctionDescriptor(
            visibility,
            userDataMap
        ).also {
-            this.isExperimentalCoroutineInReleaseEnvironment = isExperimentalCoroutineInReleaseEnvironment
+            this.coroutinesExperimentalCompatibilityMode = isExperimentalCoroutineInReleaseEnvironment
        }
    }

@@ -105,7 +111,9 @@ class DeserializedSimpleFunctionDescriptor(
        return DeserializedSimpleFunctionDescriptor(
            newOwner, original as SimpleFunctionDescriptor?, annotations, newName ?: name, kind,
            proto, nameResolver, typeTable, versionRequirementTable, containerSource, source
-        )
+        ).also {
+            it.coroutinesExperimentalCompatibilityMode = coroutinesExperimentalCompatibilityMode
+        }
    }
 }

@@ -132,16 +140,16 @@ class DeserializedPropertyDescriptor(
    containingDeclaration, original, annotations, modality, visibility, isVar, name, kind, SourceElement.NO_SOURCE,
    isLateInit, isConst, isExpect, false, isExternal, isDelegated
 ) {
-    override var isExperimentalCoroutineInReleaseEnvironment: Boolean = false
+    override var coroutinesExperimentalCompatibilityMode = DeserializedMemberDescriptor.CoroutinesCompatibilityMode.COMPATIBLE
        private set

    fun initialize(
        getter: PropertyGetterDescriptorImpl?,
        setter: PropertySetterDescriptor?,
-        isExperimentalCoroutineInReleaseEnvironment: Boolean
+        isExperimentalCoroutineInReleaseEnvironment: DeserializedMemberDescriptor.CoroutinesCompatibilityMode
    ) {
        super.initialize(getter, setter)
-            .also { this.isExperimentalCoroutineInReleaseEnvironment = isExperimentalCoroutineInReleaseEnvironment }
+            .also { this.coroutinesExperimentalCompatibilityMode = isExperimentalCoroutineInReleaseEnvironment }
    }

    override fun createSubstitutedCopy(
@@ -176,7 +184,7 @@ class DeserializedClassConstructorDescriptor(
 ) : DeserializedCallableMemberDescriptor,
    ClassConstructorDescriptorImpl(containingDeclaration, original, annotations, isPrimary, kind, source ?: SourceElement.NO_SOURCE) {

-    override var isExperimentalCoroutineInReleaseEnvironment: Boolean = false
+    override var coroutinesExperimentalCompatibilityMode = DeserializedMemberDescriptor.CoroutinesCompatibilityMode.COMPATIBLE
        internal set

    override fun createSubstitutedCopy(
@@ -190,7 +198,7 @@ class DeserializedClassConstructorDescriptor(
        return DeserializedClassConstructorDescriptor(
            newOwner as ClassDescriptor, original as ConstructorDescriptor?, annotations, isPrimary, kind,
            proto, nameResolver, typeTable, versionRequirementTable, containerSource, source
-        ).also { it.isExperimentalCoroutineInReleaseEnvironment = isExperimentalCoroutineInReleaseEnvironment }
+        ).also { it.coroutinesExperimentalCompatibilityMode = coroutinesExperimentalCompatibilityMode }
    }

    override fun isExternal(): Boolean = false
@@ -222,14 +230,14 @@ class DeserializedTypeAliasDescriptor(
    private lateinit var typeConstructorParameters: List<TypeParameterDescriptor>
    private lateinit var defaultTypeImpl: SimpleType

-    override var isExperimentalCoroutineInReleaseEnvironment: Boolean = false
+    override var coroutinesExperimentalCompatibilityMode = DeserializedMemberDescriptor.CoroutinesCompatibilityMode.COMPATIBLE
        private set

    fun initialize(
        declaredTypeParameters: List<TypeParameterDescriptor>,
        underlyingType: SimpleType,
        expandedType: SimpleType,
-        isExperimentalCoroutineInReleaseEnvironment: Boolean
+        isExperimentalCoroutineInReleaseEnvironment: DeserializedMemberDescriptor.CoroutinesCompatibilityMode
    ) {
        initialize(declaredTypeParameters)
        this.underlyingType = underlyingType
@@ -237,7 +245,7 @@ class DeserializedTypeAliasDescriptor(
        typeConstructorParameters = computeConstructorTypeParameters()
        defaultTypeImpl = computeDefaultType()
        constructors = getTypeAliasConstructors()
-        this.isExperimentalCoroutineInReleaseEnvironment = isExperimentalCoroutineInReleaseEnvironment
+        this.coroutinesExperimentalCompatibilityMode = isExperimentalCoroutineInReleaseEnvironment
    }

    override val classDescriptor: ClassDescriptor?
@@ -255,7 +263,7 @@ class DeserializedTypeAliasDescriptor(
            declaredTypeParameters,
            substitutor.safeSubstitute(underlyingType, Variance.INVARIANT).asSimpleType(),
            substitutor.safeSubstitute(expandedType, Variance.INVARIANT).asSimpleType(),
-            isExperimentalCoroutineInReleaseEnvironment
+            coroutinesExperimentalCompatibilityMode
        )

        return substituted
@@ -3,7 +3,7 @@ import libO.*

 suspend fun newMain() {
    newFoo()
-    <error descr="[DEPRECATION_ERROR] Using 'oldFoo(): Unit' is an error. Experimental coroutine cannot be used with API version 1.3">oldFoo</error>()
+    <warning descr="[DEPRECATION] 'oldFoo(): Unit' is deprecated. Experimental coroutines support will be dropped in 1.4">oldFoo</warning>()

    // TODO: actually, it's a bug
    oldMain()
@@ -14,5 +14,5 @@ fun newMain2() {
        newMain()
    }

-    <error descr="[DEPRECATION_ERROR] Using 'oldFoo(): Unit' is an error. Experimental coroutine cannot be used with API version 1.3"><error descr="[ILLEGAL_SUSPEND_FUNCTION_CALL] Suspend function 'oldFoo' should be called only from a coroutine or another suspend function">oldFoo</error></error>()
+    <error descr="[ILLEGAL_SUSPEND_FUNCTION_CALL] Suspend function 'oldFoo' should be called only from a coroutine or another suspend function">oldFoo</error>()
 }