New mangling rules require language version 1.4 (not compiler version)

Follow-up to a270ee094c

compiler/tests/org/jetbrains/kotlin/serialization/AbstractVersionRequirementTest.kt

@@ -31,7 +31,8 @@ abstract class AbstractVersionRequirementTest : TestCaseWithTmpdir() {
         customLanguageVersion: LanguageVersion = LanguageVersionSettingsImpl.DEFAULT.languageVersion,
         analysisFlags: Map<AnalysisFlag<*>, Any?> = emptyMap(),
         fqNamesWithRequirements: List<String>,
-        fqNamesWithoutRequirement: List<String> = emptyList()
+        fqNamesWithoutRequirement: List<String> = emptyList(),
+        shouldBeSingleRequirement: Boolean = true
     ) {
         compileFiles(
             listOf(File("compiler/testData/versionRequirement/${getTestName(true)}.kt")),
@@ -45,6 +46,13 @@ abstract class AbstractVersionRequirementTest : TestCaseWithTmpdir() {
             val requirements = extractRequirement(descriptor)
             if (requirements.isEmpty()) throw AssertionError("No VersionRequirement for $descriptor")
 
+            if (shouldBeSingleRequirement && requirements.size > 1) {
+                throw AssertionError(
+                    "Single VersionRequirement expected, got ${requirements.size}:\n" +
+                            requirements.joinToString(separator = "\n") { it.toDebugString() }
+                )
+            }
+
             requirements.firstOrNull {
                 expectedVersionRequirement == it.version &&
                         expectedLevel == it.level &&
@@ -53,14 +61,14 @@ abstract class AbstractVersionRequirementTest : TestCaseWithTmpdir() {
                         expectedErrorCode == it.errorCode
             }
                 ?: throw AssertionError(
-                    "Version requirement not found:\n" +
-                            "expectedVersionRequirement=" + expectedVersionRequirement +
-                            "; expectedLevel=" + expectedLevel +
-                            "; expectedMessage=" + expectedMessage +
-                            "; expectedVersionKind=" + expectedVersionKind +
-                            "; expectedErrorCode=" + expectedErrorCode +
+                    "Version requirement not found, expected:\n" +
+                            "versionRequirement=" + expectedVersionRequirement +
+                            "; level=" + expectedLevel +
+                            "; message=" + expectedMessage +
+                            "; versionKind=" + expectedVersionKind +
+                            "; errorCode=" + expectedErrorCode +
                             "\nActual requirements:\n" +
-                            requirements.joinToString(separator = "\n") { it.toString() }
+                            requirements.joinToString(separator = "\n") { it.toDebugString() }
                 )
         }
 
@@ -72,6 +80,9 @@ abstract class AbstractVersionRequirementTest : TestCaseWithTmpdir() {
         }
     }
 
+    private fun VersionRequirement.toDebugString(): String =
+        "versionRequirement=$version; level=$level; message=$message; versionKind=$kind; errorCode=$errorCode"
+
     private fun extractRequirement(descriptor: DeclarationDescriptor): List<VersionRequirement> {
         return when (descriptor) {
             is DeserializedMemberDescriptor -> descriptor.versionRequirements

compiler/tests/org/jetbrains/kotlin/serialization/JvmVersionRequirementTest.kt

@@ -129,14 +129,41 @@ class JvmVersionRequirementTest : AbstractVersionRequirementTest() {
     }
 
     fun testInlineClassReturnTypeMangled() {
+        // Class members returning inline class values are mangled,
+        // and have "since 1.4" version requirement along with "since 1.3" version requirement for inline class in signature
         doTest(
-            VersionRequirement.Version(1, 4, 0), DeprecationLevel.ERROR, null, COMPILER_VERSION, null,
+            VersionRequirement.Version(1, 4, 0), DeprecationLevel.ERROR, null, LANGUAGE_VERSION, null,
             fqNamesWithRequirements = listOf(
                 "test.C.returnsInlineClassType",
                 "test.C.propertyOfInlineClassType"
             ),
+            customLanguageVersion = LanguageVersion.KOTLIN_1_4,
+            shouldBeSingleRequirement = false
+        )
+        // Top-level functions and properties returning inline class values are NOT mangled,
+        // and have "since 1.3" version requirement for inline class in signature only.
+        doTest(
+            VersionRequirement.Version(1, 3, 0), DeprecationLevel.ERROR, null, LANGUAGE_VERSION, null,
+            fqNamesWithRequirements = listOf(
+                "test.returnsInlineClassType",
+                "test.propertyOfInlineClassType"
+            ),
+            shouldBeSingleRequirement = true,
             customLanguageVersion = LanguageVersion.KOTLIN_1_4
         )
+        // In Kotlin 1.3, all functions and properties returning inline class values are NOT mangled,
+        // and have "since 1.3" version requirement for inline class in signature only.
+        doTest(
+            VersionRequirement.Version(1, 3, 0), DeprecationLevel.ERROR, null, LANGUAGE_VERSION, null,
+            fqNamesWithRequirements = listOf(
+                "test.returnsInlineClassType",
+                "test.propertyOfInlineClassType",
+                "test.C.returnsInlineClassType",
+                "test.C.propertyOfInlineClassType"
+            ),
+            shouldBeSingleRequirement = true,
+            customLanguageVersion = LanguageVersion.KOTLIN_1_3
+        )
     }
 
     fun testSuspendFun_1_2() {