diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index c6957d5c7bb..fc6b458a0ad 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java @@ -44,6 +44,7 @@ import org.jetbrains.kotlin.codegen.when.SwitchCodegen; import org.jetbrains.kotlin.codegen.when.SwitchCodegenProvider; import org.jetbrains.kotlin.config.ApiVersion; import org.jetbrains.kotlin.config.JVMAssertionsMode; +import org.jetbrains.kotlin.config.JVMConfigurationKeys; import org.jetbrains.kotlin.config.LanguageFeature; import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor; @@ -2686,7 +2687,9 @@ public class ExpressionCodegen extends KtVisitor impleme CallableMethod method = typeMapper.mapToCallableMethod(fd, superCall, null, resolvedCall); - if (method.getAsmMethod().getName().contains("-")) { + if (method.getAsmMethod().getName().contains("-") && + !state.getConfiguration().getBoolean(JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME) + ) { Boolean classFileContainsMethod = InlineClassesCodegenUtilKt.classFileContainsMethod(fd, state, method.getAsmMethod()); if (classFileContainsMethod != null && !classFileContainsMethod) { @@ -2912,7 +2915,9 @@ public class ExpressionCodegen extends KtVisitor impleme sourceCompiler.initializeInlineFunctionContext(functionDescriptor); JvmMethodSignature signature = typeMapper.mapSignatureWithGeneric(functionDescriptor, sourceCompiler.getContextKind()); - if (signature.getAsmMethod().getName().contains("-")) { + if (signature.getAsmMethod().getName().contains("-") && + !state.getConfiguration().getBoolean(JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME) + ) { Boolean classFileContainsMethod = InlineClassesCodegenUtilKt.classFileContainsMethod(functionDescriptor, state, signature.getAsmMethod()); if (classFileContainsMethod != null && !classFileContainsMethod) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt index 10da4a93ccd..7cc905d52fa 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.kt @@ -12,6 +12,7 @@ import org.jetbrains.kotlin.codegen.createFreeFakeLocalPropertyDescriptor import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.* import org.jetbrains.kotlin.codegen.state.GenerationState import org.jetbrains.kotlin.codegen.state.KotlinTypeMapperBase +import org.jetbrains.kotlin.config.JVMConfigurationKeys import org.jetbrains.kotlin.config.JvmDefaultMode import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.* @@ -60,6 +61,7 @@ class JvmSerializerExtension @JvmOverloads constructor( override val metadataVersion = state.metadataVersion private val jvmDefaultMode = state.jvmDefaultMode private val approximator = state.typeApproximator + private val useOldManglingScheme = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME) override fun shouldUseTypeTable(): Boolean = useTypeTable override fun shouldSerializeFunction(descriptor: FunctionDescriptor): Boolean { @@ -399,4 +401,6 @@ class JvmSerializerExtension @JvmOverloads constructor( override fun releaseCoroutines(): Boolean { return languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines) } + + override fun useOldInlineClassesManglingScheme(): Boolean = useOldManglingScheme } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/KotlinToJvmSignatureMapperImpl.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/KotlinToJvmSignatureMapperImpl.kt index 40f005190c5..46393b7686d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/KotlinToJvmSignatureMapperImpl.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/signature/KotlinToJvmSignatureMapperImpl.kt @@ -17,7 +17,8 @@ class KotlinToJvmSignatureMapperImpl : KotlinToJvmSignatureMapper { private val typeMapper = KotlinTypeMapper( BindingContext.EMPTY, ClassBuilderMode.LIGHT_CLASSES, JvmProtoBufUtil.DEFAULT_MODULE_NAME, - KotlinTypeMapper.LANGUAGE_VERSION_SETTINGS_DEFAULT// TODO use proper LanguageVersionSettings + KotlinTypeMapper.LANGUAGE_VERSION_SETTINGS_DEFAULT,// TODO use proper LanguageVersionSettings + useOldInlineClassesManglingScheme = false ) override fun mapToJvmMethodSignature(function: FunctionDescriptor) = typeMapper.mapAsmMethod(function) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt index 8ebd8c1892d..02a238b1c6a 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/BuilderFactoryForDuplicateSignatureDiagnostics.kt @@ -55,7 +55,8 @@ class BuilderFactoryForDuplicateSignatureDiagnostics( private val mapAsmMethod: (FunctionDescriptor) -> Method = KotlinTypeMapper( // Avoid errors when some classes are not loaded for some reason - bindingContext, ClassBuilderMode.LIGHT_CLASSES, moduleName, languageVersionSettings, isIrBackend = false + bindingContext, ClassBuilderMode.LIGHT_CLASSES, moduleName, languageVersionSettings, isIrBackend = false, + useOldInlineClassesManglingScheme = false )::mapAsmMethod private val reportDiagnosticsTasks = ArrayList<() -> Unit>() diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt index 1d99b53b92d..8f0ebf82c3a 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt @@ -214,6 +214,7 @@ class GenerationState private constructor( classBuilderMode, this.moduleName, languageVersionSettings, + configuration.getBoolean(JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME), IncompatibleClassTrackerImpl(extraJvmDiagnosticsTrace), target, isIrBackend diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt index d2eb9630794..f02057dcf4d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/KotlinTypeMapper.kt @@ -83,6 +83,7 @@ class KotlinTypeMapper @JvmOverloads constructor( val classBuilderMode: ClassBuilderMode, private val moduleName: String, val languageVersionSettings: LanguageVersionSettings, + private val useOldInlineClassesManglingScheme: Boolean, private val incompatibleClassTracker: IncompatibleClassTracker = IncompatibleClassTracker.DoNothing, val jvmTarget: JvmTarget = JvmTarget.DEFAULT, private val isIrBackend: Boolean = false, @@ -91,7 +92,11 @@ class KotlinTypeMapper @JvmOverloads constructor( ) : KotlinTypeMapperBase() { private val isReleaseCoroutines = languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines) val jvmDefaultMode = languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode) - var useOldManglingRulesForFunctionAcceptingInlineClass: Boolean = false + var useOldManglingRulesForFunctionAcceptingInlineClass: Boolean = useOldInlineClassesManglingScheme + set(value) { + require(!useOldInlineClassesManglingScheme) + field = value + } private val typeMappingConfiguration = object : TypeMappingConfiguration { override fun commonSupertype(types: Collection): KotlinType { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/inlineClassManglingUtils.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/inlineClassManglingUtils.kt index 9a1cf9a03db..0e787796758 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/inlineClassManglingUtils.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/inlineClassManglingUtils.kt @@ -22,8 +22,6 @@ import java.util.* const val NOT_INLINE_CLASS_PARAMETER_PLACEHOLDER = "_" -private fun FunctionDescriptor.isFunctionFromStdlib(): Boolean = fqNameSafe.startsWith(Name.identifier("kotlin")) - class InfoForMangling( val fqName: FqNameUnsafe, val isInline: Boolean, @@ -96,7 +94,7 @@ fun getManglingSuffixBasedOnKotlinSignature( val unwrappedDescriptor = descriptor.unwrapInitialDescriptorForSuspendFunction() val resultNew = collectFunctionSignatureForManglingSuffix( - useOldManglingRules = useOldManglingRules || descriptor.isFunctionFromStdlib(), + useOldManglingRules = useOldManglingRules, requiresFunctionNameManglingForParameterTypes = requiresFunctionNameManglingForParameterTypes(descriptor), fqNamesForMangling = (listOfNotNull(descriptor.extensionReceiverParameter?.type) + descriptor.valueParameters.map { it.type }) diff --git a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt index 315806a73c2..e86edf8ff64 100644 --- a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt +++ b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt @@ -412,6 +412,12 @@ class K2JVMCompilerArguments : CommonCompilerArguments() { ) var useOldSpilledVarTypeAnalysis: Boolean by FreezableVar(false) + @Argument( + value = "-Xuse-14-inline-classes-mangling-scheme", + description = "Use 1.4 inline classes mangling scheme instead of 1.4.30 one" + ) + var useOldInlineClassesManglingScheme: Boolean by FreezableVar(false) + override fun configureAnalysisFlags(collector: MessageCollector): MutableMap, Any> { val result = super.configureAnalysisFlags(collector) result[JvmAnalysisFlags.strictMetadataVersionSemantics] = strictMetadataVersionSemantics diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliLightClassGenerationSupport.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliLightClassGenerationSupport.kt index 53ddc5f4960..6cb009f43ad 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliLightClassGenerationSupport.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CliLightClassGenerationSupport.kt @@ -87,6 +87,7 @@ class CliLightClassGenerationSupport( ClassBuilderMode.LIGHT_CLASSES, moduleName, languageVersionSettings, + useOldInlineClassesManglingScheme = false, jvmTarget = JvmTarget.JVM_1_8, typePreprocessor = KotlinType::cleanFromAnonymousTypes, namePreprocessor = ::tryGetPredefinedName diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/jvmArguments.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/jvmArguments.kt index 89c854abb4a..102a62e533e 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/jvmArguments.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/jvmArguments.kt @@ -231,6 +231,7 @@ fun CompilerConfiguration.configureAdvancedJvmOptions(arguments: K2JVMCompilerAr put(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE, arguments.allowKotlinPackage) put(JVMConfigurationKeys.USE_SINGLE_MODULE, arguments.singleModule) put(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS, arguments.useOldSpilledVarTypeAnalysis) + put(JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME, arguments.useOldInlineClassesManglingScheme) arguments.declarationsOutputPath?.let { put(JVMConfigurationKeys.DECLARATIONS_JSON_PATH, it) } } diff --git a/compiler/config.jvm/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java b/compiler/config.jvm/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java index 4e96fe93de0..bc896a1f725 100644 --- a/compiler/config.jvm/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java +++ b/compiler/config.jvm/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java @@ -137,4 +137,7 @@ public class JVMConfigurationKeys { public static final CompilerConfigurationKey USE_OLD_SPILLED_VAR_TYPE_ANALYSIS = CompilerConfigurationKey.create("Use old, SourceInterpreter-based analysis for fields, used for spilled variables in coroutines"); + + public static final CompilerConfigurationKey USE_OLD_INLINE_CLASSES_MANGLING_SCHEME = + CompilerConfigurationKey.create("Use old, 1.4 version of inline classes mangling scheme"); } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/InlineClassAbi.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/InlineClassAbi.kt index 2a6c25b2fbe..0ade294322a 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/InlineClassAbi.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/InlineClassAbi.kt @@ -61,8 +61,6 @@ object InlineClassAbi { return irClass.primaryConstructor!!.valueParameters[0].type } - private fun IrFunction.isFunctionFromStdlib(): Boolean = fqNameForIrSerialization.startsWith(Name.identifier("kotlin")) - /** * Returns a mangled name for a function taking inline class arguments * to avoid clashes between overloaded methods. @@ -99,7 +97,7 @@ object InlineClassAbi { alwaysMangleReturnType: Boolean = false ): String? { val signatureForMangling = collectFunctionSignatureForManglingSuffix( - useOldManglingRules = useOldMangleRules || irFunction.isFunctionFromStdlib(), + useOldManglingRules = useOldMangleRules, requiresFunctionNameManglingForParameterTypes = irFunction.fullValueParameterList.any { it.type.requiresMangling }, fqNamesForMangling = irFunction.fullValueParameterList.map { it.type.asInfoForMangling() diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/MemoizedInlineClassReplacements.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/MemoizedInlineClassReplacements.kt index 2336e5dfa3e..d9bfcb12bab 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/MemoizedInlineClassReplacements.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/MemoizedInlineClassReplacements.kt @@ -15,6 +15,7 @@ import org.jetbrains.kotlin.backend.jvm.codegen.classFileContainsMethod import org.jetbrains.kotlin.backend.jvm.ir.isStaticInlineClassReplacement import org.jetbrains.kotlin.backend.jvm.lower.inlineclasses.InlineClassAbi.mangledNameFor import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper +import org.jetbrains.kotlin.config.JVMConfigurationKeys import org.jetbrains.kotlin.descriptors.DescriptorVisibilities import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.ir.builders.declarations.addValueParameter @@ -221,8 +222,13 @@ class MemoizedInlineClassReplacements( if (noFakeOverride) { isFakeOverride = false } - name = mangledNameFor(function, mangleReturnTypes, false) - if (name.asString().contains("-") && classFileContainsMethod(function, context, name.asString()) == false) { + val useOldManglingScheme = context.state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME) + name = mangledNameFor(function, mangleReturnTypes, useOldManglingScheme) + if ( + !useOldManglingScheme && + name.asString().contains("-") && + classFileContainsMethod(function, context, name.asString()) == false + ) { name = mangledNameFor(function, mangleReturnTypes, true) } returnType = function.returnType diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt index ea0569496e8..c81709282d6 100644 --- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt +++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.kt @@ -362,7 +362,7 @@ class DescriptorSerializer private constructor( } if (descriptor.hasInlineClassTypesInSignature()) { - if (descriptor.fqNameSafe.startsWith(Name.identifier("kotlin"))) { + if (extension.useOldInlineClassesManglingScheme()) { builder.addVersionRequirement(writeVersionRequirement(LanguageFeature.InlineClasses)) } else { builder.addVersionRequirement( diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtension.kt b/compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtension.kt index 7e6b76ae01b..5c7e71d1127 100644 --- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtension.kt +++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/SerializerExtension.kt @@ -94,4 +94,6 @@ abstract class SerializerExtension { } open fun releaseCoroutines(): Boolean = false + + open fun useOldInlineClassesManglingScheme(): Boolean = false } diff --git a/compiler/testData/cli/jvm/extraHelp.out b/compiler/testData/cli/jvm/extraHelp.out index cfe5362d5c5..d4a0c34af7c 100644 --- a/compiler/testData/cli/jvm/extraHelp.out +++ b/compiler/testData/cli/jvm/extraHelp.out @@ -112,6 +112,8 @@ where advanced options include: -Xuse-javac Use javac for Java source and class files analysis -Xuse-old-class-files-reading Use old class files reading implementation. This may slow down the build and cause problems with Groovy interop. Should be used in case of problems with the new implementation + -Xuse-14-inline-classes-mangling-scheme + Use 1.4 inline classes mangling scheme instead of 1.4.30 one -Xuse-old-spilled-var-type-analysis Use old, SourceInterpreter-based analysis for fields, used for spilled variables in coroutines -Xuse-type-table Use type table in metadata serialization diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/stdlibManglingIn1430/old.kt b/compiler/testData/codegen/bytecodeListing/inlineClasses/stdlibManglingIn1430/old.kt index f993b6759d3..55bd6e9c5c2 100644 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/stdlibManglingIn1430/old.kt +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/stdlibManglingIn1430/old.kt @@ -1,3 +1,4 @@ +// KOTLIN_CONFIGURATION_FLAGS: +JVM.USE_OLD_INLINE_CLASSES_MANGLING_SCHEME // FILE: 1.kt package test diff --git a/compiler/testData/versionRequirement/inlineClassesAndRelevantDeclarations.kt b/compiler/testData/versionRequirement/inlineClassesAndRelevantDeclarations13.kt similarity index 100% rename from compiler/testData/versionRequirement/inlineClassesAndRelevantDeclarations.kt rename to compiler/testData/versionRequirement/inlineClassesAndRelevantDeclarations13.kt diff --git a/compiler/testData/versionRequirement/inlineClassesAndRelevantDeclarations1430.kt b/compiler/testData/versionRequirement/inlineClassesAndRelevantDeclarations1430.kt new file mode 100644 index 00000000000..fe276694fa0 --- /dev/null +++ b/compiler/testData/versionRequirement/inlineClassesAndRelevantDeclarations1430.kt @@ -0,0 +1,17 @@ +package test + +inline class IC(val x: String) + +typealias ICAlias = IC + +class Ctor(ic: IC) + +fun simpleFun(f: IC) {} +fun aliasedFun(f: ICAlias) {} + +val simpleProp: IC = IC("") + +fun result(r: List?>) {} + +abstract class Foo : List +interface Bar diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/AbstractVersionRequirementTest.kt b/compiler/tests/org/jetbrains/kotlin/serialization/AbstractVersionRequirementTest.kt index 1d23a4ef8fa..6444842cf6f 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/AbstractVersionRequirementTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/serialization/AbstractVersionRequirementTest.kt @@ -203,18 +203,26 @@ abstract class AbstractVersionRequirementTest : TestCaseWithTmpdir() { ) } - fun testInlineClassesAndRelevantDeclarations() { + fun testInlineClassesAndRelevantDeclarations13() { doTest( VersionRequirement.Version(1, 3), DeprecationLevel.ERROR, null, ProtoBuf.VersionRequirement.VersionKind.LANGUAGE_VERSION, null, fqNamesWithRequirements = listOf( "test.IC", "test.Ctor.", + "test.Foo", + "test.Bar", + "test.simpleProp" + ) + ) + } + + fun testInlineClassesAndRelevantDeclarations1430() { + doTest( + VersionRequirement.Version(1, 4, 30), DeprecationLevel.ERROR, null, ProtoBuf.VersionRequirement.VersionKind.COMPILER_VERSION, null, + fqNamesWithRequirements = listOf( "test.simpleFun", "test.aliasedFun", - "test.simpleProp", "test.result", - "test.Foo", - "test.Bar" ) ) } diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/JvmVersionRequirementTest.kt b/compiler/tests/org/jetbrains/kotlin/serialization/JvmVersionRequirementTest.kt index c3edf7c915a..03102fe63f0 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/JvmVersionRequirementTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/serialization/JvmVersionRequirementTest.kt @@ -145,26 +145,38 @@ class JvmVersionRequirementTest : AbstractVersionRequirementTest() { doTest( VersionRequirement.Version(1, 3, 0), DeprecationLevel.ERROR, null, LANGUAGE_VERSION, null, fqNamesWithRequirements = listOf( - "test.C.returnsInlineClassTypeJvmName", - "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 ) + // 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, 4, 30), DeprecationLevel.ERROR, null, COMPILER_VERSION, null, + fqNamesWithRequirements = listOf( + "test.C.returnsInlineClassTypeJvmName", + "test.returnsInlineClassType" + ), + shouldBeSingleRequirement = true, + customLanguageVersion = LanguageVersion.KOTLIN_1_4 + ) + doTest( + VersionRequirement.Version(1, 4, 30), DeprecationLevel.ERROR, null, COMPILER_VERSION, null, + fqNamesWithRequirements = listOf( + "test.C.returnsInlineClassType" + ), + shouldBeSingleRequirement = false, + customLanguageVersion = LanguageVersion.KOTLIN_1_4 + ) } fun testSuspendFun_1_2() { diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.kt index 96adfd6ff51..00c01264e52 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.kt @@ -81,6 +81,7 @@ class IDELightClassGenerationSupport(project: Project) : LightClassGenerationSup KotlinTypeMapper( BindingContext.EMPTY, ClassBuilderMode.LIGHT_CLASSES, moduleName, languageVersionSettings, + useOldInlineClassesManglingScheme = false, jvmTarget = JvmTarget.JVM_1_8, typePreprocessor = KotlinType::cleanFromAnonymousTypes, namePreprocessor = ::tryGetPredefinedName diff --git a/idea/jvm-debugger/jvm-debugger-util/src/org/jetbrains/kotlin/idea/debugger/FileRankingCalculator.kt b/idea/jvm-debugger/jvm-debugger-util/src/org/jetbrains/kotlin/idea/debugger/FileRankingCalculator.kt index 46ad86a15f7..9642a20a218 100644 --- a/idea/jvm-debugger/jvm-debugger-util/src/org/jetbrains/kotlin/idea/debugger/FileRankingCalculator.kt +++ b/idea/jvm-debugger/jvm-debugger-util/src/org/jetbrains/kotlin/idea/debugger/FileRankingCalculator.kt @@ -342,7 +342,8 @@ abstract class FileRankingCalculator(private val checkClassFqName: Boolean = tru bindingContext, ClassBuilderMode.LIGHT_CLASSES, "debugger", - KotlinTypeMapper.LANGUAGE_VERSION_SETTINGS_DEFAULT // TODO use proper LanguageVersionSettings + KotlinTypeMapper.LANGUAGE_VERSION_SETTINGS_DEFAULT, // TODO use proper LanguageVersionSettings + useOldInlineClassesManglingScheme = false ) } diff --git a/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableDeclarationChecker.kt b/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableDeclarationChecker.kt index ab1d15be4de..e7a12992954 100644 --- a/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableDeclarationChecker.kt +++ b/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/parcel/ParcelableDeclarationChecker.kt @@ -195,7 +195,8 @@ class ParcelableDeclarationChecker : DeclarationChecker { bindingContext, ClassBuilderMode.FULL, descriptor.module.name.asString(), - languageVersionSettings + languageVersionSettings, + useOldInlineClassesManglingScheme = false ) for (parameter in primaryConstructor?.valueParameters.orEmpty()) { diff --git a/plugins/parcelize/parcelize-compiler/src/org/jetbrains/kotlin/parcelize/ParcelizeDeclarationChecker.kt b/plugins/parcelize/parcelize-compiler/src/org/jetbrains/kotlin/parcelize/ParcelizeDeclarationChecker.kt index ccdc9a1ec2a..27aa799055b 100644 --- a/plugins/parcelize/parcelize-compiler/src/org/jetbrains/kotlin/parcelize/ParcelizeDeclarationChecker.kt +++ b/plugins/parcelize/parcelize-compiler/src/org/jetbrains/kotlin/parcelize/ParcelizeDeclarationChecker.kt @@ -212,7 +212,8 @@ open class ParcelizeDeclarationChecker : DeclarationChecker { bindingContext, ClassBuilderMode.FULL, descriptor.module.name.asString(), - languageVersionSettings + languageVersionSettings, + useOldInlineClassesManglingScheme = false ) for (parameter in primaryConstructor?.valueParameters.orEmpty()) { diff --git a/plugins/uast-kotlin-idea/src/org/jetbrains/uast/kotlin/internal/IdeaKotlinUastResolveProviderService.kt b/plugins/uast-kotlin-idea/src/org/jetbrains/uast/kotlin/internal/IdeaKotlinUastResolveProviderService.kt index fb3532b971c..4e5536524a7 100644 --- a/plugins/uast-kotlin-idea/src/org/jetbrains/uast/kotlin/internal/IdeaKotlinUastResolveProviderService.kt +++ b/plugins/uast-kotlin-idea/src/org/jetbrains/uast/kotlin/internal/IdeaKotlinUastResolveProviderService.kt @@ -35,7 +35,8 @@ class IdeaKotlinUastResolveProviderService : KotlinUastResolveProviderService { override fun getTypeMapper(element: KtElement): KotlinTypeMapper? { return KotlinTypeMapper( getBindingContext(element), ClassBuilderMode.LIGHT_CLASSES, - JvmProtoBufUtil.DEFAULT_MODULE_NAME, element.languageVersionSettings + JvmProtoBufUtil.DEFAULT_MODULE_NAME, element.languageVersionSettings, + useOldInlineClassesManglingScheme = false ) } diff --git a/plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/internal/CliKotlinUastResolveProviderService.kt b/plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/internal/CliKotlinUastResolveProviderService.kt index a3c93004fe9..c05512eb069 100644 --- a/plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/internal/CliKotlinUastResolveProviderService.kt +++ b/plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/internal/CliKotlinUastResolveProviderService.kt @@ -60,7 +60,8 @@ class UastAnalysisHandlerExtension : AnalysisHandlerExtension { val typeMapper = KotlinTypeMapper( bindingContext, ClassBuilderMode.LIGHT_CLASSES, JvmProtoBufUtil.DEFAULT_MODULE_NAME, - KotlinTypeMapper.LANGUAGE_VERSION_SETTINGS_DEFAULT // TODO use proper LanguageVersionSettings + KotlinTypeMapper.LANGUAGE_VERSION_SETTINGS_DEFAULT, // TODO use proper LanguageVersionSettings + useOldInlineClassesManglingScheme = false ) this.typeMapper = typeMapper return typeMapper