[IR] Fix compiler bugs with MFVC to let KorGE run

Signed-off-by: Evgeniy.Zhelenskiy <Evgeniy.Zhelenskiy@jetbrains.com>

#KT-1179

compiler/backend/src/org/jetbrains/kotlin/codegen/state/inlineClassManglingUtils.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.name.FqNameUnsafe
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.InlineClassDescriptorResolver
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
-import org.jetbrains.kotlin.resolve.isInlineClass
+import org.jetbrains.kotlin.resolve.isValueClass
 import org.jetbrains.kotlin.resolve.jvm.requiresFunctionNameManglingForParameterTypes
 import org.jetbrains.kotlin.resolve.jvm.requiresFunctionNameManglingForReturnType
 import org.jetbrains.kotlin.types.KotlinType
@@ -24,7 +24,7 @@ const val NOT_INLINE_CLASS_PARAMETER_PLACEHOLDER = "_"
 
 class InfoForMangling(
     val fqName: FqNameUnsafe,
-    val isInline: Boolean,
+    val isValue: Boolean,
     val isNullable: Boolean
 )
 
@@ -36,7 +36,7 @@ fun collectFunctionSignatureForManglingSuffix(
 ): String? {
     fun getSignatureElementForMangling(info: InfoForMangling?): String = buildString {
         if (info == null) return ""
-        if (useOldManglingRules || info.isInline) {
+        if (useOldManglingRules || info.isValue) {
             append('L')
             append(info.fqName)
             if (info.isNullable) append('?')
@@ -112,7 +112,7 @@ fun getManglingSuffixBasedOnKotlinSignature(
 private fun getInfoForMangling(type: KotlinType): InfoForMangling? {
     val descriptor = type.constructor.declarationDescriptor ?: return null
     return when (descriptor) {
-        is ClassDescriptor -> InfoForMangling(descriptor.fqNameUnsafe, descriptor.isInlineClass(), type.isMarkedNullable)
+        is ClassDescriptor -> InfoForMangling(descriptor.fqNameUnsafe, descriptor.isValueClass(), type.isMarkedNullable)
 
         is TypeParameterDescriptor -> {
             getInfoForMangling(descriptor.representativeUpperBound)

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java

@@ -51731,6 +51731,12 @@ public class FirLightTreeBlackBoxCodegenTestGenerated extends AbstractFirLightTr
             runTest("compiler/testData/codegen/box/valueClasses/equality.kt");
         }
 
+        @Test
+        @TestMetadata("fakeOverrideCall.kt")
+        public void testFakeOverrideCall() throws Exception {
+            runTest("compiler/testData/codegen/box/valueClasses/fakeOverrideCall.kt");
+        }
+
         @Test
         @TestMetadata("forStatement.kt")
         public void testForStatement() throws Exception {
@@ -51797,6 +51803,12 @@ public class FirLightTreeBlackBoxCodegenTestGenerated extends AbstractFirLightTr
             runTest("compiler/testData/codegen/box/valueClasses/mfvcUntypedEqualsOverriden.kt");
         }
 
+        @Test
+        @TestMetadata("multiModules.kt")
+        public void testMultiModules() throws Exception {
+            runTest("compiler/testData/codegen/box/valueClasses/multiModules.kt");
+        }
+
         @Test
         @TestMetadata("mutableSharedMfvcVar.kt")
         public void testMutableSharedMfvcVar() throws Exception {
@@ -51821,6 +51833,12 @@ public class FirLightTreeBlackBoxCodegenTestGenerated extends AbstractFirLightTr
             runTest("compiler/testData/codegen/box/valueClasses/overrides_typeParameters.kt");
         }
 
+        @Test
+        @TestMetadata("regularClassSecondaryConstructorWithMfvc.kt")
+        public void testRegularClassSecondaryConstructorWithMfvc() throws Exception {
+            runTest("compiler/testData/codegen/box/valueClasses/regularClassSecondaryConstructorWithMfvc.kt");
+        }
+
         @Test
         @TestMetadata("secondaryConstructorsWithBody.kt")
         public void testSecondaryConstructorsWithBody() throws Exception {

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java

@@ -51731,6 +51731,12 @@ public class FirPsiBlackBoxCodegenTestGenerated extends AbstractFirPsiBlackBoxCo
             runTest("compiler/testData/codegen/box/valueClasses/equality.kt");
         }
 
+        @Test
+        @TestMetadata("fakeOverrideCall.kt")
+        public void testFakeOverrideCall() throws Exception {
+            runTest("compiler/testData/codegen/box/valueClasses/fakeOverrideCall.kt");
+        }
+
         @Test
         @TestMetadata("forStatement.kt")
         public void testForStatement() throws Exception {
@@ -51797,6 +51803,12 @@ public class FirPsiBlackBoxCodegenTestGenerated extends AbstractFirPsiBlackBoxCo
             runTest("compiler/testData/codegen/box/valueClasses/mfvcUntypedEqualsOverriden.kt");
         }
 
+        @Test
+        @TestMetadata("multiModules.kt")
+        public void testMultiModules() throws Exception {
+            runTest("compiler/testData/codegen/box/valueClasses/multiModules.kt");
+        }
+
         @Test
         @TestMetadata("mutableSharedMfvcVar.kt")
         public void testMutableSharedMfvcVar() throws Exception {
@@ -51821,6 +51833,12 @@ public class FirPsiBlackBoxCodegenTestGenerated extends AbstractFirPsiBlackBoxCo
             runTest("compiler/testData/codegen/box/valueClasses/overrides_typeParameters.kt");
         }
 
+        @Test
+        @TestMetadata("regularClassSecondaryConstructorWithMfvc.kt")
+        public void testRegularClassSecondaryConstructorWithMfvc() throws Exception {
+            runTest("compiler/testData/codegen/box/valueClasses/regularClassSecondaryConstructorWithMfvc.kt");
+        }
+
         @Test
         @TestMetadata("secondaryConstructorsWithBody.kt")
         public void testSecondaryConstructorsWithBody() throws Exception {

compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt

@@ -684,9 +684,9 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass
                         val instance = targetRemappedParameter.rootMfvcNode.createInstanceFromBox(
                             this,
                             irCastIfNeeded(irGet(bridgeParameter), targetParameterType),
-                            getOptimizedPublicAccess(target, targetRemappedParameter.rootMfvcNode.mfvc)
+                            AccessType.ChooseEffective
                         ) { error("Not applicable") }
-                        val newArguments = instance.makeFlattenedGetterExpressions(this, registerPossibleExtraBoxCreation = {})
+                        val newArguments = instance.makeFlattenedGetterExpressions(this, bridge.parentAsClass, registerPossibleExtraBoxCreation = {})
                         for (newArgument in newArguments) {
                             irCall.putArgument(targetExplicitParameters[targetIndex++], newArgument)
                         }

compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmMultiFieldValueClassLowering.kt

@@ -26,7 +26,11 @@ import org.jetbrains.kotlin.ir.builders.*
 import org.jetbrains.kotlin.ir.builders.declarations.buildFun
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.*
+import org.jetbrains.kotlin.ir.expressions.impl.IrConstructorCallImpl
+import org.jetbrains.kotlin.ir.expressions.impl.IrDelegatingConstructorCallImpl
+import org.jetbrains.kotlin.ir.expressions.impl.IrEnumConstructorCallImpl
 import org.jetbrains.kotlin.ir.expressions.impl.IrFunctionReferenceImpl
+import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
 import org.jetbrains.kotlin.ir.symbols.IrFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.IrSymbol
 import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
@@ -64,6 +68,8 @@ internal class JvmMultiFieldValueClassLowering(
 
     private val irCurrentScope
         get() = currentScope!!.irElement as IrDeclaration
+    private val irCurrentClass
+        get() = currentClass!!.irElement as IrClass
 
     private fun registerPossibleExtraBoxUsage() {
         possibleExtraBoxUsageGenerated.add(irCurrentScope)
@@ -95,7 +101,7 @@ internal class JvmMultiFieldValueClassLowering(
         fun IrBuilderWithScope.makeReplacement(expression: IrGetValue): IrExpression? {
             oldValueSymbol2NewValueSymbol[expression.symbol]?.let { return irGet(it.owner) }
             val instance = oldSymbol2MfvcNodeInstance[expression.symbol] ?: return null
-            val res = instance.makeGetterExpression(this, ::registerPossibleExtraBoxUsage)
+            val res = instance.makeGetterExpression(this, irCurrentClass, ::registerPossibleExtraBoxUsage)
             expression2MfvcNodeInstanceAccessor[res] = MfvcNodeInstanceAccessor.Getter(instance)
             return res
         }
@@ -146,8 +152,8 @@ internal class JvmMultiFieldValueClassLowering(
             val node = replacements.getMfvcFieldNode(field) ?: return null
             val typeArguments = makeTypeArgumentsFromField(expression)
             val instance: ReceiverBasedMfvcNodeInstance =
-                node.createInstanceFromBox(this, typeArguments, expression.receiver, AccessType.AlwaysPrivate, ::variablesSaver)
+                node.createInstanceFromBox(this, typeArguments, expression.receiver, AccessType.UseFields, ::variablesSaver)
-            val getterExpression = instance.makeGetterExpression(this, ::registerPossibleExtraBoxUsage)
+            val getterExpression = instance.makeGetterExpression(this, irCurrentClass, ::registerPossibleExtraBoxUsage)
             expression2MfvcNodeInstanceAccessor[getterExpression] = MfvcNodeInstanceAccessor.Getter(instance)
             +getterExpression
             return getterExpression
@@ -162,7 +168,7 @@ internal class JvmMultiFieldValueClassLowering(
                 scope = this,
                 typeArguments = makeTypeArgumentsFromField(expression),
                 receiver = expression.receiver,
-                accessType = AccessType.AlwaysPrivate,
+                accessType = AccessType.UseFields,
                 saveVariable = ::variablesSaver
             )
             val values: List<IrExpression> = makeFlattenedExpressionsWithGivenSafety(
@@ -182,14 +188,9 @@ internal class JvmMultiFieldValueClassLowering(
             val node = replacements.getMfvcPropertyNode(property) ?: return null
             val typeArguments = makeTypeArgumentsFromFunction(expression)
             // Optimization: pure function access to leaf can be replaced with field access if the field itself is accessible
-            val accessType = when {
-                !node.hasPureUnboxMethod -> AccessType.AlwaysPublic
-                dispatchReceiver == null -> AccessType.PrivateWhenNoBox
-                else -> getOptimizedPublicAccess(dispatchReceiver.type.erasedUpperBound)
-            }
             val instance: ReceiverBasedMfvcNodeInstance =
-                node.createInstanceFromBox(this, typeArguments, dispatchReceiver, accessType, ::variablesSaver)
+                node.createInstanceFromBox(this, typeArguments, dispatchReceiver, AccessType.ChooseEffective, ::variablesSaver)
-            val getterExpression = instance.makeGetterExpression(this, ::registerPossibleExtraBoxUsage)
+            val getterExpression = instance.makeGetterExpression(this, irCurrentClass, ::registerPossibleExtraBoxUsage)
             expression2MfvcNodeInstanceAccessor[getterExpression] = MfvcNodeInstanceAccessor.Getter(instance)
             +getterExpression
             return getterExpression
@@ -238,7 +239,9 @@ internal class JvmMultiFieldValueClassLowering(
             val newAccessor = accessor[name] ?: return@handleSavedExpression null
             val expression = when (newAccessor) {
                 is MfvcNodeInstanceAccessor.Setter -> newAccessor.instance.makeSetterExpressions(scope, newAccessor.values)
-                is MfvcNodeInstanceAccessor.Getter -> newAccessor.instance.makeGetterExpression(scope, ::registerPossibleExtraBoxUsage)
+                is MfvcNodeInstanceAccessor.Getter -> newAccessor.instance.makeGetterExpression(
+                    scope, irCurrentClass, ::registerPossibleExtraBoxUsage
+                )
             }
             expression2MfvcNodeInstanceAccessor[expression] = newAccessor
             expression
@@ -249,7 +252,8 @@ internal class JvmMultiFieldValueClassLowering(
             expression: IrExpression,
             handler: IrBlockBuilder.(values: List<IrExpression>) -> IrExpression
         ): IrExpression? = scope.handleSavedExpression(expression) {
-            irBlock { +handler(it.instance.makeFlattenedGetterExpressions(this, ::registerPossibleExtraBoxUsage)) }.unwrapBlock()
+            irBlock { +handler(it.instance.makeFlattenedGetterExpressions(this, irCurrentClass, ::registerPossibleExtraBoxUsage)) }
+                .unwrapBlock()
         }
 
         fun registerReplacement(expression: IrExpression, instance: MfvcNodeInstance) {
@@ -354,6 +358,9 @@ internal class JvmMultiFieldValueClassLowering(
             val newDeclarations = makeNewDeclarationsForRegularClass(fieldsToRemove, propertiesOrFieldsReplacement, irClass)
             irClass.declarations.replaceAll(newDeclarations)
         }
+        for (field in fieldsToRemove) {
+            field.correspondingPropertySymbol?.owner?.backingField = null
+        }
     }
 
     private fun collectRegularClassMfvcPropertiesOrFieldsReplacement(propertiesOrFields: LinkedHashSet<IrPropertyOrIrField>) =
@@ -416,17 +423,35 @@ internal class JvmMultiFieldValueClassLowering(
 
     override fun handleSpecificNewClass(declaration: IrClass) {
         val rootNode = replacements.getRootMfvcNode(declaration)
-        rootNode.replaceFields()
+        rootNode.replaceMfvcNotStaticFields()
         declaration.declarations += rootNode.allUnboxMethods + listOfNotNull(
             // `takeIf` is a workaround for double addition problem: user-defined typed equals is already defined in the class
             rootNode.boxMethod, rootNode.specializedEqualsMethod.takeIf { rootNode.createdNewSpecializedEqualsMethod }
         )
         rootNode.replacePrimaryMultiFieldValueClassConstructor()
+
+        replaceMfvcStaticFields(declaration)
+    }
+
+    private fun replaceMfvcStaticFields(declaration: IrClass) {
+        val staticFieldMapping: Map<IrField, List<IrDeclaration>> = buildMap {
+            for (staticField in declaration.fields.filter { it.isStatic }) {
+                val node = replacements.getMfvcFieldNode(staticField) ?: continue
+                val fields = node.fields ?: listOf()
+                val initializer = staticField.initializer?.let { makeInitializerReplacement(declaration, staticField, it) }
+                staticField.correspondingPropertySymbol?.owner?.backingField = null
+                put(staticField, fields + listOfNotNull(initializer))
+            }
+        }
+        if (staticFieldMapping.isNotEmpty()) {
+            declaration.declarations.replaceAll(declaration.declarations.flatMap { staticFieldMapping[it] ?: listOf(it) })
+        }
     }
 
     override fun transformSecondaryConstructorFlat(constructor: IrConstructor, replacement: IrSimpleFunction): List<IrDeclaration> {
         for (param in replacement.valueParameters) {
-            param.transformChildrenVoid()
+            param.defaultValue?.patchDeclarationParents(replacement)
+            visitParameter(param)
         }
 
         allScopes.push(createScope(replacement))
@@ -478,9 +503,13 @@ internal class JvmMultiFieldValueClassLowering(
 
     private object UNSAFE_MFVC_SET_ORIGIN : IrStatementOrigin
 
-    private fun RootMfvcNode.replaceFields() {
+    private fun RootMfvcNode.replaceMfvcNotStaticFields() {
-        mfvc.declarations.removeIf { it is IrField && (!it.isStatic || it.type.needsMfvcFlattening()) }
+        val fieldsToRemove = mfvc.fields.filter { !it.isStatic }.toList()
-        mfvc.declarations += fields
+        for (field in fieldsToRemove) {
+            field.correspondingPropertySymbol?.owner?.backingField = null
+        }
+        mfvc.declarations.removeAll(fieldsToRemove)
+        mfvc.declarations += fields ?: emptyList()
     }
 
     override fun createBridgeDeclaration(source: IrSimpleFunction, replacement: IrSimpleFunction, mangledName: Name): IrSimpleFunction =
@@ -613,10 +642,11 @@ internal class JvmMultiFieldValueClassLowering(
                                     val receiver = sourceExplicitParameters[flattenedSourceIndex++]
                                     val rootNode = remappedTargetParameter.rootMfvcNode
                                     val instance = rootNode.createInstanceFromBox(
-                                        this@irBlock, irGet(receiver), getOptimizedPublicAccess(rootNode.mfvc), ::variablesSaver,
+                                        this@irBlock, irGet(receiver), AccessType.ChooseEffective, ::variablesSaver,
+                                    )
+                                    val flattenedExpressions = instance.makeFlattenedGetterExpressions(
+                                        this@irBlock, irCurrentClass, ::registerPossibleExtraBoxUsage
                                     )
-                                    val flattenedExpressions =
-                                        instance.makeFlattenedGetterExpressions(this@irBlock, ::registerPossibleExtraBoxUsage)
                                     for (expression in flattenedExpressions) {
                                         putArgument(targetExplicitParameters[flattenedTargetIndex++], expression)
                                     }
@@ -706,22 +736,43 @@ internal class JvmMultiFieldValueClassLowering(
             val defaultValue = replacements.oldMfvcDefaultArguments[param] ?: continue
             val structure = parametersStructure[i]
             if (structure is MultiFieldValueClassMapping) {
-                newParamList[0].defaultValue = with(context.createJvmIrBuilder(replacement.symbol)) {
+                val fakeFunction = context.irFactory.buildFun {
-                    irExprBody(irBlock {
+                    returnType = context.irBuiltIns.unitType
-                        val mfvcNodeInstance = structure.rootMfvcNode.createInstanceFromValueDeclarationsAndBoxType(
+                    name = Name.identifier("fake")
-                            param.type as IrSimpleType, newParamList
+                    visibility = DescriptorVisibilities.LOCAL
-                        )
+                }.apply { parent = replacement }
-                        flattenExpressionTo(defaultValue, mfvcNodeInstance)
+                newParamList[0].defaultValue = with(context.createJvmIrBuilder(fakeFunction.symbol)) {
-                        +irGet(newParamList[0])
+                    withinScope(fakeFunction) {
-                    })
+                        fakeFunction.body = irExprBody(irBlock {
+                            val mfvcNodeInstance = structure.rootMfvcNode.createInstanceFromValueDeclarationsAndBoxType(
+                                param.type as IrSimpleType, newParamList
+                            )
+                            flattenExpressionTo(defaultValue, mfvcNodeInstance)
+                            +irGet(newParamList[0])
+                        })
+                        postActionAfterTransformingClassDeclaration(fakeFunction)
+                        fakeFunction.body?.patchDeclarationParents(replacement) as IrExpressionBody
+                    }
                 }
             }
         }
     }
 
     override fun visitParameter(parameter: IrValueParameter) {
-        if (parameter.origin != JvmLoweredDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_PARAMETER) {
+        // default MFVC parameter is the special case, it is handled separately
-            super.visitParameter(parameter)
+        if (parameter.origin == JvmLoweredDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_PARAMETER) return
+        if (parameter.defaultValue == null) return
+        val fakeFunction = context.irFactory.buildFun {
+            returnType = context.irBuiltIns.unitType
+            name = Name.identifier("fake")
+            visibility = DescriptorVisibilities.LOCAL
+        }.apply { parent = parameter.parent }
+        parameter.defaultValue = with(context.createJvmIrBuilder(fakeFunction.symbol)) {
+            withinScope(fakeFunction) {
+                fakeFunction.body = irExprBody(parameter.defaultValue!!.expression).transform(this@JvmMultiFieldValueClassLowering, null)
+                postActionAfterTransformingClassDeclaration(fakeFunction)
+                fakeFunction.body?.patchDeclarationParents(parameter.parent) as IrExpressionBody
+            }
         }
     }
 
@@ -732,17 +783,19 @@ internal class JvmMultiFieldValueClassLowering(
 
         val initializersBlocks = mfvc.declarations.filterIsInstance<IrAnonymousInitializer>()
         val typeArguments = makeTypeParameterSubstitutionMap(mfvc, primaryConstructorImpl)
-        primaryConstructorImpl.body = context.createJvmIrBuilder(primaryConstructorImpl.symbol).irBlockBody {
+        if (!mfvc.isKotlinExternalStub()) {
-            val mfvcNodeInstance =
+            primaryConstructorImpl.body = context.createJvmIrBuilder(primaryConstructorImpl.symbol).irBlockBody {
-                ValueDeclarationMfvcNodeInstance(rootMfvcNode, typeArguments, primaryConstructorImpl.valueParameters)
+                val mfvcNodeInstance =
-            valueDeclarationsRemapper.registerReplacement(
+                    ValueDeclarationMfvcNodeInstance(rootMfvcNode, typeArguments, primaryConstructorImpl.valueParameters)
-                oldPrimaryConstructor.constructedClass.thisReceiver!!,
+                valueDeclarationsRemapper.registerReplacement(
-                mfvcNodeInstance
+                    oldPrimaryConstructor.constructedClass.thisReceiver!!,
-            )
+                    mfvcNodeInstance
-            for (initializer in initializersBlocks) {
+                )
-                +irBlock {
+                for (initializer in initializersBlocks) {
-                    for (stmt in initializer.body.statements) {
+                    +irBlock {
-                        +stmt.patchDeclarationParents(primaryConstructorImpl) // transformation is done later
+                        for (stmt in initializer.body.statements) {
+                            +stmt.patchDeclarationParents(primaryConstructorImpl) // transformation is done later
+                        }
                     }
                 }
             }
@@ -793,8 +846,8 @@ internal class JvmMultiFieldValueClassLowering(
                             // thus it is useless to show it in debugger
                             parameter.origin = JvmLoweredDeclarationOrigin.TEMPORARY_MULTI_FIELD_VALUE_CLASS_PARAMETER
                             val rootNode = replacements.getRootMfvcNode(parameter.type.erasedUpperBound)
-                            rootNode.createInstanceFromBox(this, irGet(parameter), AccessType.AlwaysPublic, ::variablesSaver)
+                            rootNode.createInstanceFromBox(this, irGet(parameter), AccessType.ChooseEffective, ::variablesSaver)
-                                .makeFlattenedGetterExpressions(this, ::registerPossibleExtraBoxUsage)
+                                .makeFlattenedGetterExpressions(this, irCurrentClass, ::registerPossibleExtraBoxUsage)
                                 .mapIndexed { index, expression ->
                                     savableStandaloneVariableWithSetter(
                                         expression = expression,
@@ -826,8 +879,8 @@ internal class JvmMultiFieldValueClassLowering(
         }.unwrapBlock()
     }
 
-    private fun IrFunction.getReplacement(): IrFunction? =
+    private fun IrFunction.getReplacement(): IrFunction? = replacements.getReplacementFunction(this)
-        replacements.getReplacementFunction(this) ?: (this as? IrConstructor)?.let { replacements.getReplacementForRegularClassConstructor(it) }
+        ?: (this as? IrConstructor)?.let { replacements.getReplacementForRegularClassConstructor(it) }
 
     private fun makeNewLambda(
         originalFunction: IrFunction, expression: IrFunctionReference, makeBody: (wrapper: IrSimpleFunction) -> IrBody
@@ -886,8 +939,8 @@ internal class JvmMultiFieldValueClassLowering(
 
     override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression {
         val function = expression.symbol.owner
-        val replacement = replacements.getReplacementFunction(function)
         val currentScope = currentScope!!.irElement as IrDeclaration
+        val replacement = replacements.getReplacementFunction(function)
         return when {
             function is IrConstructor && function.isPrimary && function.constructedClass.isMultiFieldValueClass &&
                     currentScope.origin != JvmLoweredDeclarationOrigin.SYNTHETIC_MULTI_FIELD_VALUE_CLASS_MEMBER -> {
@@ -904,7 +957,7 @@ internal class JvmMultiFieldValueClassLowering(
                         valueDeclaration.origin = JvmLoweredDeclarationOrigin.TEMPORARY_MULTI_FIELD_VALUE_CLASS_VARIABLE
                     }
                     flattenExpressionTo(expression, instance)
-                    val getterExpression = instance.makeGetterExpression(this, ::registerPossibleExtraBoxUsage)
+                    val getterExpression = instance.makeGetterExpression(this, irCurrentClass, ::registerPossibleExtraBoxUsage)
                     valueDeclarationsRemapper.registerReplacement(getterExpression, instance)
                     +getterExpression
                 }
@@ -918,8 +971,27 @@ internal class JvmMultiFieldValueClassLowering(
                 val newConstructor = (function as? IrConstructor)
                     ?.let { replacements.getReplacementForRegularClassConstructor(it) }
                     ?: return super.visitFunctionAccess(expression)
+                val callFactory: (IrConstructorSymbol) -> IrFunctionAccessExpression = when (expression) {
+                    is IrConstructorCall -> { constructorSymbol ->
+                        IrConstructorCallImpl.fromSymbolOwner(
+                            expression.startOffset, expression.endOffset, expression.type, constructorSymbol, expression.origin
+                        )
+                    }
+                    is IrDelegatingConstructorCall -> { constructorSymbol ->
+                        IrDelegatingConstructorCallImpl.fromSymbolOwner(
+                            expression.startOffset, expression.endOffset, expression.type, constructorSymbol
+                        )
+                    }
+                    is IrEnumConstructorCall -> { constructorSymbol ->
+                        IrEnumConstructorCallImpl(
+                            expression.startOffset, expression.endOffset, expression.type, constructorSymbol,
+                            expression.typeArgumentsCount, expression.valueArgumentsCount
+                        )
+                    }
+                    else -> error("Unknown constructor call type:\n${expression.dump()}")
+                }
                 context.createJvmIrBuilder(currentScope.symbol, expression).irBlock {
-                    buildReplacement(function, expression, newConstructor)
+                    buildReplacement(function, expression, newConstructor) { callFactory(it as IrConstructorSymbol) }
                 }.unwrapBlock()
             }
         }
@@ -1039,7 +1111,9 @@ internal class JvmMultiFieldValueClassLowering(
         return super.visitStringConcatenation(expression)
     }
 
-    private fun IrBlockBuilder.makeNewArguments(oldArguments: List<IrExpression?>, structure: List<RemappedParameter>): List<IrExpression?> {
+    private fun IrBlockBuilder.makeNewArguments(
+        oldArguments: List<IrExpression?>, structure: List<RemappedParameter>
+    ): List<IrExpression?> {
         val argumentSizes: List<Int> = structure.map { argTemplate -> argTemplate.valueParameters.size }
         val newArguments = (oldArguments zip argumentSizes).flatMapIndexed { index, (oldArgument, parametersCount) ->
             when {
@@ -1271,7 +1345,7 @@ internal class JvmMultiFieldValueClassLowering(
                 +irCall(rootNode.primaryConstructorImpl).apply {
                     copyTypeArgumentsFrom(expression)
                     val flattenedGetterExpressions =
-                        instance.makeFlattenedGetterExpressions(this@flattenExpressionTo, ::registerPossibleExtraBoxUsage)
+                        instance.makeFlattenedGetterExpressions(this@flattenExpressionTo, irCurrentClass, ::registerPossibleExtraBoxUsage)
                     for ((index, leafExpression) in flattenedGetterExpressions.withIndex()) {
                         putValueArgument(index, leafExpression)
                     }
@@ -1290,15 +1364,14 @@ internal class JvmMultiFieldValueClassLowering(
             return
         }
         val expressionInstance = rootNode.createInstanceFromBox(
-            this, transformedExpression, getOptimizedPublicAccess(rootNode.mfvc), ::variablesSaver,
+            this, transformedExpression, AccessType.ChooseEffective, ::variablesSaver,
         )
         require(expressionInstance.size == instance.size) { "Incompatible assignment sizes: ${expressionInstance.size}, ${instance.size}" }
-        instance.addSetterStatements(this, expressionInstance.makeFlattenedGetterExpressions(this, ::registerPossibleExtraBoxUsage))
+        instance.addSetterStatements(
+            this, expressionInstance.makeFlattenedGetterExpressions(this, irCurrentClass, ::registerPossibleExtraBoxUsage)
+        )
     }
 
-    private fun getOptimizedPublicAccess(parent: IrClass): AccessType =
-        currentScope?.irElement?.let { getOptimizedPublicAccess(it, parent) } ?: AccessType.AlwaysPublic
-
     /**
      * Removes boxing when the result is not used
      */

compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmValueClassAbstractLowering.kt

@@ -82,10 +82,10 @@ internal abstract class JvmValueClassAbstractLowering(
 
     private fun transformFlattenedConstructor(function: IrConstructor, replacement: IrConstructor): List<IrDeclaration> {
         replacement.valueParameters.forEach {
-            visitParameter(it)
             it.defaultValue?.patchDeclarationParents(replacement)
+            visitParameter(it)
         }
-        allScopes.push(createScope(function))
+        allScopes.push(createScope(replacement))
         replacement.body = function.body?.transform(this, null)?.patchDeclarationParents(replacement)
         allScopes.pop()
         return listOf(replacement)
@@ -110,8 +110,8 @@ internal abstract class JvmValueClassAbstractLowering(
 
     private fun transformSimpleFunctionFlat(function: IrSimpleFunction, replacement: IrSimpleFunction): List<IrDeclaration> {
         replacement.valueParameters.forEach {
-            visitParameter(it)
             it.defaultValue?.patchDeclarationParents(replacement)
+            visitParameter(it)
         }
         allScopes.push(createScope(replacement))
         replacement.body = function.body?.transform(this, null)?.patchDeclarationParents(replacement)
@@ -170,7 +170,7 @@ internal abstract class JvmValueClassAbstractLowering(
 
     // Anonymous initializers in inline classes are processed when building the primary constructor.
     final override fun visitAnonymousInitializerNew(declaration: IrAnonymousInitializer): IrStatement =
-        if ((declaration.parent as? IrClass)?.isSpecificLoweringLogicApplicable() == true)
+        if ((declaration.parent as? IrClass)?.isSpecificLoweringLogicApplicable() == true && !declaration.isStatic)
             declaration
         else
             super.visitAnonymousInitializerNew(declaration)

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/InlineClassAbi.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.backend.jvm
 
 import org.jetbrains.kotlin.backend.jvm.ir.erasedUpperBound
 import org.jetbrains.kotlin.backend.jvm.ir.isInlineClassType
+import org.jetbrains.kotlin.backend.jvm.ir.isValueClassType
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.codegen.state.InfoForMangling
 import org.jetbrains.kotlin.codegen.state.collectFunctionSignatureForManglingSuffix
@@ -107,7 +108,7 @@ object InlineClassAbi {
             // TODO: Move suspend function view creation before JvmInlineClassLowering.
             if (addContinuation)
                 valueParameters.map { it.asInfoForMangling() } +
-                        InfoForMangling(FqNameUnsafe("kotlin.coroutines.Continuation"), isInline = false, isNullable = false)
+                        InfoForMangling(FqNameUnsafe("kotlin.coroutines.Continuation"), isValue = false, isNullable = false)
             else
                 valueParameters.map { it.asInfoForMangling() },
             returnType?.asInfoForMangling()
@@ -116,7 +117,7 @@ object InlineClassAbi {
     private fun IrType.asInfoForMangling(): InfoForMangling =
         InfoForMangling(
             erasedUpperBound.fqNameWhenAvailable!!.toUnsafe(),
-            isInline = isInlineClassType(),
+            isValue = isValueClassType(),
             isNullable = isNullable()
         )
 

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedMultiFieldValueClassReplacements.kt

@@ -271,12 +271,11 @@ class MemoizedMultiFieldValueClassReplacements(
                         createStaticReplacement(function)
                 }
 
-                function is IrSimpleFunction && !function.isFromJava() &&
+                function is IrSimpleFunction && !function.isFromJava() && function.fullValueParameterList.any { it.type.needsMfvcFlattening() } && run {
-                        function.fullValueParameterList.any { it.type.needsMfvcFlattening() } &&
+                    if (!function.isFakeOverride) return@run true
-                        (!function.isFakeOverride ||
+                    val superDeclaration = findSuperDeclaration(function, false, context.state.jvmDefaultMode)
-                                findSuperDeclaration(function, false, context.state.jvmDefaultMode)
+                    getReplacementFunction(superDeclaration) != null
-                                in bindingOldFunctionToParameterTemplateStructure) ->
+                } -> createMethodReplacement(function)
-                    createMethodReplacement(function)
 
                 else -> null
             }
@@ -341,7 +340,9 @@ class MemoizedMultiFieldValueClassReplacements(
 
     private fun getRegularClassMfvcPropertyNode(property: IrProperty): IntermediateMfvcNode? {
         val parent = property.parent
-        val types = listOfNotNull(property.backingField?.takeUnless { property.isDelegated }?.type, property.getter?.returnType)
+        val types = listOfNotNull(
+            property.backingFieldIfNotToRemove?.takeUnless { property.isDelegated }?.type, property.getter?.returnType
+        )
         return when {
             types.isEmpty() || types.any { !it.needsMfvcFlattening() } -> null
             parent !is IrClass -> null
@@ -364,6 +365,8 @@ class MemoizedMultiFieldValueClassReplacements(
     private fun useRootNode(parent: IrClass, property: IrProperty): Boolean {
         val getter = property.getter
         if (getter != null && (getter.contextReceiverParametersCount > 0 || getter.extensionReceiverParameter != null)) return false
-        return parent.isMultiFieldValueClass && (getter?.isStatic ?: property.backingField?.isStatic) == false
+        return parent.isMultiFieldValueClass && (getter?.isStatic ?: property.backingFieldIfNotToRemove?.isStatic) == false
     }
+
+    private val IrProperty.backingFieldIfNotToRemove get() = backingField?.takeUnless { it in getFieldsToRemove(this.parentAsClass) }
 }

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedValueClassAbstractReplacements.kt

@@ -96,8 +96,15 @@ abstract class MemoizedValueClassAbstractReplacements(
                         // In case this property is declared in an object in another file which is not yet lowered, its backing field will
                         // be made static later. We have to handle it here though, because this new property will be saved to the cache
                         // and reused when lowering the same call in all subsequent files, which would be incorrect if it was not lowered.
-                        backingField = context.cachedDeclarations.getStaticBackingField(propertySymbol.owner)
+                        val existingBackingField = propertySymbol.owner.backingField
-                            ?: propertySymbol.owner.backingField
+                        val skipExistingBackingField = existingBackingField != null && with(context.multiFieldValueClassReplacements) {
+                            getMfvcFieldNode(existingBackingField)
+                            existingBackingField in getFieldsToRemove(propertySymbol.owner.parentAsClass)
+                        }
+                        if (!skipExistingBackingField) {
+                            backingField = context.cachedDeclarations.getStaticBackingField(propertySymbol.owner)
+                                ?: existingBackingField
+                        }
                     }
                 }
                 correspondingPropertySymbol = property.symbol

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNode.kt

@@ -6,7 +6,8 @@
 package org.jetbrains.kotlin.backend.jvm
 
 import org.jetbrains.kotlin.backend.jvm.NameableMfvcNodeImpl.Companion.MethodFullNameMode
-import org.jetbrains.kotlin.backend.jvm.NameableMfvcNodeImpl.Companion.MethodFullNameMode.*
+import org.jetbrains.kotlin.backend.jvm.NameableMfvcNodeImpl.Companion.MethodFullNameMode.Getter
+import org.jetbrains.kotlin.backend.jvm.NameableMfvcNodeImpl.Companion.MethodFullNameMode.UnboxFunction
 import org.jetbrains.kotlin.backend.jvm.ir.erasedUpperBound
 import org.jetbrains.kotlin.backend.jvm.ir.isMultiFieldValueClassType
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
@@ -84,6 +85,7 @@ fun makeTypeArgumentsFromType(type: IrSimpleType): TypeArguments {
 
 sealed interface NameableMfvcNode : MfvcNode {
     val namedNodeImpl: NameableMfvcNodeImpl
+    val hasPureUnboxMethod: Boolean
 }
 
 val NameableMfvcNode.nameParts: List<Name>
@@ -96,15 +98,12 @@ val NameableMfvcNode.fullMethodName: Name
     get() = namedNodeImpl.fullMethodName
 val NameableMfvcNode.fullFieldName: Name
     get() = namedNodeImpl.fullFieldName
-val NameableMfvcNode.hasPureUnboxMethod: Boolean
-    get() = namedNodeImpl.hasPureUnboxMethod
 
 
 class NameableMfvcNodeImpl(
     methodFullNameMode: MethodFullNameMode,
     val nameParts: List<Name>,
     val unboxMethod: IrSimpleFunction,
-    val hasPureUnboxMethod: Boolean,
 ) {
     val fullMethodName = makeFullMethodName(methodFullNameMode, nameParts)
     val fullFieldName = makeFullFieldName(nameParts)
@@ -239,8 +238,8 @@ val MfvcNodeWithSubnodes.leaves: List<LeafMfvcNode>
     get() = subnodesImpl.leaves
 val MfvcNodeWithSubnodes.fields: List<IrField>?
     get() = subnodesImpl.fields
-val RootMfvcNode.fields: List<IrField>
+val RootMfvcNode.fields: List<IrField>?
-    get() = subnodesImpl.fields!!
+    get() = subnodesImpl.fields
 val MfvcNodeWithSubnodes.indices: IntRange
     get() = subnodesImpl.indices
 val MfvcNodeWithSubnodes.subnodeIndices: Map<NameableMfvcNode, IntRange>
@@ -286,9 +285,11 @@ class LeafMfvcNode(
     nameParts: List<Name>,
     val field: IrField?,
     unboxMethod: IrSimpleFunction,
-    hasPureUnboxMethod: Boolean,
+    defaultMethodsImplementationSourceNode: UnboxFunctionImplementation
 ) : NameableMfvcNode {
-    override val namedNodeImpl: NameableMfvcNodeImpl = NameableMfvcNodeImpl(methodFullNameMode, nameParts, unboxMethod, hasPureUnboxMethod)
+
+    override val hasPureUnboxMethod: Boolean = defaultMethodsImplementationSourceNode.hasPureUnboxMethod
+    override val namedNodeImpl: NameableMfvcNodeImpl = NameableMfvcNodeImpl(methodFullNameMode, nameParts, unboxMethod)
 
     override val leavesCount: Int
         get() = 1
@@ -327,10 +328,12 @@ class IntermediateMfvcNode(
     nameParts: List<Name>,
     subnodes: List<NameableMfvcNode>,
     unboxMethod: IrSimpleFunction,
-    hasPureUnboxMethod: Boolean,
+    defaultMethodsImplementationSourceNode: UnboxFunctionImplementation,
     val rootNode: RootMfvcNode, // root node corresponding type of the node
 ) : NameableMfvcNode, MfvcNodeWithSubnodes {
-    override val namedNodeImpl: NameableMfvcNodeImpl = NameableMfvcNodeImpl(methodFullNameMode, nameParts, unboxMethod, hasPureUnboxMethod)
+    override val hasPureUnboxMethod: Boolean =
+        defaultMethodsImplementationSourceNode.hasPureUnboxMethod && subnodes.all { it.hasPureUnboxMethod }
+    override val namedNodeImpl: NameableMfvcNodeImpl = NameableMfvcNodeImpl(methodFullNameMode, nameParts, unboxMethod)
     override val subnodesImpl: MfvcNodeWithSubnodesImpl = MfvcNodeWithSubnodesImpl(subnodes, unboxMethod)
     override val leavesCount
         get() = leaves.size
@@ -401,7 +404,7 @@ class RootMfvcNode internal constructor(
     override val leavesUnboxMethods: List<IrSimpleFunction> = collectLeavesUnboxMethods()
 
     init {
-        require(type.needsMfvcFlattening()) { "MFVC type expected but got% ${type.render()}" }
+        require(type.needsMfvcFlattening()) { "MFVC type expected but got: ${type.render()}" }
         for (constructor in listOf(oldPrimaryConstructor, newPrimaryConstructor)) {
             require(constructor.isPrimary) { "Expected a primary constructor but got:\n${constructor.dump()}" }
         }

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNodeFactory.kt

@@ -7,10 +7,10 @@ package org.jetbrains.kotlin.backend.jvm
 
 import org.jetbrains.kotlin.backend.common.lower.createIrBuilder
 import org.jetbrains.kotlin.backend.common.lower.irBlockBody
-import org.jetbrains.kotlin.backend.common.lower.parents
 import org.jetbrains.kotlin.backend.jvm.IrPropertyOrIrField.Field
 import org.jetbrains.kotlin.backend.jvm.IrPropertyOrIrField.Property
 import org.jetbrains.kotlin.backend.jvm.NameableMfvcNodeImpl.Companion.MethodFullNameMode
+import org.jetbrains.kotlin.backend.jvm.UnboxFunctionImplementation.*
 import org.jetbrains.kotlin.backend.jvm.ir.createJvmIrBuilder
 import org.jetbrains.kotlin.backend.jvm.ir.erasedUpperBound
 import org.jetbrains.kotlin.backend.jvm.ir.upperBound
@@ -18,7 +18,6 @@ import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilities
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.MultiFieldValueClassRepresentation
-import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.builders.*
 import org.jetbrains.kotlin.ir.builders.declarations.addValueParameter
 import org.jetbrains.kotlin.ir.builders.declarations.buildConstructor
@@ -36,7 +35,7 @@ import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
 fun createLeafMfvcNode(
-    parent: IrDeclarationContainer,
+    parent: IrClass,
     context: JvmBackendContext,
     type: IrType,
     methodFullNameMode: MethodFullNameMode,
@@ -44,7 +43,7 @@ fun createLeafMfvcNode(
     fieldAnnotations: List<IrConstructorCall>,
     static: Boolean,
     overriddenNode: LeafMfvcNode?,
-    defaultMethodsImplementationSourceNode: Pair<IrSimpleFunction?, LeafMfvcNode>?, // used if the getter was custom and need to call it.
+    defaultMethodsImplementationSourceNode: UnboxFunctionImplementation,
     oldGetter: IrSimpleFunction?,
     modality: Modality,
     oldPropertyBackingField: IrField?,
@@ -79,22 +78,19 @@ fun createLeafMfvcNode(
         modality,
     ) { receiver -> irGetField(if (field!!.isStatic) null else irGet(receiver!!), field) }
 
-    return LeafMfvcNode(type, methodFullNameMode, nameParts, field, unboxMethod, defaultMethodsImplementationSourceNode.isPure())
+    return LeafMfvcNode(type, methodFullNameMode, nameParts, field, unboxMethod, defaultMethodsImplementationSourceNode)
 }
 
-private fun Pair<IrSimpleFunction?, NameableMfvcNode>?.isPure(): Boolean {
+fun IrClass.isKotlinExternalStub() = origin == IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB
-    val (outer, inner) = this ?: return true
-    return outer == null && inner.hasPureUnboxMethod
-}
 
 private fun makeUnboxMethod(
     context: JvmBackendContext,
     fullMethodName: Name,
     type: IrType,
-    parent: IrDeclarationParent,
+    parent: IrClass,
     overriddenNode: NameableMfvcNode?,
     static: Boolean,
-    defaultMethodsImplementationSourceNode: Pair<IrSimpleFunction?, NameableMfvcNode>?,
+    defaultMethodsImplementationSourceNode: UnboxFunctionImplementation,
     oldGetter: IrSimpleFunction?,
     modality: Modality,
     makeOptimizedExpression: IrBuilderWithScope.(receiver: IrValueDeclaration?) -> IrExpression,
@@ -113,23 +109,63 @@ private fun makeUnboxMethod(
     }
 
     return res.apply {
-        body = with(context.createJvmIrBuilder(this.symbol)) {
+        if (!parent.isKotlinExternalStub()) {
-            val receiver = dispatchReceiverParameter
+            body = with(context.createJvmIrBuilder(this.symbol)) {
-            if (defaultMethodsImplementationSourceNode == null) {
+                val receiver = dispatchReceiverParameter
-                irExprBody(makeOptimizedExpression(receiver))
+                if (defaultMethodsImplementationSourceNode.hasPureUnboxMethod) {
-            } else {
+                    irExprBody(makeOptimizedExpression(receiver))
-                val (outer, inner) = defaultMethodsImplementationSourceNode
+                } else {
-                val receiverExpression = receiver?.let { irGet(it) }
+                    val receiverExpression: IrExpression? = receiver?.let { irGet(it) }
-                val outerCall = if (outer == null) receiverExpression else irCall(outer).apply { dispatchReceiver = receiverExpression }
+                    val unboxMethodsToCall = when (defaultMethodsImplementationSourceNode) {
-                val innerCall = irCall(inner.unboxMethod).apply { dispatchReceiver = outerCall }
+                        DefaultUnboxFunctionImplementation -> error("$defaultMethodsImplementationSourceNode is expected to be pure")
-                irExprBody(innerCall)
+                        ExternalUnboxFunctionImplementation -> error("${parent.render()} is expected to be external")
+                        is DelegatingUnboxFunctionImplementation -> listOf(defaultMethodsImplementationSourceNode.node.unboxMethod)
+                        is CustomUnboxFunctionImplementation -> listOfNotNull(
+                            defaultMethodsImplementationSourceNode.getter,
+                            (defaultMethodsImplementationSourceNode.node as? NameableMfvcNode)?.unboxMethod
+                        )
+                    }
+                    val expression = unboxMethodsToCall.fold(receiverExpression) { arg, f -> irCall(f).apply { dispatchReceiver = arg } }
+                    irExprBody(expression!!)
+                }
             }
         }
     }
 }
 
+
+sealed class UnboxFunctionImplementation {
+    abstract val hasPureUnboxMethod: Boolean
+
+    object DefaultUnboxFunctionImplementation : UnboxFunctionImplementation() {
+        override val hasPureUnboxMethod: Boolean get() = true
+    }
+
+    object ExternalUnboxFunctionImplementation : UnboxFunctionImplementation() {
+        override val hasPureUnboxMethod: Boolean get() = false
+    }
+
+    data class DelegatingUnboxFunctionImplementation(val node: NameableMfvcNode) : UnboxFunctionImplementation() {
+        override val hasPureUnboxMethod: Boolean = node.hasPureUnboxMethod
+    }
+
+    data class CustomUnboxFunctionImplementation(val getter: IrSimpleFunction, val node: MfvcNode) : UnboxFunctionImplementation() {
+        override val hasPureUnboxMethod: Boolean get() = false
+    }
+
+    operator fun get(name: Name): UnboxFunctionImplementation {
+        fun nextNode(node: MfvcNode) = (node as MfvcNodeWithSubnodes)[name]!!
+        return when (this) {
+            is CustomUnboxFunctionImplementation -> copy(node = nextNode(node))
+            is DelegatingUnboxFunctionImplementation -> copy(node = nextNode(node))
+            DefaultUnboxFunctionImplementation -> DefaultUnboxFunctionImplementation
+            ExternalUnboxFunctionImplementation -> ExternalUnboxFunctionImplementation
+        }
+    }
+}
+
 fun createNameableMfvcNodes(
-    parent: IrDeclarationContainer,
+    parent: IrClass,
     context: JvmBackendContext,
     type: IrSimpleType,
     typeArguments: TypeArguments,
@@ -138,7 +174,7 @@ fun createNameableMfvcNodes(
     fieldAnnotations: List<IrConstructorCall>,
     static: Boolean,
     overriddenNode: NameableMfvcNode?,
-    defaultMethodsImplementationSourceNode: Pair<IrSimpleFunction?, NameableMfvcNode>?, // used if the getter was custom and need to call it.
+    defaultMethodsImplementationSourceNode: UnboxFunctionImplementation,
     oldGetter: IrSimpleFunction?,
     modality: Modality,
     oldPropertyBackingField: IrField?,
@@ -152,7 +188,7 @@ fun createNameableMfvcNodes(
     fieldAnnotations,
     static,
     overriddenNode as IntermediateMfvcNode?,
-    defaultMethodsImplementationSourceNode?.let { (outer, inner) -> outer to (inner as IntermediateMfvcNode) },
+    defaultMethodsImplementationSourceNode,
     oldGetter,
     modality,
     oldPropertyBackingField,
@@ -165,14 +201,14 @@ fun createNameableMfvcNodes(
     fieldAnnotations,
     static,
     overriddenNode as LeafMfvcNode?,
-    defaultMethodsImplementationSourceNode?.let { (outer, inner) -> outer to (inner as LeafMfvcNode) },
+    defaultMethodsImplementationSourceNode,
     oldGetter,
     modality,
     oldPropertyBackingField
 )
 
 fun createIntermediateMfvcNode(
-    parent: IrDeclarationContainer,
+    parent: IrClass,
     context: JvmBackendContext,
     type: IrSimpleType,
     typeArguments: TypeArguments,
@@ -181,7 +217,7 @@ fun createIntermediateMfvcNode(
     fieldAnnotations: List<IrConstructorCall>,
     static: Boolean,
     overriddenNode: IntermediateMfvcNode?,
-    defaultMethodsImplementationSourceNode: Pair<IrSimpleFunction?, IntermediateMfvcNode>?, // used if the getter was custom and need to call it.
+    defaultMethodsImplementationSourceNode: UnboxFunctionImplementation?,
     oldGetter: IrSimpleFunction?,
     modality: Modality,
     oldPropertyBackingField: IrField?,
@@ -202,15 +238,12 @@ fun createIntermediateMfvcNode(
         val newType = type.substitute(typeArguments) as IrSimpleType
         val newTypeArguments = typeArguments.toMutableMap().apply { putAll(makeTypeArgumentsFromType(newType)) }
         val newDefaultMethodsImplementationSourceNode = when {
-            defaultMethodsImplementationSourceNode != null -> {
+            defaultMethodsImplementationSourceNode != null -> defaultMethodsImplementationSourceNode[name]
-                val (outer, inner) = defaultMethodsImplementationSourceNode
+            shadowBackingFieldProperty != null -> DelegatingUnboxFunctionImplementation(
-                require(!useOldGetter) { "Multiple non-default getters:\n\n${outer?.dump()}\n\n${oldGetter?.dump()}" }
+                replacements.getMfvcPropertyNode(shadowBackingFieldProperty)!!
-                outer to inner[name]!!
+            )
-            }
+            useOldGetter -> CustomUnboxFunctionImplementation(oldGetter!!, rootNode[name]!!)
-
+            else -> DefaultUnboxFunctionImplementation
-            shadowBackingFieldProperty != null -> null to replacements.getMfvcPropertyNode(shadowBackingFieldProperty)!!
-            useOldGetter -> oldGetter!! to rootNode[name]!!
-            else -> null
         }
         createNameableMfvcNodes(
             parent,
@@ -231,56 +264,78 @@ fun createIntermediateMfvcNode(
 
     val fullMethodName = NameableMfvcNodeImpl.makeFullMethodName(methodFullNameMode, nameParts)
 
-    val unboxMethod = if (useOldGetter) oldGetter!! else makeUnboxMethod(
+    val unboxMethod: IrSimpleFunction
-        context, fullMethodName, type, parent, overriddenNode, static, defaultMethodsImplementationSourceNode, oldGetter, modality
+    val unboxFunctionImplementation: UnboxFunctionImplementation
-    ) { receiver ->
+    if (useOldGetter) {
-        val valueArguments = subnodes.flatMap { it.fields!! }
+        unboxMethod = oldGetter!!
-            .map { field -> irGetField(if (field.isStatic) null else irGet(receiver!!), field) }
+        unboxFunctionImplementation = defaultMethodsImplementationSourceNode ?: CustomUnboxFunctionImplementation(unboxMethod, rootNode)
-        rootNode.makeBoxedExpression(this, typeArguments, valueArguments, registerPossibleExtraBoxCreation = {})
+    } else {
+        unboxFunctionImplementation = defaultMethodsImplementationSourceNode ?: DefaultUnboxFunctionImplementation
+        unboxMethod = makeUnboxMethod(
+            context, fullMethodName, type, parent, overriddenNode, static, unboxFunctionImplementation, oldGetter, modality
+        ) { receiver ->
+            val valueArguments = subnodes.flatMap { it.fields!! }
+                .map { field -> irGetField(if (field.isStatic) null else irGet(receiver!!), field) }
+            rootNode.makeBoxedExpression(this, typeArguments, valueArguments, registerPossibleExtraBoxCreation = {})
+        }
     }
-
+    return IntermediateMfvcNode(type, methodFullNameMode, nameParts, subnodes, unboxMethod, unboxFunctionImplementation, rootNode)
-    val hasPureUnboxMethod = defaultMethodsImplementationSourceNode.isPure() && subnodes.all { it.hasPureUnboxMethod }
-    return IntermediateMfvcNode(
-        type, methodFullNameMode, nameParts, subnodes, unboxMethod, hasPureUnboxMethod, rootNode
-    )
 }
 
 fun collectPropertiesAfterLowering(irClass: IrClass, context: JvmBackendContext): LinkedHashSet<IrProperty> =
     LinkedHashSet(collectPropertiesOrFieldsAfterLowering(irClass, context).map { (it as Property).property })
 
 sealed class IrPropertyOrIrField {
-    data class Property(val property: IrProperty) : IrPropertyOrIrField()
+    data class Property(val property: IrProperty) : IrPropertyOrIrField() {
-    data class Field(val field: IrField) : IrPropertyOrIrField()
+        override fun toString(): String = property.dump()
+    }
+
+    data class Field(val field: IrField) : IrPropertyOrIrField() {
+        override fun toString(): String = field.dump()
+    }
 }
 
 fun collectPropertiesOrFieldsAfterLowering(irClass: IrClass, context: JvmBackendContext): LinkedHashSet<IrPropertyOrIrField> =
     LinkedHashSet<IrPropertyOrIrField>().apply {
-        for (element in irClass.declarations) {
+        fun handleField(element: IrField) {
-            if (element is IrField) {
+            val property = element.correspondingPropertySymbol?.owner
-                val property = element.correspondingPropertySymbol?.owner
+            if (
-                if (
+                property != null && !property.isDelegated &&
-                    property != null && !property.isDelegated &&
+                !context.multiFieldValueClassReplacements.getFieldsToRemove(element.parentAsClass).contains(element)
-                    !context.multiFieldValueClassReplacements.getFieldsToRemove(element.parentAsClass).contains(element)
+            ) {
-                ) {
+                add(Property(property))
-                    add(Property(property))
+            } else {
-                } else {
+                add(Field(element))
-                    add(Field(element))
+            }
-                }
+        }
-            } else if (element is IrSimpleFunction && element.extensionReceiverParameter == null && element.contextReceiverParametersCount == 0) {
+
+        fun handleAccessor(element: IrSimpleFunction) {
+            if (element.extensionReceiverParameter == null && element.contextReceiverParametersCount == 0) {
                 element.correspondingPropertySymbol?.owner?.let { add(Property(it)) }
             }
         }
+
+        for (element in irClass.declarations) {
+            when (element) {
+                is IrField -> handleField(element)
+                is IrSimpleFunction -> handleAccessor(element)
+                is IrProperty -> {
+                    element.backingField?.let(::handleField)
+                    element.getter?.let(::handleAccessor)
+                }
+            }
+        }
     }
 
 private fun IrProperty.isStatic(currentContainer: IrDeclarationContainer) =
     getterIfDeclared(currentContainer)?.isStatic
         ?: backingFieldIfNotDelegate?.isStatic
-        ?: error("Property without both getter and backing field")
+        ?: error("Property without both getter and backing field:\n${dump()}")
 
 fun getRootNode(context: JvmBackendContext, mfvc: IrClass): RootMfvcNode {
     require(mfvc.isMultiFieldValueClass) { "${mfvc.defaultType.render()} does not require flattening" }
     val oldPrimaryConstructor = mfvc.primaryConstructor!!
-    val oldFields = mfvc.fields.filter { !it.isStatic }.toList()
+    val oldFields = mfvc.declarations.mapNotNull { it as? IrField ?: (it as? IrProperty)?.backingField }.filter { !it.isStatic }
     val representation = mfvc.multiFieldValueClassRepresentation!!
     val properties = collectPropertiesAfterLowering(mfvc, context).associateBy { it.isStatic(mfvc) to it.name }
 
@@ -288,7 +343,7 @@ fun getRootNode(context: JvmBackendContext, mfvc: IrClass): RootMfvcNode {
 
     val mfvcNodeWithSubnodesImpl = MfvcNodeWithSubnodesImpl(subnodes, null)
     val leaves = mfvcNodeWithSubnodesImpl.leaves
-    val fields = mfvcNodeWithSubnodesImpl.fields!!
+    val fields = mfvcNodeWithSubnodesImpl.fields
 
     val newPrimaryConstructor = makeMfvcPrimaryConstructor(context, oldPrimaryConstructor, mfvc, leaves, fields)
     val primaryConstructorImpl = makePrimaryConstructorImpl(context, oldPrimaryConstructor, mfvc, leaves, mfvcNodeWithSubnodesImpl)
@@ -328,23 +383,24 @@ private fun makeSpecializedEqualsMethod(
         name = Name.identifier("other")
         type = mfvc.defaultType.upperBound
     }
-
+    if (!mfvc.isKotlinExternalStub()) {
-    body = with(context.createJvmIrBuilder(this.symbol)) {
+        body = with(context.createJvmIrBuilder(this.symbol)) {
-        if (customEqualsAny != null) {
+            if (customEqualsAny != null) {
-            irExprBody(irCall(customEqualsAny).apply {
+                irExprBody(irCall(customEqualsAny).apply {
-                dispatchReceiver = irGet(dispatchReceiverParameter!!)
+                    dispatchReceiver = irGet(dispatchReceiverParameter!!)
-                putValueArgument(0, irGet(other))
+                    putValueArgument(0, irGet(other))
-            })
+                })
-        } else {
+            } else {
-            val leftArgs = oldFields.map { irGetField(irGet(dispatchReceiverParameter!!), it) }
+                val leftArgs = oldFields.map { irGetField(irGet(dispatchReceiverParameter!!), it) }
-            val rightArgs = oldFields.map { irGetField(irGet(other), it) }
+                val rightArgs = oldFields.map { irGetField(irGet(other), it) }
-            val conjunctions = leftArgs.zip(rightArgs) { l, r -> irEquals(l, r) }
+                val conjunctions = leftArgs.zip(rightArgs) { l, r -> irEquals(l, r) }
-            irExprBody(conjunctions.reduce { acc, current ->
+                irExprBody(conjunctions.reduce { acc, current ->
-                irCall(context.irBuiltIns.andandSymbol).apply {
+                    irCall(context.irBuiltIns.andandSymbol).apply {
-                    putValueArgument(0, acc)
+                        putValueArgument(0, acc)
-                    putValueArgument(1, current)
+                        putValueArgument(1, current)
-                }
+                    }
-            })
+                })
+            }
         }
     }
 }
@@ -366,12 +422,14 @@ private fun makeBoxMethod(
     }.toMap()
     returnType = returnType.substitute(mapping)
     val parameters = leaves.map { leaf -> addValueParameter(leaf.fullFieldName, leaf.type.substitute(mapping)) }
-    body = with(context.createJvmIrBuilder(this.symbol)) {
+    if (!mfvc.isKotlinExternalStub()) {
-        irExprBody(irCall(newPrimaryConstructor).apply {
+        body = with(context.createJvmIrBuilder(this.symbol)) {
-            for ((index, parameter) in parameters.withIndex()) {
+            irExprBody(irCall(newPrimaryConstructor).apply {
-                putValueArgument(index, irGet(parameter))
+                for ((index, parameter) in parameters.withIndex()) {
-            }
+                    putValueArgument(index, irGet(parameter))
-        })
+                }
+            })
+        }
     }
 }
 
@@ -414,7 +472,7 @@ private fun makeMfvcPrimaryConstructor(
     oldPrimaryConstructor: IrConstructor,
     mfvc: IrClass,
     leaves: List<LeafMfvcNode>,
-    fields: List<IrField>
+    fields: List<IrField>?
 ) = context.irFactory.buildConstructor {
     updateFrom(oldPrimaryConstructor)
     visibility = DescriptorVisibilities.PRIVATE
@@ -425,10 +483,12 @@ private fun makeMfvcPrimaryConstructor(
     this.parent = mfvc
     val parameters = leaves.map { addValueParameter(it.fullFieldName, it.type) }
     val irConstructor = this@apply
-    body = context.createIrBuilder(irConstructor.symbol).irBlockBody(irConstructor) {
+    if (!mfvc.isKotlinExternalStub()) {
-        +irDelegatingConstructorCall(context.irBuiltIns.anyClass.owner.constructors.single())
+        body = context.createIrBuilder(irConstructor.symbol).irBlockBody(irConstructor) {
-        for ((field, parameter) in fields zip parameters) {
+            +irDelegatingConstructorCall(context.irBuiltIns.anyClass.owner.constructors.single())
-            +irSetField(irGet(mfvc.thisReceiver!!), field, irGet(parameter))
+            for ((field, parameter) in fields!! zip parameters) {
+                +irSetField(irGet(mfvc.thisReceiver!!), field, irGet(parameter))
+            }
         }
     }
 }
@@ -455,7 +515,7 @@ private fun makeRootMfvcNodeSubnodes(
         oldBackingField?.annotations ?: listOf(),
         static,
         overriddenNode,
-        null,
+        DefaultUnboxFunctionImplementation,
         oldGetter.takeIf { static },
         Modality.FINAL,
         oldBackingField,
@@ -471,12 +531,13 @@ private fun updateAnnotationsAndPropertyFromOldProperty(
     node: MfvcNode,
 ) {
     if (node is LeafMfvcNode) return
-    oldProperty.backingField?.let { context.multiFieldValueClassReplacements.addFieldToRemove(it.parentAsClass, it) }
+    oldProperty.backingField?.let {
-    oldProperty.backingField = null
+        context.multiFieldValueClassReplacements.addFieldToRemove(it.parentAsClass, it)
+    }
 }
 
 fun createIntermediateNodeForMfvcPropertyOfRegularClass(
-    parent: IrDeclarationContainer,
+    parent: IrClass,
     context: JvmBackendContext,
     oldProperty: IrProperty,
 ): IntermediateMfvcNode {
@@ -488,16 +549,17 @@ fun createIntermediateNodeForMfvcPropertyOfRegularClass(
     val static = oldProperty.isStatic(parent)
     val overriddenNode = oldGetter?.let { getOverriddenNode(context.multiFieldValueClassReplacements, it) as IntermediateMfvcNode? }
     val modality = if (oldGetter == null || oldGetter.modality == Modality.FINAL) Modality.FINAL else oldGetter.modality
+    val defaultMethodsImplementationSourceNode = if (parent.isKotlinExternalStub()) ExternalUnboxFunctionImplementation else null
     return createIntermediateMfvcNode(
         parent, context, type, makeTypeArgumentsFromType(type), MethodFullNameMode.Getter, listOf(oldProperty.name),
-        fieldAnnotations, static, overriddenNode, null, oldGetter, modality, oldField
+        fieldAnnotations, static, overriddenNode, defaultMethodsImplementationSourceNode, oldGetter, modality, oldField
     ).also {
         updateAnnotationsAndPropertyFromOldProperty(oldProperty, context, it)
     }
 }
 
 fun createIntermediateNodeForStandaloneMfvcField(
-    parent: IrDeclarationContainer,
+    parent: IrClass,
     context: JvmBackendContext,
     oldField: IrField,
 ): IntermediateMfvcNode {
@@ -514,19 +576,7 @@ private fun getOverriddenNode(replacements: MemoizedMultiFieldValueClassReplacem
         .firstOrNull { !it.owner.isFakeOverride }
         ?.let { replacements.getMfvcPropertyNode(it.owner.correspondingPropertySymbol!!.owner) }
 
-fun getOptimizedPublicAccess(currentElement: IrElement?, parent: IrClass): AccessType {
+private fun IrProperty.getterIfDeclared(parent: IrDeclarationContainer): IrSimpleFunction? =
-    val declaration = currentElement as? IrDeclaration ?: return AccessType.AlwaysPublic
+    getter?.takeIf { it in parent.declarations || this in parent.declarations }
-    for (cur in declaration.parents.filterIsInstance<IrClass>()) {
-        return when {
-            cur == parent -> AccessType.PrivateWhenNoBox
-            cur.isInner -> continue
-            cur.isCompanion -> continue
-            else -> AccessType.AlwaysPublic
-        }
-    }
-    return AccessType.AlwaysPublic
-}
-
-private fun IrProperty.getterIfDeclared(parent: IrDeclarationContainer): IrSimpleFunction? = getter?.takeIf { it in parent.declarations }
 
 private val IrProperty.backingFieldIfNotDelegate get() = backingField?.takeUnless { isDelegated }

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNodeInstance.kt

@@ -23,8 +23,11 @@ interface MfvcNodeInstance {
     val typeArguments: TypeArguments
     val type: IrSimpleType
 
-    fun makeFlattenedGetterExpressions(scope: IrBlockBuilder, registerPossibleExtraBoxCreation: () -> Unit): List<IrExpression>
+    fun makeFlattenedGetterExpressions(
-    fun makeGetterExpression(scope: IrBuilderWithScope, registerPossibleExtraBoxCreation: () -> Unit): IrExpression
+        scope: IrBlockBuilder, currentClass: IrClass, registerPossibleExtraBoxCreation: () -> Unit
+    ): List<IrExpression>
+
+    fun makeGetterExpression(scope: IrBuilderWithScope, currentClass: IrClass, registerPossibleExtraBoxCreation: () -> Unit): IrExpression
     operator fun get(name: Name): MfvcNodeInstance?
     fun makeStatements(scope: IrBuilderWithScope, values: List<IrExpression>): List<IrStatement>
 }
@@ -57,12 +60,12 @@ class ValueDeclarationMfvcNodeInstance(
 
     override val type: IrSimpleType = makeTypeFromMfvcNodeAndTypeArguments(node, typeArguments)
 
-    override fun makeFlattenedGetterExpressions(scope: IrBlockBuilder, registerPossibleExtraBoxCreation: () -> Unit): List<IrExpression> =
+    override fun makeFlattenedGetterExpressions(scope: IrBlockBuilder, currentClass: IrClass, registerPossibleExtraBoxCreation: () -> Unit): List<IrExpression> =
         makeFlattenedGetterExpressions(scope as IrBuilderWithScope)
 
     private fun makeFlattenedGetterExpressions(scope: IrBuilderWithScope): List<IrExpression> = valueDeclarations.map { scope.irGet(it) }
 
-    override fun makeGetterExpression(scope: IrBuilderWithScope, registerPossibleExtraBoxCreation: () -> Unit): IrExpression = when (node) {
+    override fun makeGetterExpression(scope: IrBuilderWithScope, currentClass: IrClass, registerPossibleExtraBoxCreation: () -> Unit): IrExpression = when (node) {
         is LeafMfvcNode -> makeFlattenedGetterExpressions(scope).single()
         is MfvcNodeWithSubnodes -> node.makeBoxedExpression(
             scope, typeArguments, makeFlattenedGetterExpressions(scope), registerPossibleExtraBoxCreation
@@ -138,7 +141,7 @@ fun IrExpression?.isRepeatableSetter(): Boolean = when (this) {
 
 fun IrExpression?.isRepeatableAccessor(): Boolean = isRepeatableGetter() || isRepeatableSetter()
 
-enum class AccessType { AlwaysPublic, PrivateWhenNoBox, AlwaysPrivate }
+enum class AccessType { UseFields, ChooseEffective }
 
 class ReceiverBasedMfvcNodeInstance(
     private val scope: IrBlockBuilder,
@@ -162,20 +165,23 @@ class ReceiverBasedMfvcNodeInstance(
     }
 
     override fun makeFlattenedGetterExpressions(
-        scope: IrBlockBuilder, registerPossibleExtraBoxCreation: () -> Unit
+        scope: IrBlockBuilder, currentClass: IrClass, registerPossibleExtraBoxCreation: () -> Unit
-    ): List<IrExpression> = when (node) {
+    ): List<IrExpression> = makeFlattenedGetterExpressions(scope, currentClass, isInsideRecursion = false, registerPossibleExtraBoxCreation)
-        is LeafMfvcNode -> listOf(makeGetterExpression(scope, registerPossibleExtraBoxCreation))
-        is MfvcNodeWithSubnodes -> when {
-            node is IntermediateMfvcNode && canUsePrivateAccessFor(node) && fields != null ->
-                fields.map { scope.irGetField(makeReceiverCopy(), it) }
 
-            node !is IntermediateMfvcNode || node.hasPureUnboxMethod && (canUsePrivateAccessFor(node) || node.unboxMethod.parentAsClass.isMultiFieldValueClass) ->
+    private fun makeFlattenedGetterExpressions(
-                // We cannot rely on purity of non-mfvc class getter because the incremental compiler will not recompile the code
+        scope: IrBlockBuilder, currentClass: IrClass, isInsideRecursion: Boolean, registerPossibleExtraBoxCreation: () -> Unit
-                // that relayed after the change of purity if it is not local for the class.
+    ): List<IrExpression> {
-                node.subnodes.flatMap { get(it.name)!!.makeFlattenedGetterExpressions(scope, registerPossibleExtraBoxCreation) }
+        fun makeRecursiveResult(node: MfvcNodeWithSubnodes) = node.subnodes.flatMap {
+            get(it.name)!!.makeFlattenedGetterExpressions(scope, currentClass, true, registerPossibleExtraBoxCreation)
+        }
 
-            else -> {
+        return when (node) {
-                val value = makeGetterExpression(scope, registerPossibleExtraBoxCreation = { /* The box is definitely useful */ })
+            is LeafMfvcNode -> listOf(makeGetterExpression(scope, currentClass, registerPossibleExtraBoxCreation))
+            is RootMfvcNode -> makeRecursiveResult(node)
+            is IntermediateMfvcNode -> if (isInsideRecursion || node.hasPureUnboxMethod) {
+                makeRecursiveResult(node) // use real getter for fields
+            } else {
+                val value = makeGetterExpression(scope, currentClass, registerPossibleExtraBoxCreation = { /* The box is definitely useful */ })
                 val asVariable = scope.savableStandaloneVariableWithSetter(
                     value,
                     origin = JvmLoweredDeclarationOrigin.TEMPORARY_MULTI_FIELD_VALUE_CLASS_VARIABLE,
@@ -185,18 +191,26 @@ class ReceiverBasedMfvcNodeInstance(
                 val root = node.rootNode
                 val variableInstance =
                     root.createInstanceFromBox(scope, typeArguments, scope.irGet(asVariable), accessType, saveVariable)
-                variableInstance.makeFlattenedGetterExpressions(scope, registerPossibleExtraBoxCreation)
+                variableInstance.makeFlattenedGetterExpressions(scope, currentClass, registerPossibleExtraBoxCreation)
             }
         }
     }
 
-    override fun makeGetterExpression(scope: IrBuilderWithScope, registerPossibleExtraBoxCreation: () -> Unit): IrExpression = with(scope) {
+    override fun makeGetterExpression(scope: IrBuilderWithScope, currentClass: IrClass, registerPossibleExtraBoxCreation: () -> Unit): IrExpression = with(scope) {
         when {
-            node is LeafMfvcNode && canUsePrivateAccessFor(node) && fields != null -> irGetField(makeReceiverCopy(), fields.single())
+            node is RootMfvcNode -> makeReceiverCopy()!!
-            node is IntermediateMfvcNode && accessType == AccessType.AlwaysPrivate && fields != null -> node.makeBoxedExpression(
+            node is LeafMfvcNode && node.hasPureUnboxMethod && canUsePrivateAccess(node, currentClass) && fields != null ->
-                this, typeArguments, fields.map { irGetField(makeReceiverCopy(), it) }, registerPossibleExtraBoxCreation
+                irGetField(makeReceiverCopy(), fields.single())
-            )
+            node is LeafMfvcNode && accessType == AccessType.UseFields -> {
-
+                require(fields != null) { "Invalid getter to $node" }
+                irGetField(makeReceiverCopy(), fields.single())
+            }
+            node is IntermediateMfvcNode && accessType == AccessType.UseFields -> {
+                require(fields != null) { "Invalid getter to $node" }
+                node.makeBoxedExpression(
+                    this, typeArguments, fields.map { irGetField(makeReceiverCopy(), it) }, registerPossibleExtraBoxCreation
+                )
+            }
             unboxMethod != null -> irCall(unboxMethod).apply {
                 val dispatchReceiverParameter = unboxMethod.dispatchReceiverParameter
                 if (dispatchReceiverParameter != null) {
@@ -207,14 +221,14 @@ class ReceiverBasedMfvcNodeInstance(
                     }
                 }
             }
-
-            node is RootMfvcNode -> makeReceiverCopy()!!
             else -> error("Unbox method must exist for $node")
         }
     }
 
-    private fun canUsePrivateAccessFor(node: NameableMfvcNode) =
+    private fun canUsePrivateAccess(node: NameableMfvcNode, currentClass: IrClass): Boolean {
-        node.hasPureUnboxMethod && accessType == AccessType.PrivateWhenNoBox || accessType == AccessType.AlwaysPrivate
+        val sourceClass = node.unboxMethod.parentAsClass.let { if (it.isCompanion) it.parentAsClass else it }
+        return sourceClass == currentClass
+    }
 
     override fun get(name: Name): ReceiverBasedMfvcNodeInstance? {
         val (newNode, _) = node.getSubnodeAndIndices(name) ?: return null

compiler/testData/codegen/box/valueClasses/classFlattening.kt

@@ -9,6 +9,7 @@
 value class IC(val x: UInt)
 
 fun ic(x: IC) = x.x
+fun ic(x: UInt) = ic(IC(x))
 
 @JvmInline
 value class SimpleMfvc(val x: UInt, val y: IC, val z: String) {
@@ -69,6 +70,10 @@ value class SimpleMfvc(val x: UInt, val y: IC, val z: String) {
 
 fun smfvc(ic: IC, x: SimpleMfvc, ic1: UInt) = ic(ic) + x.x + ic(x.y) + ic1
 
+@JvmInline
+value class Wrapper(val simpleMfvc: SimpleMfvc)
+fun smfvc(ic: IC, x: Wrapper, ic1: UInt) = smfvc(ic, x.simpleMfvc, ic1)
+
 @JvmInline
 value class GreaterMfvc(val x: SimpleMfvc, val y: IC, val z: SimpleMfvc)
 
@@ -135,6 +140,7 @@ fun box(): String {
     val o2 = SimpleMfvc(1U, o1, "3")
     val o2_ = SimpleMfvc(1U, o1, "-3")
     require(smfvc(IC(4U), o2, 5U) == 12U)
+    require(smfvc(IC(4U), Wrapper(o2), 5U) == 12U)
     val o3 = GreaterMfvc(o2, IC(6U), SimpleMfvc(7U, IC(8U), "9"))
     require(gmfvc(IC(10U), o3, 11U) == 45U)
     with(Extensions()) {

compiler/testData/codegen/box/valueClasses/classFlattening.txt

@@ -2,11 +2,13 @@
 public final class ClassFlatteningKt {
     // source: 'classFlattening.kt'
     public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
-    public final static method gmfvc-Ket90g4(p0: int, p1: int, p2: int, @org.jetbrains.annotations.NotNull p3: java.lang.String, p4: int, p5: int, p6: int, @org.jetbrains.annotations.NotNull p7: java.lang.String, p8: int): int
+    public final static method gmfvc-esHD5tU(p0: int, p1: int, p2: int, @org.jetbrains.annotations.NotNull p3: java.lang.String, p4: int, p5: int, p6: int, @org.jetbrains.annotations.NotNull p7: java.lang.String, p8: int): int
     public final static method ic-K5cTq2M(p0: int): int
+    public final static method ic-WZ4Q5Ns(p0: int): int
     public final static @org.jetbrains.annotations.NotNull method idBoxed(@org.jetbrains.annotations.Nullable p0: SimpleMfvc): SimpleMfvc
-    public final static @org.jetbrains.annotations.NotNull method idUnboxed-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
+    public final static @org.jetbrains.annotations.NotNull method idUnboxed-ge5QAg4(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
-    public final static method smfvc-Ket90g4(p0: int, p1: int, p2: int, @org.jetbrains.annotations.NotNull p3: java.lang.String, p4: int): int
+    public final static method smfvc-8dxEgb8(p0: int, p1: int, p2: int, @org.jetbrains.annotations.NotNull p3: java.lang.String, p4: int): int
+    public final static method smfvc-qMG0wUE(p0: int, p1: int, p2: int, @org.jetbrains.annotations.NotNull p3: java.lang.String, p4: int): int
     public final inner class Contexts$Companion
     public final inner class Extensions$Companion
     public final inner class SimpleMfvc$Companion
@@ -17,13 +19,13 @@ public final class Contexts$Companion {
     // source: 'classFlattening.kt'
     private method <init>(): void
     public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
-    public synthetic final static method access$getPrivate2-sUp7gFk(p0: Contexts$Companion, p1: int, p2: int, p3: java.lang.String): SimpleMfvc
+    public synthetic final static method access$getPrivate2-ge5QAg4(p0: Contexts$Companion, p1: int, p2: int, p3: java.lang.String): SimpleMfvc
-    private final method getPrivate1-sUp7gFk(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
+    private final method getPrivate1-ge5QAg4(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
     private synthetic deprecated static @kotlin.jvm.JvmStatic method getPrivate2$annotations(): void
-    private final method getPrivate2-sUp7gFk(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
+    private final method getPrivate2-ge5QAg4(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
-    public final @org.jetbrains.annotations.NotNull method getY1-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
+    public final @org.jetbrains.annotations.NotNull method getY1-ge5QAg4(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
     public synthetic deprecated static @kotlin.jvm.JvmStatic method getZ1$annotations(): void
-    public final @org.jetbrains.annotations.NotNull method getZ1-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
+    public final @org.jetbrains.annotations.NotNull method getZ1-ge5QAg4(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
     public final inner class Contexts$Companion
 }
 
@@ -33,10 +35,10 @@ public final class Contexts {
     public final static @org.jetbrains.annotations.NotNull field Companion: Contexts$Companion
     static method <clinit>(): void
     public method <init>(): void
-    private final static method getPrivate2-sUp7gFk(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
+    private final static method getPrivate2-ge5QAg4(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
-    private final method getPrivate_-sUp7gFk(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
+    private final method getPrivate_-ge5QAg4(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
-    public final @org.jetbrains.annotations.NotNull method getX1-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
+    public final @org.jetbrains.annotations.NotNull method getX1-ge5QAg4(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
-    public final static @org.jetbrains.annotations.NotNull method getZ1-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
+    public final static @org.jetbrains.annotations.NotNull method getZ1-ge5QAg4(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
     public final inner class Contexts$Companion
 }
 
@@ -45,13 +47,13 @@ public final class Extensions$Companion {
     // source: 'classFlattening.kt'
     private method <init>(): void
     public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
-    public synthetic final static method access$getPrivate2-sUp7gFk(p0: Extensions$Companion, p1: int, p2: int, p3: java.lang.String): SimpleMfvc
+    public synthetic final static method access$getPrivate2-ge5QAg4(p0: Extensions$Companion, p1: int, p2: int, p3: java.lang.String): SimpleMfvc
-    private final method getPrivate1-sUp7gFk(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
+    private final method getPrivate1-ge5QAg4(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
     private synthetic deprecated static @kotlin.jvm.JvmStatic method getPrivate2$annotations(p0: SimpleMfvc): void
-    private final method getPrivate2-sUp7gFk(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
+    private final method getPrivate2-ge5QAg4(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
-    public final @org.jetbrains.annotations.NotNull method getY1-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
+    public final @org.jetbrains.annotations.NotNull method getY1-ge5QAg4(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
     public synthetic deprecated static @kotlin.jvm.JvmStatic method getZ1$annotations(p0: SimpleMfvc): void
-    public final @org.jetbrains.annotations.NotNull method getZ1-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
+    public final @org.jetbrains.annotations.NotNull method getZ1-ge5QAg4(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
     public final inner class Extensions$Companion
 }
 
@@ -61,10 +63,10 @@ public final class Extensions {
     public final static @org.jetbrains.annotations.NotNull field Companion: Extensions$Companion
     static method <clinit>(): void
     public method <init>(): void
-    private final static method getPrivate2-sUp7gFk(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
+    private final static method getPrivate2-ge5QAg4(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
-    private final method getPrivate_-sUp7gFk(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
+    private final method getPrivate_-ge5QAg4(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
-    public final @org.jetbrains.annotations.NotNull method getX1-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
+    public final @org.jetbrains.annotations.NotNull method getX1-ge5QAg4(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
-    public final static @org.jetbrains.annotations.NotNull method getZ1-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
+    public final static @org.jetbrains.annotations.NotNull method getZ1-ge5QAg4(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
     public final inner class Extensions$Companion
 }
 
@@ -127,20 +129,20 @@ public final class SimpleMfvc$Companion {
     // source: 'classFlattening.kt'
     private method <init>(): void
     public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
-    public synthetic final static method access$getPrivate2-sUp7gFk(p0: SimpleMfvc$Companion, p1: int, p2: int, p3: java.lang.String): SimpleMfvc
+    public synthetic final static method access$getPrivate2-ge5QAg4(p0: SimpleMfvc$Companion, p1: int, p2: int, p3: java.lang.String): SimpleMfvc
-    public synthetic final static method access$getPrivate4-sUp7gFk(p0: SimpleMfvc$Companion, p1: int, p2: int, p3: java.lang.String): SimpleMfvc
+    public synthetic final static method access$getPrivate4-ge5QAg4(p0: SimpleMfvc$Companion, p1: int, p2: int, p3: java.lang.String): SimpleMfvc
-    public final @org.jetbrains.annotations.NotNull method getA1-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
+    public final @org.jetbrains.annotations.NotNull method getA1-ge5QAg4(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
-    public final @org.jetbrains.annotations.NotNull method getA2-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
+    public final @org.jetbrains.annotations.NotNull method getA2-ge5QAg4(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
     public synthetic deprecated static @kotlin.jvm.JvmStatic method getB1$annotations(p0: SimpleMfvc): void
-    public final @org.jetbrains.annotations.NotNull method getB1-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
+    public final @org.jetbrains.annotations.NotNull method getB1-ge5QAg4(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
     public synthetic deprecated static @kotlin.jvm.JvmStatic method getB2$annotations(): void
-    public final @org.jetbrains.annotations.NotNull method getB2-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
+    public final @org.jetbrains.annotations.NotNull method getB2-ge5QAg4(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
-    private final method getPrivate1-sUp7gFk(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
+    private final method getPrivate1-ge5QAg4(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
     private synthetic deprecated static @kotlin.jvm.JvmStatic method getPrivate2$annotations(p0: SimpleMfvc): void
-    private final method getPrivate2-sUp7gFk(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
+    private final method getPrivate2-ge5QAg4(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
-    private final method getPrivate3-sUp7gFk(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
+    private final method getPrivate3-ge5QAg4(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
     private synthetic deprecated static @kotlin.jvm.JvmStatic method getPrivate4$annotations(): void
-    private final method getPrivate4-sUp7gFk(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
+    private final method getPrivate4-ge5QAg4(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
     public final inner class SimpleMfvc$Companion
 }
 
@@ -159,16 +161,16 @@ public final class SimpleMfvc {
     public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
     public static method equals-impl(p0: int, p1: int, p2: java.lang.String, p3: java.lang.Object): boolean
     public final static method equals-impl0(p0: int, p1: int, p2: java.lang.String, p3: int, p4: int, p5: java.lang.String): boolean
-    public final static @org.jetbrains.annotations.NotNull method getA3-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String, p3: int, p4: int, @org.jetbrains.annotations.NotNull p5: java.lang.String): SimpleMfvc
+    public final static @org.jetbrains.annotations.NotNull method getA3-ge5QAg4(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String, p3: int, p4: int, @org.jetbrains.annotations.NotNull p5: java.lang.String): SimpleMfvc
     public final static method getA4-impl(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): int
-    public final static @org.jetbrains.annotations.NotNull method getB1-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
+    public final static @org.jetbrains.annotations.NotNull method getB1-ge5QAg4(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
-    public final static @org.jetbrains.annotations.NotNull method getB2-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
+    public final static @org.jetbrains.annotations.NotNull method getB2-ge5QAg4(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
-    public final static @org.jetbrains.annotations.NotNull method getB3-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String, p3: int, p4: int, @org.jetbrains.annotations.NotNull p5: java.lang.String): SimpleMfvc
+    public final static @org.jetbrains.annotations.NotNull method getB3-ge5QAg4(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String, p3: int, p4: int, @org.jetbrains.annotations.NotNull p5: java.lang.String): SimpleMfvc
     public final static @org.jetbrains.annotations.NotNull method getB4-impl(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc
-    private final static method getPrivate1-sUp7gFk(p0: int, p1: int, p2: java.lang.String, p3: int, p4: int, p5: java.lang.String): SimpleMfvc
+    private final static method getPrivate1-ge5QAg4(p0: int, p1: int, p2: java.lang.String, p3: int, p4: int, p5: java.lang.String): SimpleMfvc
-    private final static method getPrivate2-sUp7gFk(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
+    private final static method getPrivate2-ge5QAg4(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
-    private final static method getPrivate2-sUp7gFk(p0: int, p1: int, p2: java.lang.String, p3: int, p4: int, p5: java.lang.String): SimpleMfvc
+    private final static method getPrivate2-ge5QAg4(p0: int, p1: int, p2: java.lang.String, p3: int, p4: int, p5: java.lang.String): SimpleMfvc
-    private final static method getPrivate4-sUp7gFk(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
+    private final static method getPrivate4-ge5QAg4(p0: int, p1: int, p2: java.lang.String): SimpleMfvc
     public final method getX-pVg5ArA(): int
     public final method getY-fhib4bs(): int
     public final @org.jetbrains.annotations.NotNull method getZ(): java.lang.String
@@ -181,3 +183,27 @@ public final class SimpleMfvc {
     public synthetic final method unbox-impl-z(): java.lang.String
     public final inner class SimpleMfvc$Companion
 }
+
+@kotlin.jvm.JvmInline
+@kotlin.Metadata
+public final class Wrapper {
+    // source: 'classFlattening.kt'
+    private final field simpleMfvc-x: int
+    private final field simpleMfvc-y: int
+    private final @org.jetbrains.annotations.NotNull field simpleMfvc-z: java.lang.String
+    private synthetic method <init>(p0: int, p1: int, p2: java.lang.String): void
+    public synthetic final static method box-impl(p0: int, p1: int, p2: java.lang.String): Wrapper
+    public final static method constructor-impl(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): void
+    public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
+    public static method equals-impl(p0: int, p1: int, p2: java.lang.String, p3: java.lang.Object): boolean
+    public final static method equals-impl0(p0: int, p1: int, p2: java.lang.String, p3: int, p4: int, p5: java.lang.String): boolean
+    public final @org.jetbrains.annotations.NotNull method getSimpleMfvc(): SimpleMfvc
+    public method hashCode(): int
+    public static method hashCode-impl(p0: int, p1: int, p2: java.lang.String): int
+    public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
+    public static method toString-impl(p0: int, p1: int, p2: java.lang.String): java.lang.String
+    public synthetic final method unbox-impl-simpleMfvc(): SimpleMfvc
+    public synthetic final method unbox-impl-simpleMfvc-x(): int
+    public synthetic final method unbox-impl-simpleMfvc-y(): int
+    public synthetic final method unbox-impl-simpleMfvc-z(): java.lang.String
+}

compiler/testData/codegen/box/valueClasses/complex.txt

@@ -84,7 +84,7 @@ public interface Base2 {
     public synthetic abstract method getL-z-x-x-x(): int
     public synthetic abstract method getL-z-x-x-y(): int
     public synthetic abstract method getL-z-x-x-z(): java.lang.String
-    public abstract method setL-sUp7gFk(p0: int, p1: int, p2: int, p3: int, @org.jetbrains.annotations.NotNull p4: java.lang.String, @org.jetbrains.annotations.NotNull p5: java.util.List): void
+    public abstract method setL-dD1ukFQ(p0: int, p1: int, p2: int, p3: int, @org.jetbrains.annotations.NotNull p4: java.lang.String, @org.jetbrains.annotations.NotNull p5: java.util.List): void
 }
 
 @kotlin.Metadata
@@ -137,18 +137,18 @@ public final class ComplexKt {
     private final static @org.jetbrains.annotations.NotNull field lines: java.util.List
     static method <clinit>(): void
     public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
-    public final static method equalsChecks-GPBa7dw(p0: int, p1: int, p2: int, p3: int, @org.jetbrains.annotations.NotNull p4: java.lang.String, @org.jetbrains.annotations.NotNull p5: java.util.List, p6: int, p7: int, p8: int, p9: int, @org.jetbrains.annotations.NotNull p10: java.lang.String, @org.jetbrains.annotations.NotNull p11: java.util.List): void
+    public final static method equalsChecks--HuG_sY(p0: int, p1: int, p2: int, p3: int, @org.jetbrains.annotations.NotNull p4: java.lang.String, @org.jetbrains.annotations.NotNull p5: java.util.List, p6: int, p7: int, p8: int, p9: int, @org.jetbrains.annotations.NotNull p10: java.lang.String, @org.jetbrains.annotations.NotNull p11: java.util.List): void
     public final static method equalsChecks1-iUtXLc0(@org.jetbrains.annotations.NotNull p0: java.util.List): void
-    public final static method f-sUp7gFk(p0: int, p1: int, p2: int, p3: int, @org.jetbrains.annotations.NotNull p4: java.lang.String, @org.jetbrains.annotations.NotNull p5: java.util.List): void
+    public final static method f-dD1ukFQ(p0: int, p1: int, p2: int, p3: int, @org.jetbrains.annotations.NotNull p4: java.lang.String, @org.jetbrains.annotations.NotNull p5: java.util.List): void
-    public final static method g-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): void
+    public final static method g-YDOJbQ0(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): void
     public final static @org.jetbrains.annotations.NotNull method getLate1(): E
     public final static @org.jetbrains.annotations.NotNull method getLines(): java.util.List
-    public final static method h-sUp7gFk(p0: int, p1: int, p2: int, p3: int, @org.jetbrains.annotations.NotNull p4: java.lang.String, @org.jetbrains.annotations.NotNull p5: java.util.List): void
+    public final static method h-dD1ukFQ(p0: int, p1: int, p2: int, p3: int, @org.jetbrains.annotations.NotNull p4: java.lang.String, @org.jetbrains.annotations.NotNull p5: java.util.List): void
     public final static method h1(): void
     public final static @org.jetbrains.annotations.NotNull method inlined-OsBMiQA(p0: int, p1: int, p2: int): D
     public final static @org.jetbrains.annotations.NotNull method notInlined-OsBMiQA(p0: int, p1: int, p2: int): D
     public final static method reuseBoxed(@org.jetbrains.annotations.NotNull p0: java.util.List): void
-    public final static method setLate1-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): void
+    public final static method setLate1-YDOJbQ0(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): void
     public final static method supply(@org.jetbrains.annotations.NotNull p0: java.lang.Object): void
     public final static method testVars(@org.jetbrains.annotations.NotNull p0: NotInlined): void
 }
@@ -195,7 +195,7 @@ public final class E {
     public final @org.jetbrains.annotations.NotNull method getX(): D
     public method hashCode(): int
     public static method hashCode-impl(p0: int, p1: int, p2: java.lang.String): int
-    public final static method setWithNonTrivialSetters-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String, p3: int, p4: int, @org.jetbrains.annotations.NotNull p5: java.lang.String): void
+    public final static method setWithNonTrivialSetters-j_b7x2A(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String, p3: int, p4: int, @org.jetbrains.annotations.NotNull p5: java.lang.String): void
     public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
     public static method toString-impl(p0: int, p1: int, p2: java.lang.String): java.lang.String
     public synthetic final method unbox-impl-x(): D
@@ -274,9 +274,9 @@ public final class NotInlined {
     public synthetic final method getWithNonTrivialSettersWithBF-z-x-x-z(): java.lang.String
     public final method getY(): int
     public synthetic bridge method setL(p0: java.lang.Object): void
-    public method setL-sUp7gFk(p0: int, p1: int, p2: int, p3: int, @org.jetbrains.annotations.NotNull p4: java.lang.String, @org.jetbrains.annotations.NotNull p5: java.util.List): void
+    public method setL-dD1ukFQ(p0: int, p1: int, p2: int, p3: int, @org.jetbrains.annotations.NotNull p4: java.lang.String, @org.jetbrains.annotations.NotNull p5: java.util.List): void
-    public final method setWithNonTrivialSetters-sUp7gFk(p0: int, p1: int, p2: int, p3: int, @org.jetbrains.annotations.NotNull p4: java.lang.String, @org.jetbrains.annotations.NotNull p5: java.util.List): void
+    public final method setWithNonTrivialSetters-dD1ukFQ(p0: int, p1: int, p2: int, p3: int, @org.jetbrains.annotations.NotNull p4: java.lang.String, @org.jetbrains.annotations.NotNull p5: java.util.List): void
-    public final method setWithNonTrivialSettersWithBF-sUp7gFk(p0: int, p1: int, p2: int, p3: int, @org.jetbrains.annotations.NotNull p4: java.lang.String, @org.jetbrains.annotations.NotNull p5: java.util.List): void
+    public final method setWithNonTrivialSettersWithBF-dD1ukFQ(p0: int, p1: int, p2: int, p3: int, @org.jetbrains.annotations.NotNull p4: java.lang.String, @org.jetbrains.annotations.NotNull p5: java.util.List): void
     public final method setY(p0: int): void
     public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
     public final method trySetter(): void

compiler/testData/codegen/box/valueClasses/defaultParameters.kt

@@ -6,6 +6,14 @@
 @JvmInline
 value class DPoint(/*inline */val x: Double/* = 1.0*/, /*inline */val y: Double/* = 2.0*/) {
     fun f1(a: Int, b: Int = -1, c: DPoint = DPoint(-2.0, -3.0)) = listOf(this, x, y, a, b, c)
+    
+    companion object {
+        inline operator fun invoke(): DPoint = DPoint(0.0, 0.0)
+    }
+}
+
+object RegularObject {
+    fun pointToString(x: DPoint? = DPoint()) = "$x"
 }
 
 @JvmInline
@@ -21,6 +29,14 @@ fun complexFun(a1: Double, a2: DPoint, a3: Double = a1 * a2.x * a2.y, a4: DPoint
 
 inline fun complexInlineFun(a1: Double, a2: DPoint, a3: Double = a1 * a2.x * a2.y, a4: DPoint = DPoint(a2.x * a1 * a3, a2.y * a1 * a3)) = "$a1, $a2, $a3, $a4"
 
+fun getLineIntersectionPoint(out: DPoint = DPoint()): DPoint? {
+    return getIntersectXY(out)
+}
+
+fun getIntersectXY(out: DPoint = DPoint()): DPoint? {
+    return out
+}
+
 fun box(): String {
 //    comments bellow are because MFVC primary constructors default parameters require support of inline arguments in regular functions
 //    require(DPoint() == DPoint(1.0, 2.0)) { "${DPoint()} ${DPoint(1.0, 2.0)}" }
@@ -86,5 +102,8 @@ fun box(): String {
         complexInlineFun(2.0, DPoint(3.0, 5.0), 7.0, DPoint(11.0, 13.0))
     }
     
+    require(RegularObject.pointToString() == "DPoint(x=0.0, y=0.0)") { RegularObject.pointToString() }
+    require(getLineIntersectionPoint().toString() == "DPoint(x=0.0, y=0.0)") { getLineIntersectionPoint().toString() }
+    
     return "OK"
 }

compiler/testData/codegen/box/valueClasses/defaultParameters.txt

@@ -1,17 +1,28 @@
+@kotlin.Metadata
+public final class DPoint$Companion {
+    // source: 'defaultParameters.kt'
+    private method <init>(): void
+    public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
+    public final @org.jetbrains.annotations.NotNull method invoke(): DPoint
+    public final inner class DPoint$Companion
+}
+
 @kotlin.jvm.JvmInline
 @kotlin.Metadata
 public final class DPoint {
     // source: 'defaultParameters.kt'
+    public final static @org.jetbrains.annotations.NotNull field Companion: DPoint$Companion
     private final field x: double
     private final field y: double
+    static method <clinit>(): void
     private synthetic method <init>(p0: double, p1: double): void
     public synthetic final static method box-impl(p0: double, p1: double): DPoint
     public final static method constructor-impl(p0: double, p1: double): void
     public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
     public static method equals-impl(p0: double, p1: double, p2: java.lang.Object): boolean
     public final static method equals-impl0(p0: double, p1: double, p2: double, p3: double): boolean
-    public synthetic static method f1-lIoT8es$default(p0: double, p1: double, p2: int, p3: int, p4: double, p5: double, p6: int, p7: java.lang.Object): java.util.List
+    public synthetic static method f1-lrN9jSQ$default(p0: double, p1: double, p2: int, p3: int, p4: double, p5: double, p6: int, p7: java.lang.Object): java.util.List
-    public final static @org.jetbrains.annotations.NotNull method f1-lIoT8es(p0: double, p1: double, p2: int, p3: int, p4: double, p5: double): java.util.List
+    public final static @org.jetbrains.annotations.NotNull method f1-lrN9jSQ(p0: double, p1: double, p2: int, p3: int, p4: double, p5: double): java.util.List
     public final method getX(): double
     public final method getY(): double
     public method hashCode(): int
@@ -20,6 +31,7 @@ public final class DPoint {
     public static method toString-impl(p0: double, p1: double): java.lang.String
     public synthetic final method unbox-impl-x(): double
     public synthetic final method unbox-impl-y(): double
+    public final inner class DPoint$Companion
 }
 
 @kotlin.jvm.JvmInline
@@ -37,8 +49,8 @@ public final class DSegment {
     public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
     public static method equals-impl(p0: double, p1: double, p2: double, p3: double, p4: int, p5: java.lang.Object): boolean
     public final static method equals-impl0(p0: double, p1: double, p2: double, p3: double, p4: int, p5: double, p6: double, p7: double, p8: double, p9: int): boolean
-    public synthetic static method f2-lIoT8es$default(p0: double, p1: double, p2: double, p3: double, p4: int, p5: int, p6: int, p7: double, p8: double, p9: int, p10: java.lang.Object): java.util.List
+    public synthetic static method f2-lrN9jSQ$default(p0: double, p1: double, p2: double, p3: double, p4: int, p5: int, p6: int, p7: double, p8: double, p9: int, p10: java.lang.Object): java.util.List
-    public final static @org.jetbrains.annotations.NotNull method f2-lIoT8es(p0: double, p1: double, p2: double, p3: double, p4: int, p5: int, p6: int, p7: double, p8: double): java.util.List
+    public final static @org.jetbrains.annotations.NotNull method f2-lrN9jSQ(p0: double, p1: double, p2: double, p3: double, p4: int, p5: int, p6: int, p7: double, p8: double): java.util.List
     public final method getN(): int
     public final @org.jetbrains.annotations.NotNull method getP1(): DPoint
     public final @org.jetbrains.annotations.NotNull method getP2(): DPoint
@@ -59,10 +71,26 @@ public final class DSegment {
 public final class DefaultParametersKt {
     // source: 'defaultParameters.kt'
     public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
-    public synthetic static method complexFun-552ch2I$default(p0: double, p1: double, p2: double, p3: double, p4: double, p5: double, p6: int, p7: java.lang.Object): java.lang.String
+    public synthetic static method complexFun-A7c95m0$default(p0: double, p1: double, p2: double, p3: double, p4: double, p5: double, p6: int, p7: java.lang.Object): java.lang.String
-    public final static @org.jetbrains.annotations.NotNull method complexFun-552ch2I(p0: double, p1: double, p2: double, p3: double, p4: double, p5: double): java.lang.String
+    public final static @org.jetbrains.annotations.NotNull method complexFun-A7c95m0(p0: double, p1: double, p2: double, p3: double, p4: double, p5: double): java.lang.String
-    public synthetic static method complexInlineFun-552ch2I$default(p0: double, p1: double, p2: double, p3: double, p4: double, p5: double, p6: int, p7: java.lang.Object): java.lang.String
+    public synthetic static method complexInlineFun-A7c95m0$default(p0: double, p1: double, p2: double, p3: double, p4: double, p5: double, p6: int, p7: java.lang.Object): java.lang.String
-    public final static @org.jetbrains.annotations.NotNull method complexInlineFun-552ch2I(p0: double, p1: double, p2: double, p3: double, p4: double, p5: double): java.lang.String
+    public final static @org.jetbrains.annotations.NotNull method complexInlineFun-A7c95m0(p0: double, p1: double, p2: double, p3: double, p4: double, p5: double): java.lang.String
+    public synthetic static method getIntersectXY-nuuzChU$default(p0: double, p1: double, p2: int, p3: java.lang.Object): DPoint
+    public final static @org.jetbrains.annotations.Nullable method getIntersectXY-nuuzChU(p0: double, p1: double): DPoint
+    public synthetic static method getLineIntersectionPoint-nuuzChU$default(p0: double, p1: double, p2: int, p3: java.lang.Object): DPoint
+    public final static @org.jetbrains.annotations.Nullable method getLineIntersectionPoint-nuuzChU(p0: double, p1: double): DPoint
+    public final inner class DPoint$Companion
+}
+
+@kotlin.Metadata
+public final class RegularObject {
+    // source: 'defaultParameters.kt'
+    public final static @org.jetbrains.annotations.NotNull field INSTANCE: RegularObject
+    static method <clinit>(): void
+    private method <init>(): void
+    public synthetic static method pointToString$default(p0: RegularObject, p1: DPoint, p2: int, p3: java.lang.Object): java.lang.String
+    public final @org.jetbrains.annotations.NotNull method pointToString(@org.jetbrains.annotations.Nullable p0: DPoint): java.lang.String
+    public final inner class DPoint$Companion
 }
 
 @kotlin.Metadata
@@ -79,11 +107,11 @@ public final class Wrapper {
     public synthetic method <init>(p0: double, p1: double, p2: double, p3: double, p4: int, p5: int, p6: kotlin.jvm.internal.DefaultConstructorMarker): void
     public final @org.jetbrains.annotations.NotNull method component1(): DSegment
     public final method component2(): int
-    public synthetic static method copy-GPBa7dw$default(p0: Wrapper, p1: double, p2: double, p3: double, p4: double, p5: int, p6: int, p7: int, p8: java.lang.Object): Wrapper
+    public synthetic static method copy-X39isKk$default(p0: Wrapper, p1: double, p2: double, p3: double, p4: double, p5: int, p6: int, p7: int, p8: java.lang.Object): Wrapper
-    public final @org.jetbrains.annotations.NotNull method copy-GPBa7dw(p0: double, p1: double, p2: double, p3: double, p4: int, p5: int): Wrapper
+    public final @org.jetbrains.annotations.NotNull method copy-X39isKk(p0: double, p1: double, p2: double, p3: double, p4: int, p5: int): Wrapper
     public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
-    public synthetic static method f3-lIoT8es$default(p0: Wrapper, p1: int, p2: int, p3: double, p4: double, p5: int, p6: java.lang.Object): java.util.List
+    public synthetic static method f3-lrN9jSQ$default(p0: Wrapper, p1: int, p2: int, p3: double, p4: double, p5: int, p6: java.lang.Object): java.util.List
-    public final @org.jetbrains.annotations.NotNull method f3-lIoT8es(p0: int, p1: int, p2: double, p3: double): java.util.List
+    public final @org.jetbrains.annotations.NotNull method f3-lrN9jSQ(p0: int, p1: int, p2: double, p3: double): java.util.List
     public final method getN(): int
     public final @org.jetbrains.annotations.NotNull method getSegment(): DSegment
     public synthetic final method getSegment-n(): int

compiler/testData/codegen/box/valueClasses/delegating.txt

@@ -65,7 +65,7 @@ public final class B {
     public synthetic final method getX-x(): int
     public synthetic final method getX-y(): int
     public final @org.jetbrains.annotations.Nullable method getY(): A
-    public final method setX-sUp7gFk(p0: int, p1: int): void
+    public final method setX-iUtXLc0(p0: int, p1: int): void
     public final method setY(@org.jetbrains.annotations.Nullable p0: A): void
 }
 

compiler/testData/codegen/box/valueClasses/fakeOverrideCall.kt

@@ -0,0 +1,21 @@
+// !LANGUAGE: +ValueClasses
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// CHECK_BYTECODE_LISTING
+
+
+@JvmInline
+value class DPoint(val x: Double, val y: Double)
+
+class A : B()
+
+class C {
+    fun set(value: DPoint) = A().set(value)
+}
+
+open class B {
+
+    fun set(value: DPoint) = "OK"
+}
+
+fun box(): String = A().set(DPoint(1.0, 2.0))

compiler/testData/codegen/box/valueClasses/fakeOverrideCall.txt

@@ -0,0 +1,47 @@
+@kotlin.Metadata
+public final class A {
+    // source: 'fakeOverrideCall.kt'
+    public method <init>(): void
+}
+
+@kotlin.Metadata
+public class B {
+    // source: 'fakeOverrideCall.kt'
+    public method <init>(): void
+    public final @org.jetbrains.annotations.NotNull method set-nuuzChU(p0: double, p1: double): java.lang.String
+}
+
+@kotlin.Metadata
+public final class C {
+    // source: 'fakeOverrideCall.kt'
+    public method <init>(): void
+    public final @org.jetbrains.annotations.NotNull method set-nuuzChU(p0: double, p1: double): java.lang.String
+}
+
+@kotlin.jvm.JvmInline
+@kotlin.Metadata
+public final class DPoint {
+    // source: 'fakeOverrideCall.kt'
+    private final field x: double
+    private final field y: double
+    private synthetic method <init>(p0: double, p1: double): void
+    public synthetic final static method box-impl(p0: double, p1: double): DPoint
+    public final static method constructor-impl(p0: double, p1: double): void
+    public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
+    public static method equals-impl(p0: double, p1: double, p2: java.lang.Object): boolean
+    public final static method equals-impl0(p0: double, p1: double, p2: double, p3: double): boolean
+    public final method getX(): double
+    public final method getY(): double
+    public method hashCode(): int
+    public static method hashCode-impl(p0: double, p1: double): int
+    public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
+    public static method toString-impl(p0: double, p1: double): java.lang.String
+    public synthetic final method unbox-impl-x(): double
+    public synthetic final method unbox-impl-y(): double
+}
+
+@kotlin.Metadata
+public final class FakeOverrideCallKt {
+    // source: 'fakeOverrideCall.kt'
+    public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
+}

compiler/testData/codegen/box/valueClasses/functionReferences.txt

@@ -5,7 +5,7 @@ public final class A {
     private final field point-y: double
     private method <init>(p0: double, p1: double): void
     public synthetic method <init>(p0: double, p1: double, p2: kotlin.jvm.internal.DefaultConstructorMarker): void
-    public final method f-GPBa7dw(p0: double, p1: double, p2: double): double
+    public final method f-jsnAEDk(p0: double, p1: double, p2: double): double
     public final @org.jetbrains.annotations.NotNull method getPoint(): DPoint
     public synthetic final method getPoint-x(): double
     public synthetic final method getPoint-y(): double
@@ -26,7 +26,7 @@ synthetic final class AnotherKt$any1$1 {
 @kotlin.Metadata
 synthetic final class AnotherKt$any2$1 {
     // source: 'another.kt'
-    enclosing method AnotherKt.any2-sUp7gFk(DD)Ljava/lang/Object;
+    enclosing method AnotherKt.any2-nuuzChU(DD)Ljava/lang/Object;
     inner (anonymous) class AnotherKt$any2$1
     method <init>(p0: java.lang.Object): void
     public final @org.jetbrains.annotations.NotNull method invoke(p0: double): java.lang.Double
@@ -42,13 +42,13 @@ synthetic final class AnotherKt$any2$2 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double
+    public final @org.jetbrains.annotations.NotNull method invoke-jsnAEDk(p0: double, p1: double, p2: double): java.lang.Double
 }
 
 @kotlin.Metadata
 synthetic final class AnotherKt$any3$1 {
     // source: 'another.kt'
-    enclosing method AnotherKt.any3-sUp7gFk(DD)Ljava/lang/Object;
+    enclosing method AnotherKt.any3-nuuzChU(DD)Ljava/lang/Object;
     inner (anonymous) class AnotherKt$any3$1
     method <init>(p0: java.lang.Object): void
     public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object
@@ -64,13 +64,13 @@ synthetic final class AnotherKt$any3$2 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
 synthetic final class AnotherKt$any4$1 {
     // source: 'another.kt'
-    enclosing method AnotherKt.any4-sUp7gFk(DD)Ljava/lang/Object;
+    enclosing method AnotherKt.any4-nuuzChU(DD)Ljava/lang/Object;
     inner (anonymous) class AnotherKt$any4$1
     method <init>(p0: java.lang.Object): void
     public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object
@@ -86,17 +86,17 @@ synthetic final class AnotherKt$any4$2 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
 synthetic final class AnotherKt$any5$1 {
     // source: 'another.kt'
-    enclosing method AnotherKt.any5-sUp7gFk(DD)Ljava/lang/Object;
+    enclosing method AnotherKt.any5-nuuzChU(DD)Ljava/lang/Object;
     inner (anonymous) class AnotherKt$any5$1
     method <init>(p0: java.lang.Object): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final method invoke-Qn1smSk(p0: double, p1: double, p2: int): int
+    public final method invoke-VZ1VC2s(p0: double, p1: double, p2: int): int
 }
 
 @kotlin.Metadata
@@ -108,13 +108,13 @@ synthetic final class AnotherKt$any5$2 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object
-    public final method invoke-jXDDuk8(p0: double, p1: double, p2: double, p3: double, p4: int): int
+    public final method invoke-pytmvKE(p0: double, p1: double, p2: double, p3: double, p4: int): int
 }
 
 @kotlin.Metadata
 synthetic final class AnotherKt$any6$1 {
     // source: 'another.kt'
-    enclosing method AnotherKt.any6-sUp7gFk(DD)Ljava/lang/Object;
+    enclosing method AnotherKt.any6-nuuzChU(DD)Ljava/lang/Object;
     inner (anonymous) class AnotherKt$any6$1
     method <init>(p0: java.lang.Object): void
     public final @org.jetbrains.annotations.NotNull method invoke(p0: double): java.lang.Double
@@ -130,17 +130,17 @@ synthetic final class AnotherKt$any6$2 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double
+    public final @org.jetbrains.annotations.NotNull method invoke-jsnAEDk(p0: double, p1: double, p2: double): java.lang.Double
 }
 
 @kotlin.Metadata
 synthetic final class AnotherKt$any7$1 {
     // source: 'another.kt'
-    enclosing method AnotherKt.any7-sUp7gFk(DD)Ljava/lang/Object;
+    enclosing method AnotherKt.any7-nuuzChU(DD)Ljava/lang/Object;
     inner (anonymous) class AnotherKt$any7$1
     method <init>(p0: java.lang.Object): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-lIoT8es(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-qDyJxbU(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -152,17 +152,17 @@ synthetic final class AnotherKt$any7$2 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-552ch2I(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-lQKCjj0(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
 synthetic final class AnotherKt$any8$1 {
     // source: 'another.kt'
-    enclosing method AnotherKt.any8-sUp7gFk(DD)Ljava/lang/Object;
+    enclosing method AnotherKt.any8-nuuzChU(DD)Ljava/lang/Object;
     inner (anonymous) class AnotherKt$any8$1
     method <init>(p0: java.lang.Object): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-lIoT8es(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-qDyJxbU(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -174,7 +174,7 @@ synthetic final class AnotherKt$any8$2 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-552ch2I(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-lQKCjj0(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -197,20 +197,20 @@ public final class AnotherKt {
     inner (anonymous) class AnotherKt$any8$2
     public final static @org.jetbrains.annotations.NotNull method any1(): java.lang.Object
     public final static @org.jetbrains.annotations.NotNull method any2(): java.lang.Object
-    public final static @org.jetbrains.annotations.NotNull method any2-sUp7gFk(p0: double, p1: double): java.lang.Object
+    public final static @org.jetbrains.annotations.NotNull method any2-nuuzChU(p0: double, p1: double): java.lang.Object
     public final static @org.jetbrains.annotations.NotNull method any3(): java.lang.Object
-    public final static @org.jetbrains.annotations.NotNull method any3-sUp7gFk(p0: double, p1: double): java.lang.Object
+    public final static @org.jetbrains.annotations.NotNull method any3-nuuzChU(p0: double, p1: double): java.lang.Object
     public final static @org.jetbrains.annotations.NotNull method any4(): java.lang.Object
-    public final static @org.jetbrains.annotations.NotNull method any4-sUp7gFk(p0: double, p1: double): java.lang.Object
+    public final static @org.jetbrains.annotations.NotNull method any4-nuuzChU(p0: double, p1: double): java.lang.Object
     public final static @org.jetbrains.annotations.NotNull method any5(): java.lang.Object
-    public final static @org.jetbrains.annotations.NotNull method any5-sUp7gFk(p0: double, p1: double): java.lang.Object
+    public final static @org.jetbrains.annotations.NotNull method any5-nuuzChU(p0: double, p1: double): java.lang.Object
     public final static @org.jetbrains.annotations.NotNull method any6(): java.lang.Object
-    public final static @org.jetbrains.annotations.NotNull method any6-sUp7gFk(p0: double, p1: double): java.lang.Object
+    public final static @org.jetbrains.annotations.NotNull method any6-nuuzChU(p0: double, p1: double): java.lang.Object
     public final static @org.jetbrains.annotations.NotNull method any7(): java.lang.Object
-    public final static @org.jetbrains.annotations.NotNull method any7-sUp7gFk(p0: double, p1: double): java.lang.Object
+    public final static @org.jetbrains.annotations.NotNull method any7-nuuzChU(p0: double, p1: double): java.lang.Object
     public final static @org.jetbrains.annotations.NotNull method any8(): java.lang.Object
-    public final static @org.jetbrains.annotations.NotNull method any8-sUp7gFk(p0: double, p1: double): java.lang.Object
+    public final static @org.jetbrains.annotations.NotNull method any8-nuuzChU(p0: double, p1: double): java.lang.Object
-    public final static @org.jetbrains.annotations.Nullable method requiresF-lIoT8es(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: F, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method requiresF-qDyJxbU(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: F, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -234,7 +234,7 @@ public final class CallerKt {
 @kotlin.Metadata
 final class DPoint$suspendFunctionWithLambda$1 {
     // source: 'test.kt'
-    enclosing method DPoint.suspendFunctionWithLambda-lIoT8es(DDDDLkotlin/jvm/functions/Function2;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
+    enclosing method DPoint.suspendFunctionWithLambda-qDyJxbU(DDDDLkotlin/jvm/functions/Function2;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
     field D$0: double
     field D$1: double
     field L$0: java.lang.Object
@@ -249,7 +249,7 @@ final class DPoint$suspendFunctionWithLambda$1 {
 @kotlin.Metadata
 final class DPoint$suspendInlineFunctionWithLambda$1 {
     // source: 'test.kt'
-    enclosing method DPoint.suspendInlineFunctionWithLambda-lIoT8es(DDDDLkotlin/jvm/functions/Function2;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
+    enclosing method DPoint.suspendInlineFunctionWithLambda-qDyJxbU(DDDDLkotlin/jvm/functions/Function2;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
     field D$0: double
     field D$1: double
     field L$0: java.lang.Object
@@ -275,13 +275,13 @@ public final class DPoint {
     public static method equals-impl(p0: double, p1: double, p2: java.lang.Object): boolean
     public final static method equals-impl0(p0: double, p1: double, p2: double, p3: double): boolean
     public final static method f-impl(p0: double, p1: double, p2: double): double
-    public final static method functionWithInlineClass-Qn1smSk(p0: double, p1: double, p2: double, p3: double, p4: int): int
+    public final static method functionWithInlineClass-VZ1VC2s(p0: double, p1: double, p2: double, p3: double, p4: int): int
     public final method getX(): double
     public final method getY(): double
     public method hashCode(): int
     public static method hashCode-impl(p0: double, p1: double): int
-    public final static @org.jetbrains.annotations.Nullable method suspendFunctionWithLambda-lIoT8es(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method suspendFunctionWithLambda-qDyJxbU(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
-    public final static @org.jetbrains.annotations.Nullable method suspendInlineFunctionWithLambda-lIoT8es(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
+    public final static @org.jetbrains.annotations.Nullable method suspendInlineFunctionWithLambda-qDyJxbU(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
     public final static @org.jetbrains.annotations.Nullable method suspended-impl(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
     private final static method suspendedInline-impl$$forInline(p0: double, p1: double, p2: kotlin.coroutines.Continuation): java.lang.Object
     public final static @org.jetbrains.annotations.Nullable method suspendedInline-impl(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
@@ -294,7 +294,7 @@ public final class DPoint {
 @kotlin.Metadata
 public interface F {
     // source: 'another.kt'
-    public abstract @org.jetbrains.annotations.Nullable method run-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public abstract @org.jetbrains.annotations.Nullable method run-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.coroutines.jvm.internal.DebugMetadata
@@ -322,7 +322,7 @@ synthetic final class TestKt$box$100 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double
+    public final @org.jetbrains.annotations.NotNull method invoke-jsnAEDk(p0: double, p1: double, p2: double): java.lang.Double
 }
 
 @kotlin.Metadata
@@ -334,7 +334,7 @@ synthetic final class TestKt$box$101 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double
+    public final @org.jetbrains.annotations.NotNull method invoke-jsnAEDk(p0: double, p1: double, p2: double): java.lang.Double
 }
 
 @kotlin.Metadata
@@ -344,7 +344,7 @@ synthetic final class TestKt$box$102 {
     inner (anonymous) class TestKt$box$102
     method <init>(p0: java.lang.Object): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double
+    public final @org.jetbrains.annotations.NotNull method invoke-jsnAEDk(p0: double, p1: double, p2: double): java.lang.Double
 }
 
 @kotlin.Metadata
@@ -354,7 +354,7 @@ synthetic final class TestKt$box$103 {
     inner (anonymous) class TestKt$box$103
     method <init>(p0: java.lang.Object): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double
+    public final @org.jetbrains.annotations.NotNull method invoke-jsnAEDk(p0: double, p1: double, p2: double): java.lang.Double
 }
 
 @kotlin.Metadata
@@ -366,7 +366,7 @@ synthetic final class TestKt$box$104 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.NotNull method invoke-lIoT8es(@org.jetbrains.annotations.NotNull p0: A, p1: double, p2: double, p3: double): java.lang.Double
+    public final @org.jetbrains.annotations.NotNull method invoke-Vn1JeKA(@org.jetbrains.annotations.NotNull p0: A, p1: double, p2: double, p3: double): java.lang.Double
 }
 
 @kotlin.Metadata
@@ -378,7 +378,7 @@ synthetic final class TestKt$box$105 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.NotNull method invoke-lIoT8es(@org.jetbrains.annotations.NotNull p0: A, p1: double, p2: double, p3: double): java.lang.Double
+    public final @org.jetbrains.annotations.NotNull method invoke-Vn1JeKA(@org.jetbrains.annotations.NotNull p0: A, p1: double, p2: double, p3: double): java.lang.Double
 }
 
 @kotlin.Metadata
@@ -390,7 +390,7 @@ synthetic final class TestKt$box$106 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double, p3: double): DPoint
+    public final @org.jetbrains.annotations.NotNull method invoke-p4hbfwc(p0: double, p1: double, p2: double, p3: double): DPoint
 }
 
 @kotlin.Metadata
@@ -402,7 +402,7 @@ synthetic final class TestKt$box$107 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double, p3: double): DPoint
+    public final @org.jetbrains.annotations.NotNull method invoke-p4hbfwc(p0: double, p1: double, p2: double, p3: double): DPoint
 }
 
 @kotlin.coroutines.jvm.internal.DebugMetadata
@@ -430,7 +430,7 @@ final class TestKt$box$110$1 {
     inner (anonymous) class TestKt$box$110$1
     static method <clinit>(): void
     method <init>(): void
-    public final @org.jetbrains.annotations.Nullable method run-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method run-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.coroutines.jvm.internal.DebugMetadata
@@ -459,7 +459,7 @@ final class TestKt$box$111$1 {
     inner (anonymous) class TestKt$box$111$1
     static method <clinit>(): void
     method <init>(): void
-    public final @org.jetbrains.annotations.Nullable method run-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method run-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.coroutines.jvm.internal.DebugMetadata
@@ -489,7 +489,7 @@ synthetic final class TestKt$box$12$1 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.coroutines.jvm.internal.DebugMetadata
@@ -519,7 +519,7 @@ synthetic final class TestKt$box$13$2 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.coroutines.jvm.internal.DebugMetadata
@@ -549,7 +549,7 @@ synthetic final class TestKt$box$14$2 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.coroutines.jvm.internal.DebugMetadata
@@ -579,7 +579,7 @@ synthetic final class TestKt$box$15$1 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.coroutines.jvm.internal.DebugMetadata
@@ -609,7 +609,7 @@ synthetic final class TestKt$box$16$2 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.coroutines.jvm.internal.DebugMetadata
@@ -639,7 +639,7 @@ synthetic final class TestKt$box$17$2 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.coroutines.jvm.internal.DebugMetadata
@@ -671,7 +671,7 @@ final class TestKt$box$18$1 {
     method <init>(p0: kotlin.coroutines.Continuation): void
     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 bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
     public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
 }
 
@@ -704,7 +704,7 @@ final class TestKt$box$19$2 {
     method <init>(p0: kotlin.coroutines.Continuation): void
     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 bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
     public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
 }
 
@@ -737,7 +737,7 @@ final class TestKt$box$20$2 {
     method <init>(p0: kotlin.coroutines.Continuation): void
     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 bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
     public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
 }
 
@@ -770,7 +770,7 @@ final class TestKt$box$21$1 {
     method <init>(p0: kotlin.coroutines.Continuation): void
     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 bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
     public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
 }
 
@@ -803,7 +803,7 @@ final class TestKt$box$22$2 {
     method <init>(p0: kotlin.coroutines.Continuation): void
     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 bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
     public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
 }
 
@@ -836,7 +836,7 @@ final class TestKt$box$23$2 {
     method <init>(p0: kotlin.coroutines.Continuation): void
     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 bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
     public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
 }
 
@@ -867,7 +867,7 @@ synthetic final class TestKt$box$24$1 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.coroutines.jvm.internal.DebugMetadata
@@ -897,7 +897,7 @@ synthetic final class TestKt$box$25$2 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.coroutines.jvm.internal.DebugMetadata
@@ -927,7 +927,7 @@ synthetic final class TestKt$box$26$2 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.coroutines.jvm.internal.DebugMetadata
@@ -957,7 +957,7 @@ synthetic final class TestKt$box$27$1 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.coroutines.jvm.internal.DebugMetadata
@@ -987,7 +987,7 @@ synthetic final class TestKt$box$28$2 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.coroutines.jvm.internal.DebugMetadata
@@ -1017,7 +1017,7 @@ synthetic final class TestKt$box$29$2 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.coroutines.jvm.internal.DebugMetadata
@@ -1049,7 +1049,7 @@ final class TestKt$box$30$1 {
     method <init>(p0: kotlin.coroutines.Continuation): void
     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 bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
     public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
 }
 
@@ -1082,7 +1082,7 @@ final class TestKt$box$31$2 {
     method <init>(p0: kotlin.coroutines.Continuation): void
     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 bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
     public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
 }
 
@@ -1115,7 +1115,7 @@ final class TestKt$box$32$2 {
     method <init>(p0: kotlin.coroutines.Continuation): void
     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 bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
     public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
 }
 
@@ -1148,7 +1148,7 @@ final class TestKt$box$33$1 {
     method <init>(p0: kotlin.coroutines.Continuation): void
     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 bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
     public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
 }
 
@@ -1181,7 +1181,7 @@ final class TestKt$box$34$2 {
     method <init>(p0: kotlin.coroutines.Continuation): void
     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 bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
     public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
 }
 
@@ -1214,7 +1214,7 @@ final class TestKt$box$35$2 {
     method <init>(p0: kotlin.coroutines.Continuation): void
     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 bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object
     public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object
 }
 
@@ -1244,7 +1244,7 @@ synthetic final class TestKt$box$47 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double, p3: double): DPoint
+    public final @org.jetbrains.annotations.NotNull method invoke-p4hbfwc(p0: double, p1: double, p2: double, p3: double): DPoint
 }
 
 @kotlin.Metadata
@@ -1256,7 +1256,7 @@ final class TestKt$box$48 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double, p3: double): DPoint
+    public final @org.jetbrains.annotations.NotNull method invoke-p4hbfwc(p0: double, p1: double, p2: double, p3: double): DPoint
 }
 
 @kotlin.Metadata
@@ -1268,7 +1268,7 @@ final class TestKt$box$51 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double, p3: double): DPoint
+    public final @org.jetbrains.annotations.NotNull method invoke-p4hbfwc(p0: double, p1: double, p2: double, p3: double): DPoint
 }
 
 @kotlin.Metadata
@@ -1364,7 +1364,7 @@ synthetic final class TestKt$box$60 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double
+    public final @org.jetbrains.annotations.NotNull method invoke-jsnAEDk(p0: double, p1: double, p2: double): java.lang.Double
 }
 
 @kotlin.Metadata
@@ -1376,7 +1376,7 @@ synthetic final class TestKt$box$61 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double
+    public final @org.jetbrains.annotations.NotNull method invoke-jsnAEDk(p0: double, p1: double, p2: double): java.lang.Double
 }
 
 @kotlin.Metadata
@@ -1398,7 +1398,7 @@ synthetic final class TestKt$box$63 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double
+    public final @org.jetbrains.annotations.NotNull method invoke-jsnAEDk(p0: double, p1: double, p2: double): java.lang.Double
 }
 
 @kotlin.Metadata
@@ -1430,7 +1430,7 @@ synthetic final class TestKt$box$66 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -1442,7 +1442,7 @@ synthetic final class TestKt$box$67 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -1464,7 +1464,7 @@ synthetic final class TestKt$box$69 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.coroutines.jvm.internal.DebugMetadata
@@ -1512,7 +1512,7 @@ synthetic final class TestKt$box$72 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -1524,7 +1524,7 @@ synthetic final class TestKt$box$73 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -1546,7 +1546,7 @@ synthetic final class TestKt$box$75 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-jsnAEDk(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -1556,7 +1556,7 @@ synthetic final class TestKt$box$76 {
     inner (anonymous) class TestKt$box$76
     method <init>(p0: java.lang.Object): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final method invoke-Qn1smSk(p0: double, p1: double, p2: int): int
+    public final method invoke-VZ1VC2s(p0: double, p1: double, p2: int): int
 }
 
 @kotlin.Metadata
@@ -1566,7 +1566,7 @@ synthetic final class TestKt$box$77 {
     inner (anonymous) class TestKt$box$77
     method <init>(p0: java.lang.Object): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final method invoke-Qn1smSk(p0: double, p1: double, p2: int): int
+    public final method invoke-VZ1VC2s(p0: double, p1: double, p2: int): int
 }
 
 @kotlin.Metadata
@@ -1578,7 +1578,7 @@ synthetic final class TestKt$box$78 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object
-    public final method invoke-jXDDuk8(p0: double, p1: double, p2: double, p3: double, p4: int): int
+    public final method invoke-pytmvKE(p0: double, p1: double, p2: double, p3: double, p4: int): int
 }
 
 @kotlin.Metadata
@@ -1590,7 +1590,7 @@ synthetic final class TestKt$box$79 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object
-    public final method invoke-jXDDuk8(p0: double, p1: double, p2: double, p3: double, p4: int): int
+    public final method invoke-pytmvKE(p0: double, p1: double, p2: double, p3: double, p4: int): int
 }
 
 @kotlin.coroutines.jvm.internal.DebugMetadata
@@ -1616,7 +1616,7 @@ synthetic final class TestKt$box$80 {
     inner (anonymous) class TestKt$box$80
     method <init>(p0: java.lang.Object): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final method invoke-Qn1smSk(p0: double, p1: double, p2: int): int
+    public final method invoke-VZ1VC2s(p0: double, p1: double, p2: int): int
 }
 
 @kotlin.Metadata
@@ -1628,7 +1628,7 @@ synthetic final class TestKt$box$81 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object
-    public final method invoke-jXDDuk8(p0: double, p1: double, p2: double, p3: double, p4: int): int
+    public final method invoke-pytmvKE(p0: double, p1: double, p2: double, p3: double, p4: int): int
 }
 
 @kotlin.Metadata
@@ -1660,7 +1660,7 @@ synthetic final class TestKt$box$84 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double
+    public final @org.jetbrains.annotations.NotNull method invoke-jsnAEDk(p0: double, p1: double, p2: double): java.lang.Double
 }
 
 @kotlin.Metadata
@@ -1672,7 +1672,7 @@ synthetic final class TestKt$box$85 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double
+    public final @org.jetbrains.annotations.NotNull method invoke-jsnAEDk(p0: double, p1: double, p2: double): java.lang.Double
 }
 
 @kotlin.Metadata
@@ -1694,7 +1694,7 @@ synthetic final class TestKt$box$87 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double
+    public final @org.jetbrains.annotations.NotNull method invoke-jsnAEDk(p0: double, p1: double, p2: double): java.lang.Double
 }
 
 @kotlin.Metadata
@@ -1704,7 +1704,7 @@ synthetic final class TestKt$box$88 {
     inner (anonymous) class TestKt$box$88
     method <init>(p0: java.lang.Object): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-lIoT8es(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-qDyJxbU(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -1714,7 +1714,7 @@ synthetic final class TestKt$box$89 {
     inner (anonymous) class TestKt$box$89
     method <init>(p0: java.lang.Object): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-lIoT8es(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-qDyJxbU(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.coroutines.jvm.internal.DebugMetadata
@@ -1742,7 +1742,7 @@ synthetic final class TestKt$box$90 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-552ch2I(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-lQKCjj0(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -1754,7 +1754,7 @@ synthetic final class TestKt$box$91 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-552ch2I(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-lQKCjj0(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -1764,7 +1764,7 @@ synthetic final class TestKt$box$92 {
     inner (anonymous) class TestKt$box$92
     method <init>(p0: java.lang.Object): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-lIoT8es(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-qDyJxbU(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -1776,7 +1776,7 @@ synthetic final class TestKt$box$93 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-552ch2I(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-lQKCjj0(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -1786,7 +1786,7 @@ synthetic final class TestKt$box$94 {
     inner (anonymous) class TestKt$box$94
     method <init>(p0: java.lang.Object): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-lIoT8es(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-qDyJxbU(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -1796,7 +1796,7 @@ synthetic final class TestKt$box$95 {
     inner (anonymous) class TestKt$box$95
     method <init>(p0: java.lang.Object): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-lIoT8es(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-qDyJxbU(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -1808,7 +1808,7 @@ synthetic final class TestKt$box$96 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-552ch2I(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-lQKCjj0(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -1820,7 +1820,7 @@ synthetic final class TestKt$box$97 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-552ch2I(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-lQKCjj0(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -1830,7 +1830,7 @@ synthetic final class TestKt$box$98 {
     inner (anonymous) class TestKt$box$98
     method <init>(p0: java.lang.Object): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-lIoT8es(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-qDyJxbU(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -1842,7 +1842,7 @@ synthetic final class TestKt$box$99 {
     static method <clinit>(): void
     method <init>(): void
     public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): java.lang.Object
-    public final @org.jetbrains.annotations.Nullable method invoke-552ch2I(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
+    public final @org.jetbrains.annotations.Nullable method invoke-lQKCjj0(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object
 }
 
 @kotlin.Metadata
@@ -1938,12 +1938,12 @@ public final class TestKt {
     inner (anonymous) class TestKt$box$98
     inner (anonymous) class TestKt$box$99
     public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
-    public final static @org.jetbrains.annotations.NotNull method consume-lIoT8es(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2): DPoint
+    public final static @org.jetbrains.annotations.NotNull method consume-_BuEyOk(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2): DPoint
-    public final static @org.jetbrains.annotations.NotNull method consumeInline-lIoT8es(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2): DPoint
+    public final static @org.jetbrains.annotations.NotNull method consumeInline-_BuEyOk(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2): DPoint
-    public final static method extensionFunction-GPBa7dw(p0: double, p1: double, p2: double): double
+    public final static method extensionFunction-jsnAEDk(p0: double, p1: double, p2: double): double
-    public final static method g-GPBa7dw(p0: double, p1: double, p2: double): double
+    public final static method g-jsnAEDk(p0: double, p1: double, p2: double): double
     public final static method id(p0: java.lang.Object): java.lang.Object
     public final static @org.jetbrains.annotations.NotNull method makeDPoint(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2): DPoint
     public final static @org.jetbrains.annotations.NotNull method makeDPointInline(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2): DPoint
-    public final static @org.jetbrains.annotations.NotNull method plus-GPBa7dw(p0: double, p1: double, p2: double, p3: double): DPoint
+    public final static @org.jetbrains.annotations.NotNull method plus-p4hbfwc(p0: double, p1: double, p2: double, p3: double): DPoint
 }

compiler/testData/codegen/box/valueClasses/inlineFunctions.txt

@@ -70,9 +70,9 @@ public final class DSegment {
 @kotlin.Metadata
 public final class DependencyKt {
     // source: 'dependency.kt'
-    public final static method getLength1-sUp7gFk(p0: double, p1: double, p2: double, p3: double): double
+    public final static method getLength1-3dRLH6g(p0: double, p1: double, p2: double, p3: double): double
-    public final static @org.jetbrains.annotations.NotNull method getMiddle1-sUp7gFk(p0: double, p1: double, p2: double, p3: double): DPoint
+    public final static @org.jetbrains.annotations.NotNull method getMiddle1-3dRLH6g(p0: double, p1: double, p2: double, p3: double): DPoint
-    public final static @org.jetbrains.annotations.NotNull method myLet-GPBa7dw(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function1): DPoint
+    public final static @org.jetbrains.annotations.NotNull method myLet-X39isKk(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function1): DPoint
     public final static method square(p0: double): double
 }
 

compiler/testData/codegen/box/valueClasses/mfvcEqualsOverride.txt

@@ -1,7 +1,7 @@
 @kotlin.Metadata
 public interface I {
     // source: 'mfvcEqualsOverride.kt'
-    public abstract method equals-sUp7gFk(p0: int, p1: int): boolean
+    public abstract method equals-7njTOxU(p0: int, p1: int): boolean
 }
 
 @kotlin.jvm.JvmInline
@@ -14,9 +14,9 @@ public final class MFVC {
     public synthetic final static method box-impl(p0: int, p1: int): MFVC
     public final static method constructor-impl(p0: int, p1: int): void
     public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
+    public method equals-7njTOxU(p0: int, p1: int): boolean
     public static method equals-impl(p0: int, p1: int, p2: java.lang.Object): boolean
     public static method equals-impl0(p0: int, p1: int, p2: int, p3: int): boolean
-    public method equals-sUp7gFk(p0: int, p1: int): boolean
     public final method getValue(): int
     public final method getY(): int
     public method hashCode(): int

compiler/testData/codegen/box/valueClasses/mfvcFieldInitializationOrder.txt

@@ -8,7 +8,7 @@ public final class A {
     public final @org.jetbrains.annotations.NotNull method getX(): DPoint
     public synthetic final method getX-x(): double
     public synthetic final method getX-y(): double
-    public final method setX-sUp7gFk(p0: double, p1: double): void
+    public final method setX-nuuzChU(p0: double, p1: double): void
 }
 
 @kotlin.Metadata
@@ -30,7 +30,7 @@ public final class B {
     public final @org.jetbrains.annotations.NotNull method getC(): DPoint
     public synthetic final method getC-x(): double
     public synthetic final method getC-y(): double
-    public final method setA-sUp7gFk(p0: double, p1: double): void
+    public final method setA-nuuzChU(p0: double, p1: double): void
 }
 
 @kotlin.jvm.JvmInline

compiler/testData/codegen/box/valueClasses/mfvcTypedEqualsGenerics.txt

@@ -41,7 +41,7 @@ public final class MFVC2 {
     public synthetic final static method box-impl(p0: Generic, p1: int): MFVC2
     public final static method constructor-impl(@org.jetbrains.annotations.NotNull p0: Generic, p1: int): void
     public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
-    public final static method equals-GPBa7dw(@org.jetbrains.annotations.NotNull p0: Generic, p1: int, p2: double, p3: int, p4: int): boolean
+    public final static method equals-7Pc2DFw(@org.jetbrains.annotations.NotNull p0: Generic, p1: int, p2: double, p3: int, p4: int): boolean
     public static method equals-impl(p0: Generic, p1: int, p2: java.lang.Object): boolean
     public final static method equals-impl0(@org.jetbrains.annotations.NotNull p0: Generic, p1: int, @org.jetbrains.annotations.NotNull p2: Generic, p3: int): boolean
     public final method getOther(): int

compiler/testData/codegen/box/valueClasses/multiModules.kt

@@ -0,0 +1,50 @@
+// WITH_STDLIB
+// LANGUAGE: +ValueClasses, +CustomEqualsInValueClasses
+// TARGET_BACKEND: JVM_IR
+// CHECK_BYTECODE_LISTING
+
+// MODULE: dependency
+
+package dependency
+
+@JvmInline
+value class DPoint(val x: Double, val y: Double)
+
+fun f() = dependency.DPoint(1.0, 2.0)
+inline fun inlined() = dependency.DPoint(1.0, 2.0)
+
+fun id(x: dependency.DPoint) = x
+inline fun idInlined(x: dependency.DPoint) = x
+
+
+// MODULE: main(dependency)
+
+package main
+
+fun f() = dependency.DPoint(1.0, 2.0)
+inline fun inlined() = dependency.DPoint(1.0, 2.0)
+fun id(x: dependency.DPoint) = x
+inline fun idInlined(x: dependency.DPoint) = x
+
+
+
+fun box(): String {
+    if (f().toString() != "DPoint(x=1.0, y=2.0)") return f().toString()
+    if (inlined().toString() != "DPoint(x=1.0, y=2.0)") return inlined().toString()
+    if (f() != f()) return f().toString()
+    if (f() != inlined()) return "${f()} ${inlined()}"
+    if (inlined() != f()) return "${inlined()} ${f()}"
+    if (inlined() != inlined()) return inlined().toString()
+    if (id(f()) != f()) return id(f()).toString()
+    if (idInlined(f()) != f()) return id(f()).toString()
+
+    if (dependency.f().toString() != "DPoint(x=1.0, y=2.0)") return dependency.f().toString()
+    if (dependency.inlined().toString() != "DPoint(x=1.0, y=2.0)") return dependency.inlined().toString()
+    if (dependency.f() != dependency.f()) return dependency.f().toString()
+    if (dependency.f() != dependency.inlined()) return "${dependency.f()} ${dependency.inlined()}"
+    if (dependency.inlined() != dependency.f()) return "${dependency.inlined()} ${dependency.f()}"
+    if (dependency.inlined() != dependency.inlined()) return dependency.inlined().toString()
+    if (dependency.id(dependency.f()) != dependency.f()) return dependency.id(dependency.f()).toString()
+    if (dependency.idInlined(dependency.f()) != dependency.f()) return dependency.id(dependency.f()).toString()
+    return "OK"
+}

compiler/testData/codegen/box/valueClasses/multiModules.txt

@@ -0,0 +1,41 @@
+Module: dependency
+@kotlin.jvm.JvmInline
+@kotlin.Metadata
+public final class dependency/DPoint {
+    // source: 'module_dependency_multiModules.kt'
+    private final field x: double
+    private final field y: double
+    private synthetic method <init>(p0: double, p1: double): void
+    public synthetic final static method box-impl(p0: double, p1: double): dependency.DPoint
+    public final static method constructor-impl(p0: double, p1: double): void
+    public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
+    public static method equals-impl(p0: double, p1: double, p2: java.lang.Object): boolean
+    public final static method equals-impl0(p0: double, p1: double, p2: double, p3: double): boolean
+    public final method getX(): double
+    public final method getY(): double
+    public method hashCode(): int
+    public static method hashCode-impl(p0: double, p1: double): int
+    public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
+    public static method toString-impl(p0: double, p1: double): java.lang.String
+    public synthetic final method unbox-impl-x(): double
+    public synthetic final method unbox-impl-y(): double
+}
+
+@kotlin.Metadata
+public final class dependency/Module_dependency_multiModulesKt {
+    // source: 'module_dependency_multiModules.kt'
+    public final static @org.jetbrains.annotations.NotNull method f(): dependency.DPoint
+    public final static @org.jetbrains.annotations.NotNull method id-ggqRWaI(p0: double, p1: double): dependency.DPoint
+    public final static @org.jetbrains.annotations.NotNull method idInlined-ggqRWaI(p0: double, p1: double): dependency.DPoint
+    public final static @org.jetbrains.annotations.NotNull method inlined(): dependency.DPoint
+}
+Module: main
+@kotlin.Metadata
+public final class main/Module_main_multiModulesKt {
+    // source: 'module_main_multiModules.kt'
+    public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
+    public final static @org.jetbrains.annotations.NotNull method f(): dependency.DPoint
+    public final static @org.jetbrains.annotations.NotNull method id-ggqRWaI(p0: double, p1: double): dependency.DPoint
+    public final static @org.jetbrains.annotations.NotNull method idInlined-ggqRWaI(p0: double, p1: double): dependency.DPoint
+    public final static @org.jetbrains.annotations.NotNull method inlined(): dependency.DPoint
+}

compiler/testData/codegen/box/valueClasses/overrides.txt

@@ -60,10 +60,10 @@ public final class DPointWithInterface {
     public method hashCode(): int
     public static method hashCode-impl(p0: double, p1: double): int
     public synthetic bridge method setSomethingGeneric(p0: java.lang.Object): void
-    public method setSomethingGeneric-sUp7gFk(p0: double, p1: double): void
+    public method setSomethingGeneric-nuuzChU(p0: double, p1: double): void
-    public static method setSomethingGeneric-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void
+    public static method setSomethingGeneric-nuuzChU(p0: double, p1: double, p2: double, p3: double): void
-    public method setSomethingMFVC-sUp7gFk(p0: double, p1: double): void
+    public method setSomethingMFVC-nuuzChU(p0: double, p1: double): void
-    public static method setSomethingMFVC-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void
+    public static method setSomethingMFVC-nuuzChU(p0: double, p1: double, p2: double, p3: double): void
     public method setSomethingRegular(p0: int): void
     public static method setSomethingRegular-impl(p0: double, p1: double, p2: int): void
     public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
@@ -154,11 +154,11 @@ public final class GenericFakeOverrideMFVC {
     public method hashCode(): int
     public static method hashCode-impl(p0: double, p1: double): int
     public synthetic bridge method setP(p0: java.lang.Object): void
-    public method setP-sUp7gFk(@org.jetbrains.annotations.NotNull p0: DPoint): void
+    public method setP-nuuzChU(@org.jetbrains.annotations.NotNull p0: DPoint): void
-    public static method setP-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void
+    public static method setP-nuuzChU(p0: double, p1: double, p2: double, p3: double): void
     public synthetic bridge method setP1(p0: java.lang.Object): void
-    public method setP1-sUp7gFk(@org.jetbrains.annotations.NotNull p0: DPoint): void
+    public method setP1-nuuzChU(@org.jetbrains.annotations.NotNull p0: DPoint): void
-    public static method setP1-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void
+    public static method setP1-nuuzChU(p0: double, p1: double, p2: double, p3: double): void
     public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
     public static method toString-impl(p0: double, p1: double): java.lang.String
     public synthetic final method unbox-impl-field1(): double
@@ -186,10 +186,10 @@ public final class GenericFakeOverrideMFVCWithMFVCUpperBound {
     public static @org.jetbrains.annotations.NotNull method getP1-impl(p0: double, p1: double): DPoint
     public method hashCode(): int
     public static method hashCode-impl(p0: double, p1: double): int
-    public method setP-sUp7gFk(p0: double, p1: double): void
+    public method setP-nuuzChU(p0: double, p1: double): void
-    public static method setP-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void
+    public static method setP-nuuzChU(p0: double, p1: double, p2: double, p3: double): void
-    public method setP1-sUp7gFk(p0: double, p1: double): void
+    public method setP1-nuuzChU(p0: double, p1: double): void
-    public static method setP1-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void
+    public static method setP1-nuuzChU(p0: double, p1: double, p2: double, p3: double): void
     public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
     public static method toString-impl(p0: double, p1: double): java.lang.String
     public synthetic final method unbox-impl-field1(): double
@@ -203,8 +203,8 @@ public final class GenericFakeOverrideWithMFVCUpperBound {
     public method <init>(): void
     public @org.jetbrains.annotations.NotNull method getP(): DPoint
     public @org.jetbrains.annotations.NotNull method getP1(): DPoint
-    public method setP-sUp7gFk(p0: double, p1: double): void
+    public method setP-nuuzChU(p0: double, p1: double): void
-    public method setP1-sUp7gFk(p0: double, p1: double): void
+    public method setP1-nuuzChU(p0: double, p1: double): void
     public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls
 }
 
@@ -246,8 +246,8 @@ public interface GenericMFVCHolderWithMFVCUpperBound {
     public abstract @org.jetbrains.annotations.NotNull method getP1(): DPoint
     public synthetic abstract method getP1-x(): double
     public synthetic abstract method getP1-y(): double
-    public abstract method setP-sUp7gFk(p0: double, p1: double): void
+    public abstract method setP-nuuzChU(p0: double, p1: double): void
-    public abstract method setP1-sUp7gFk(p0: double, p1: double): void
+    public abstract method setP1-nuuzChU(p0: double, p1: double): void
 }
 
 @kotlin.Metadata
@@ -259,8 +259,8 @@ public final class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls {
     public static @org.jetbrains.annotations.NotNull method getP1(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): DPoint
     public synthetic static method getP1-x(p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): double
     public synthetic static method getP1-y(p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): double
-    public static method setP-sUp7gFk(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls, p1: double, p2: double): void
+    public static method setP-nuuzChU(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls, p1: double, p2: double): void
-    public static method setP1-sUp7gFk(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls, p1: double, p2: double): void
+    public static method setP1-nuuzChU(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls, p1: double, p2: double): void
     public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls
 }
 
@@ -273,8 +273,8 @@ public interface GenericMFVCHolderWithMFVCUpperBoundWithImpls {
     public abstract @org.jetbrains.annotations.NotNull method getP1(): DPoint
     public synthetic abstract method getP1-x(): double
     public synthetic abstract method getP1-y(): double
-    public abstract method setP-sUp7gFk(p0: double, p1: double): void
+    public abstract method setP-nuuzChU(p0: double, p1: double): void
-    public abstract method setP1-sUp7gFk(p0: double, p1: double): void
+    public abstract method setP1-nuuzChU(p0: double, p1: double): void
     public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls
 }
 
@@ -2478,9 +2478,9 @@ public final class RealOverride {
     public synthetic method getP1-x(): double
     public synthetic method getP1-y(): double
     public synthetic bridge method setP(p0: java.lang.Object): void
-    public method setP-sUp7gFk(p0: double, p1: double): void
+    public method setP-nuuzChU(p0: double, p1: double): void
     public synthetic bridge method setP1(p0: java.lang.Object): void
-    public method setP1-sUp7gFk(p0: double, p1: double): void
+    public method setP1-nuuzChU(p0: double, p1: double): void
 }
 
 @kotlin.Metadata
@@ -2489,8 +2489,8 @@ public final class ReifiedFakeOverride {
     public method <init>(): void
     public @org.jetbrains.annotations.NotNull method getP(): DPoint
     public @org.jetbrains.annotations.NotNull method getP1(): DPoint
-    public method setP-sUp7gFk(p0: double, p1: double): void
+    public method setP-nuuzChU(p0: double, p1: double): void
-    public method setP1-sUp7gFk(p0: double, p1: double): void
+    public method setP1-nuuzChU(p0: double, p1: double): void
     public final inner class ReifiedMFVCHolderWithImpls$DefaultImpls
 }
 
@@ -2514,10 +2514,10 @@ public final class ReifiedFakeOverrideMFVC {
     public static @org.jetbrains.annotations.NotNull method getP1-impl(p0: double, p1: double): DPoint
     public method hashCode(): int
     public static method hashCode-impl(p0: double, p1: double): int
-    public method setP-sUp7gFk(p0: double, p1: double): void
+    public method setP-nuuzChU(p0: double, p1: double): void
-    public static method setP-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void
+    public static method setP-nuuzChU(p0: double, p1: double, p2: double, p3: double): void
-    public method setP1-sUp7gFk(p0: double, p1: double): void
+    public method setP1-nuuzChU(p0: double, p1: double): void
-    public static method setP1-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void
+    public static method setP1-nuuzChU(p0: double, p1: double, p2: double, p3: double): void
     public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
     public static method toString-impl(p0: double, p1: double): java.lang.String
     public synthetic final method unbox-impl-field1(): double
@@ -2534,8 +2534,8 @@ public interface ReifiedMFVCHolder {
     public abstract @org.jetbrains.annotations.NotNull method getP1(): DPoint
     public synthetic abstract method getP1-x(): double
     public synthetic abstract method getP1-y(): double
-    public abstract method setP-sUp7gFk(p0: double, p1: double): void
+    public abstract method setP-nuuzChU(p0: double, p1: double): void
-    public abstract method setP1-sUp7gFk(p0: double, p1: double): void
+    public abstract method setP1-nuuzChU(p0: double, p1: double): void
 }
 
 @kotlin.Metadata
@@ -2547,8 +2547,8 @@ public final class ReifiedMFVCHolderWithImpls$DefaultImpls {
     public static @org.jetbrains.annotations.NotNull method getP1(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls): DPoint
     public synthetic static method getP1-x(p0: ReifiedMFVCHolderWithImpls): double
     public synthetic static method getP1-y(p0: ReifiedMFVCHolderWithImpls): double
-    public static method setP-sUp7gFk(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls, p1: double, p2: double): void
+    public static method setP-nuuzChU(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls, p1: double, p2: double): void
-    public static method setP1-sUp7gFk(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls, p1: double, p2: double): void
+    public static method setP1-nuuzChU(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls, p1: double, p2: double): void
     public final inner class ReifiedMFVCHolderWithImpls$DefaultImpls
 }
 
@@ -2561,8 +2561,8 @@ public interface ReifiedMFVCHolderWithImpls {
     public abstract @org.jetbrains.annotations.NotNull method getP1(): DPoint
     public synthetic abstract method getP1-x(): double
     public synthetic abstract method getP1-y(): double
-    public abstract method setP-sUp7gFk(p0: double, p1: double): void
+    public abstract method setP-nuuzChU(p0: double, p1: double): void
-    public abstract method setP1-sUp7gFk(p0: double, p1: double): void
+    public abstract method setP1-nuuzChU(p0: double, p1: double): void
     public final inner class ReifiedMFVCHolderWithImpls$DefaultImpls
 }
 
@@ -2575,7 +2575,7 @@ public interface SomePointInterface {
     public synthetic abstract method getSomethingMFVC-y(): double
     public abstract method getSomethingRegular(): int
     public abstract method setSomethingGeneric(p0: java.lang.Object): void
-    public abstract method setSomethingMFVC-sUp7gFk(p0: double, p1: double): void
+    public abstract method setSomethingMFVC-nuuzChU(p0: double, p1: double): void
     public abstract method setSomethingRegular(p0: int): void
 }
 
@@ -2589,7 +2589,7 @@ public interface SomePointInterfaceWithMFVCBound {
     public synthetic abstract method getSomethingMFVC-x(): double
     public synthetic abstract method getSomethingMFVC-y(): double
     public abstract method getSomethingRegular(): int
-    public abstract method setSomethingGeneric-sUp7gFk(p0: double, p1: double): void
+    public abstract method setSomethingGeneric-nuuzChU(p0: double, p1: double): void
-    public abstract method setSomethingMFVC-sUp7gFk(p0: double, p1: double): void
+    public abstract method setSomethingMFVC-nuuzChU(p0: double, p1: double): void
     public abstract method setSomethingRegular(p0: int): void
 }

compiler/testData/codegen/box/valueClasses/overrides_inlineClass.txt

@@ -60,10 +60,10 @@ public final class DPointWithInterface {
     public method hashCode(): int
     public static method hashCode-impl(p0: double, p1: double): int
     public synthetic bridge method setSomethingGeneric(p0: java.lang.Object): void
-    public method setSomethingGeneric-sUp7gFk(p0: double, p1: double): void
+    public method setSomethingGeneric-nuuzChU(p0: double, p1: double): void
-    public static method setSomethingGeneric-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void
+    public static method setSomethingGeneric-nuuzChU(p0: double, p1: double, p2: double, p3: double): void
-    public method setSomethingMFVC-sUp7gFk(p0: double, p1: double): void
+    public method setSomethingMFVC-nuuzChU(p0: double, p1: double): void
-    public static method setSomethingMFVC-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void
+    public static method setSomethingMFVC-nuuzChU(p0: double, p1: double, p2: double, p3: double): void
     public method setSomethingRegular(p0: int): void
     public static method setSomethingRegular-impl(p0: double, p1: double, p2: int): void
     public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
@@ -154,11 +154,11 @@ public final class GenericFakeOverrideMFVC {
     public method hashCode(): int
     public static method hashCode-impl(p0: double, p1: double): int
     public synthetic bridge method setP(p0: java.lang.Object): void
-    public method setP-sUp7gFk(@org.jetbrains.annotations.NotNull p0: DPoint): void
+    public method setP-nuuzChU(@org.jetbrains.annotations.NotNull p0: DPoint): void
-    public static method setP-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void
+    public static method setP-nuuzChU(p0: double, p1: double, p2: double, p3: double): void
     public synthetic bridge method setP1(p0: java.lang.Object): void
-    public method setP1-sUp7gFk(@org.jetbrains.annotations.NotNull p0: DPoint): void
+    public method setP1-nuuzChU(@org.jetbrains.annotations.NotNull p0: DPoint): void
-    public static method setP1-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void
+    public static method setP1-nuuzChU(p0: double, p1: double, p2: double, p3: double): void
     public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
     public static method toString-impl(p0: double, p1: double): java.lang.String
     public synthetic final method unbox-impl-field1(): double
@@ -186,10 +186,10 @@ public final class GenericFakeOverrideMFVCWithMFVCUpperBound {
     public static @org.jetbrains.annotations.NotNull method getP1-impl(p0: double, p1: double): DPoint
     public method hashCode(): int
     public static method hashCode-impl(p0: double, p1: double): int
-    public method setP-sUp7gFk(p0: double, p1: double): void
+    public method setP-nuuzChU(p0: double, p1: double): void
-    public static method setP-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void
+    public static method setP-nuuzChU(p0: double, p1: double, p2: double, p3: double): void
-    public method setP1-sUp7gFk(p0: double, p1: double): void
+    public method setP1-nuuzChU(p0: double, p1: double): void
-    public static method setP1-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void
+    public static method setP1-nuuzChU(p0: double, p1: double, p2: double, p3: double): void
     public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
     public static method toString-impl(p0: double, p1: double): java.lang.String
     public synthetic final method unbox-impl-field1(): double
@@ -203,8 +203,8 @@ public final class GenericFakeOverrideWithMFVCUpperBound {
     public method <init>(): void
     public @org.jetbrains.annotations.NotNull method getP(): DPoint
     public @org.jetbrains.annotations.NotNull method getP1(): DPoint
-    public method setP-sUp7gFk(p0: double, p1: double): void
+    public method setP-nuuzChU(p0: double, p1: double): void
-    public method setP1-sUp7gFk(p0: double, p1: double): void
+    public method setP1-nuuzChU(p0: double, p1: double): void
     public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls
 }
 
@@ -246,8 +246,8 @@ public interface GenericMFVCHolderWithMFVCUpperBound {
     public abstract @org.jetbrains.annotations.NotNull method getP1(): DPoint
     public synthetic abstract method getP1-x(): double
     public synthetic abstract method getP1-y(): double
-    public abstract method setP-sUp7gFk(p0: double, p1: double): void
+    public abstract method setP-nuuzChU(p0: double, p1: double): void
-    public abstract method setP1-sUp7gFk(p0: double, p1: double): void
+    public abstract method setP1-nuuzChU(p0: double, p1: double): void
 }
 
 @kotlin.Metadata
@@ -259,8 +259,8 @@ public final class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls {
     public static @org.jetbrains.annotations.NotNull method getP1(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): DPoint
     public synthetic static method getP1-x(p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): double
     public synthetic static method getP1-y(p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): double
-    public static method setP-sUp7gFk(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls, p1: double, p2: double): void
+    public static method setP-nuuzChU(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls, p1: double, p2: double): void
-    public static method setP1-sUp7gFk(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls, p1: double, p2: double): void
+    public static method setP1-nuuzChU(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls, p1: double, p2: double): void
     public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls
 }
 
@@ -273,8 +273,8 @@ public interface GenericMFVCHolderWithMFVCUpperBoundWithImpls {
     public abstract @org.jetbrains.annotations.NotNull method getP1(): DPoint
     public synthetic abstract method getP1-x(): double
     public synthetic abstract method getP1-y(): double
-    public abstract method setP-sUp7gFk(p0: double, p1: double): void
+    public abstract method setP-nuuzChU(p0: double, p1: double): void
-    public abstract method setP1-sUp7gFk(p0: double, p1: double): void
+    public abstract method setP1-nuuzChU(p0: double, p1: double): void
     public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls
 }
 
@@ -2494,9 +2494,9 @@ public final class RealOverride {
     public synthetic method getP1-x(): double
     public synthetic method getP1-y(): double
     public synthetic bridge method setP(p0: java.lang.Object): void
-    public method setP-sUp7gFk(p0: double, p1: double): void
+    public method setP-nuuzChU(p0: double, p1: double): void
     public synthetic bridge method setP1(p0: java.lang.Object): void
-    public method setP1-sUp7gFk(p0: double, p1: double): void
+    public method setP1-nuuzChU(p0: double, p1: double): void
 }
 
 @kotlin.Metadata
@@ -2505,8 +2505,8 @@ public final class ReifiedFakeOverride {
     public method <init>(): void
     public @org.jetbrains.annotations.NotNull method getP(): DPoint
     public @org.jetbrains.annotations.NotNull method getP1(): DPoint
-    public method setP-sUp7gFk(p0: double, p1: double): void
+    public method setP-nuuzChU(p0: double, p1: double): void
-    public method setP1-sUp7gFk(p0: double, p1: double): void
+    public method setP1-nuuzChU(p0: double, p1: double): void
     public final inner class ReifiedMFVCHolderWithImpls$DefaultImpls
 }
 
@@ -2530,10 +2530,10 @@ public final class ReifiedFakeOverrideMFVC {
     public static @org.jetbrains.annotations.NotNull method getP1-impl(p0: double, p1: double): DPoint
     public method hashCode(): int
     public static method hashCode-impl(p0: double, p1: double): int
-    public method setP-sUp7gFk(p0: double, p1: double): void
+    public method setP-nuuzChU(p0: double, p1: double): void
-    public static method setP-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void
+    public static method setP-nuuzChU(p0: double, p1: double, p2: double, p3: double): void
-    public method setP1-sUp7gFk(p0: double, p1: double): void
+    public method setP1-nuuzChU(p0: double, p1: double): void
-    public static method setP1-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void
+    public static method setP1-nuuzChU(p0: double, p1: double, p2: double, p3: double): void
     public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
     public static method toString-impl(p0: double, p1: double): java.lang.String
     public synthetic final method unbox-impl-field1(): double
@@ -2550,8 +2550,8 @@ public interface ReifiedMFVCHolder {
     public abstract @org.jetbrains.annotations.NotNull method getP1(): DPoint
     public synthetic abstract method getP1-x(): double
     public synthetic abstract method getP1-y(): double
-    public abstract method setP-sUp7gFk(p0: double, p1: double): void
+    public abstract method setP-nuuzChU(p0: double, p1: double): void
-    public abstract method setP1-sUp7gFk(p0: double, p1: double): void
+    public abstract method setP1-nuuzChU(p0: double, p1: double): void
 }
 
 @kotlin.Metadata
@@ -2563,8 +2563,8 @@ public final class ReifiedMFVCHolderWithImpls$DefaultImpls {
     public static @org.jetbrains.annotations.NotNull method getP1(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls): DPoint
     public synthetic static method getP1-x(p0: ReifiedMFVCHolderWithImpls): double
     public synthetic static method getP1-y(p0: ReifiedMFVCHolderWithImpls): double
-    public static method setP-sUp7gFk(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls, p1: double, p2: double): void
+    public static method setP-nuuzChU(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls, p1: double, p2: double): void
-    public static method setP1-sUp7gFk(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls, p1: double, p2: double): void
+    public static method setP1-nuuzChU(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls, p1: double, p2: double): void
     public final inner class ReifiedMFVCHolderWithImpls$DefaultImpls
 }
 
@@ -2577,8 +2577,8 @@ public interface ReifiedMFVCHolderWithImpls {
     public abstract @org.jetbrains.annotations.NotNull method getP1(): DPoint
     public synthetic abstract method getP1-x(): double
     public synthetic abstract method getP1-y(): double
-    public abstract method setP-sUp7gFk(p0: double, p1: double): void
+    public abstract method setP-nuuzChU(p0: double, p1: double): void
-    public abstract method setP1-sUp7gFk(p0: double, p1: double): void
+    public abstract method setP1-nuuzChU(p0: double, p1: double): void
     public final inner class ReifiedMFVCHolderWithImpls$DefaultImpls
 }
 
@@ -2591,7 +2591,7 @@ public interface SomePointInterface {
     public synthetic abstract method getSomethingMFVC-y(): double
     public abstract method getSomethingRegular(): int
     public abstract method setSomethingGeneric(p0: java.lang.Object): void
-    public abstract method setSomethingMFVC-sUp7gFk(p0: double, p1: double): void
+    public abstract method setSomethingMFVC-nuuzChU(p0: double, p1: double): void
     public abstract method setSomethingRegular(p0: int): void
 }
 
@@ -2605,7 +2605,7 @@ public interface SomePointInterfaceWithMFVCBound {
     public synthetic abstract method getSomethingMFVC-x(): double
     public synthetic abstract method getSomethingMFVC-y(): double
     public abstract method getSomethingRegular(): int
-    public abstract method setSomethingGeneric-sUp7gFk(p0: double, p1: double): void
+    public abstract method setSomethingGeneric-nuuzChU(p0: double, p1: double): void
-    public abstract method setSomethingMFVC-sUp7gFk(p0: double, p1: double): void
+    public abstract method setSomethingMFVC-nuuzChU(p0: double, p1: double): void
     public abstract method setSomethingRegular(p0: int): void
 }

compiler/testData/codegen/box/valueClasses/overrides_typeParameters.txt

@@ -64,11 +64,11 @@ public final class GenericFakeOverrideMFVC {
     public method hashCode(): int
     public static method hashCode-impl(p0: java.lang.Object, p1: java.lang.Object): int
     public synthetic bridge method setP(p0: java.lang.Object): void
-    public method setP-sUp7gFk(@org.jetbrains.annotations.NotNull p0: XPoint): void
+    public method setP-E-wHi0Q(@org.jetbrains.annotations.NotNull p0: XPoint): void
-    public static method setP-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void
+    public static method setP-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void
     public synthetic bridge method setP1(p0: java.lang.Object): void
-    public method setP1-sUp7gFk(@org.jetbrains.annotations.NotNull p0: XPoint): void
+    public method setP1-E-wHi0Q(@org.jetbrains.annotations.NotNull p0: XPoint): void
-    public static method setP1-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void
+    public static method setP1-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void
     public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
     public static method toString-impl(p0: java.lang.Object, p1: java.lang.Object): java.lang.String
     public synthetic final method unbox-impl-field1(): java.lang.Object
@@ -96,10 +96,10 @@ public final class GenericFakeOverrideMFVCWithMFVCUpperBound {
     public static @org.jetbrains.annotations.NotNull method getP1-impl(p0: java.lang.Object, p1: java.lang.Object): XPoint
     public method hashCode(): int
     public static method hashCode-impl(p0: java.lang.Object, p1: java.lang.Object): int
-    public method setP-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public method setP-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
-    public static method setP-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void
+    public static method setP-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void
-    public method setP1-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public method setP1-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
-    public static method setP1-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void
+    public static method setP1-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void
     public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
     public static method toString-impl(p0: java.lang.Object, p1: java.lang.Object): java.lang.String
     public synthetic final method unbox-impl-field1(): java.lang.Object
@@ -113,8 +113,8 @@ public final class GenericFakeOverrideWithMFVCUpperBound {
     public method <init>(): void
     public @org.jetbrains.annotations.NotNull method getP(): XPoint
     public @org.jetbrains.annotations.NotNull method getP1(): XPoint
-    public method setP-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public method setP-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
-    public method setP1-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public method setP1-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
     public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls
 }
 
@@ -156,8 +156,8 @@ public interface GenericMFVCHolderWithMFVCUpperBound {
     public abstract @org.jetbrains.annotations.NotNull method getP1(): XPoint
     public synthetic abstract method getP1-x(): java.lang.Object
     public synthetic abstract method getP1-y(): java.lang.Object
-    public abstract method setP-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public abstract method setP-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
-    public abstract method setP1-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public abstract method setP1-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
 }
 
 @kotlin.Metadata
@@ -169,8 +169,8 @@ public final class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls {
     public static @org.jetbrains.annotations.NotNull method getP1(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): XPoint
     public synthetic static method getP1-x(p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): java.lang.Object
     public synthetic static method getP1-y(p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): java.lang.Object
-    public static method setP-sUp7gFk(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls, p1: java.lang.Object, p2: java.lang.Object): void
+    public static method setP-E-wHi0Q(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls, p1: java.lang.Object, p2: java.lang.Object): void
-    public static method setP1-sUp7gFk(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls, p1: java.lang.Object, p2: java.lang.Object): void
+    public static method setP1-E-wHi0Q(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls, p1: java.lang.Object, p2: java.lang.Object): void
     public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls
 }
 
@@ -183,8 +183,8 @@ public interface GenericMFVCHolderWithMFVCUpperBoundWithImpls {
     public abstract @org.jetbrains.annotations.NotNull method getP1(): XPoint
     public synthetic abstract method getP1-x(): java.lang.Object
     public synthetic abstract method getP1-y(): java.lang.Object
-    public abstract method setP-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public abstract method setP-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
-    public abstract method setP1-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public abstract method setP1-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
     public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls
 }
 
@@ -2371,7 +2371,7 @@ public final class Overrides_typeParametersKt {
     public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
     public final static method equal(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function0, @org.jetbrains.annotations.NotNull p1: kotlin.jvm.functions.Function0): void
     public final static method genericFunctionIC-lld4ICU(@org.jetbrains.annotations.NotNull p0: java.lang.Object): void
-    public final static method genericFunctionMFVC-sUp7gFk(@org.jetbrains.annotations.NotNull p0: java.util.List, @org.jetbrains.annotations.NotNull p1: java.util.List): void
+    public final static method genericFunctionMFVC-E-wHi0Q(@org.jetbrains.annotations.NotNull p0: java.util.List, @org.jetbrains.annotations.NotNull p1: java.util.List): void
 }
 
 @kotlin.Metadata
@@ -2390,9 +2390,9 @@ public final class RealOverride {
     public synthetic method getP1-x(): java.lang.Object
     public synthetic method getP1-y(): java.lang.Object
     public synthetic bridge method setP(p0: java.lang.Object): void
-    public method setP-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public method setP-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
     public synthetic bridge method setP1(p0: java.lang.Object): void
-    public method setP1-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public method setP1-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
 }
 
 @kotlin.Metadata
@@ -2401,8 +2401,8 @@ public final class ReifiedFakeOverride {
     public method <init>(): void
     public @org.jetbrains.annotations.NotNull method getP(): XPoint
     public @org.jetbrains.annotations.NotNull method getP1(): XPoint
-    public method setP-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public method setP-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
-    public method setP1-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public method setP1-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
     public final inner class ReifiedMFVCHolderWithImpls$DefaultImpls
 }
 
@@ -2426,10 +2426,10 @@ public final class ReifiedFakeOverrideMFVC {
     public static @org.jetbrains.annotations.NotNull method getP1-impl(p0: java.lang.Object, p1: java.lang.Object): XPoint
     public method hashCode(): int
     public static method hashCode-impl(p0: java.lang.Object, p1: java.lang.Object): int
-    public method setP-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public method setP-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
-    public static method setP-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void
+    public static method setP-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void
-    public method setP1-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public method setP1-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
-    public static method setP1-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void
+    public static method setP1-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void
     public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
     public static method toString-impl(p0: java.lang.Object, p1: java.lang.Object): java.lang.String
     public synthetic final method unbox-impl-field1(): java.lang.Object
@@ -2446,8 +2446,8 @@ public interface ReifiedMFVCHolder {
     public abstract @org.jetbrains.annotations.NotNull method getP1(): XPoint
     public synthetic abstract method getP1-x(): java.lang.Object
     public synthetic abstract method getP1-y(): java.lang.Object
-    public abstract method setP-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public abstract method setP-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
-    public abstract method setP1-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public abstract method setP1-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
 }
 
 @kotlin.Metadata
@@ -2459,8 +2459,8 @@ public final class ReifiedMFVCHolderWithImpls$DefaultImpls {
     public static @org.jetbrains.annotations.NotNull method getP1(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls): XPoint
     public synthetic static method getP1-x(p0: ReifiedMFVCHolderWithImpls): java.lang.Object
     public synthetic static method getP1-y(p0: ReifiedMFVCHolderWithImpls): java.lang.Object
-    public static method setP-sUp7gFk(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls, p1: java.lang.Object, p2: java.lang.Object): void
+    public static method setP-E-wHi0Q(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls, p1: java.lang.Object, p2: java.lang.Object): void
-    public static method setP1-sUp7gFk(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls, p1: java.lang.Object, p2: java.lang.Object): void
+    public static method setP1-E-wHi0Q(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls, p1: java.lang.Object, p2: java.lang.Object): void
     public final inner class ReifiedMFVCHolderWithImpls$DefaultImpls
 }
 
@@ -2473,8 +2473,8 @@ public interface ReifiedMFVCHolderWithImpls {
     public abstract @org.jetbrains.annotations.NotNull method getP1(): XPoint
     public synthetic abstract method getP1-x(): java.lang.Object
     public synthetic abstract method getP1-y(): java.lang.Object
-    public abstract method setP-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public abstract method setP-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
-    public abstract method setP1-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public abstract method setP1-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
     public final inner class ReifiedMFVCHolderWithImpls$DefaultImpls
 }
 
@@ -2482,7 +2482,7 @@ public interface ReifiedMFVCHolderWithImpls {
 public final class SomeInterface$DefaultImpls {
     // source: 'overrides_typeParameters.kt'
     public static method someFunction1(@org.jetbrains.annotations.NotNull p0: SomeInterface, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void
-    public static method someFunction2-lIoT8es(@org.jetbrains.annotations.NotNull p0: SomeInterface, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object, p4: java.lang.Object, p5: java.lang.Object, p6: java.lang.Object): void
+    public static method someFunction2-bw8FDaY(@org.jetbrains.annotations.NotNull p0: SomeInterface, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object, p4: java.lang.Object, p5: java.lang.Object, p6: java.lang.Object): void
     public final inner class SomeInterface$DefaultImpls
 }
 
@@ -2490,7 +2490,7 @@ public final class SomeInterface$DefaultImpls {
 public interface SomeInterface {
     // source: 'overrides_typeParameters.kt'
     public abstract method someFunction1(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): void
-    public abstract method someFunction2-lIoT8es(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object, p4: java.lang.Object, p5: java.lang.Object): void
+    public abstract method someFunction2-bw8FDaY(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object, p4: java.lang.Object, p5: java.lang.Object): void
     public final inner class SomeInterface$DefaultImpls
 }
 
@@ -2503,7 +2503,7 @@ public interface SomePointInterface {
     public synthetic abstract method getSomethingMFVC-y(): java.lang.Object
     public abstract method getSomethingRegular(): int
     public abstract method setSomethingGeneric(p0: java.lang.Object): void
-    public abstract method setSomethingMFVC-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public abstract method setSomethingMFVC-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
     public abstract method setSomethingRegular(p0: int): void
 }
 
@@ -2517,8 +2517,8 @@ public interface SomePointInterfaceWithMFVCBound {
     public synthetic abstract method getSomethingMFVC-x(): java.lang.Object
     public synthetic abstract method getSomethingMFVC-y(): java.lang.Object
     public abstract method getSomethingRegular(): int
-    public abstract method setSomethingGeneric-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public abstract method setSomethingGeneric-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
-    public abstract method setSomethingMFVC-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public abstract method setSomethingMFVC-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
     public abstract method setSomethingRegular(p0: int): void
 }
 
@@ -2540,8 +2540,8 @@ public final class XPoint {
     public static method hashCode-impl(p0: java.lang.Object, p1: java.lang.Object): int
     public method someFunction1(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): void
     public static method someFunction1-impl(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object, p4: java.lang.Object): void
-    public method someFunction2-lIoT8es(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object, p4: java.lang.Object, p5: java.lang.Object): void
+    public method someFunction2-bw8FDaY(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object, p4: java.lang.Object, p5: java.lang.Object): void
-    public static method someFunction2-lIoT8es(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, p7: java.lang.Object): void
+    public static method someFunction2-bw8FDaY(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, p7: java.lang.Object): void
     public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
     public static method toString-impl(p0: java.lang.Object, p1: java.lang.Object): java.lang.String
     public synthetic final method unbox-impl-x(): java.lang.Object
@@ -2572,10 +2572,10 @@ public final class XPointWithInterface {
     public method hashCode(): int
     public static method hashCode-impl(p0: java.lang.Object, p1: java.lang.Object): int
     public synthetic bridge method setSomethingGeneric(p0: java.lang.Object): void
-    public method setSomethingGeneric-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public method setSomethingGeneric-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
-    public static method setSomethingGeneric-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void
+    public static method setSomethingGeneric-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void
-    public method setSomethingMFVC-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void
+    public method setSomethingMFVC-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object): void
-    public static method setSomethingMFVC-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void
+    public static method setSomethingMFVC-E-wHi0Q(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void
     public method setSomethingRegular(p0: int): void
     public static method setSomethingRegular-impl(p0: java.lang.Object, p1: java.lang.Object, p2: int): void
     public @org.jetbrains.annotations.NotNull method toString(): java.lang.String

compiler/testData/codegen/box/valueClasses/regularClassSecondaryConstructorWithMfvc.kt

@@ -0,0 +1,22 @@
+// WITH_STDLIB
+// LANGUAGE: +ValueClasses, +CustomEqualsInValueClasses
+// TARGET_BACKEND: JVM_IR
+// CHECK_BYTECODE_LISTING
+
+
+@JvmInline
+value
+class Point(val x: Double, val y: Double)
+
+data class Line(val a: Point = Point(-300.0, -400.0), val b: Point) {
+    constructor(x0: Float, y0: Float, x1: Float, y1: Float) : this(Point(x0.toDouble(), y0.toDouble()), Point(x1.toDouble(), y1.toDouble()))
+    constructor(a: Point = Point(-100.0, -200.0), x1: Float, y1: Float) : this(a, Point(x1.toDouble(), y1.toDouble()))
+}
+
+fun box(): String {
+    if (Line(Point(1.0, 2.0), Point(3.0, 4.0)) != Line(1.0f, 2.0f, 3.0f, 4.0f)) return Line(1.0f, 2.0f, 3.0f, 4.0f).toString()
+    if (Line(Point(1.0, 2.0), Point(3.0, 4.0)) != Line(Point(1.0, 2.0), 3.0f, 4.0f)) return Line(Point(1.0, 2.0), 3.0f, 4.0f).toString()
+    if (Line(Point(-300.0, -400.0), Point(3.0, 4.0)) != Line(b = Point(3.0, 4.0))) return Line(b = Point(3.0, 4.0)).toString()
+    if (Line(Point(-100.0, -200.0), Point(5.0, 6.0)) != Line(x1 = 5.0f, y1 = 6.0f)) return Line(x1 = 5.0f, y1 = 6.0f).toString()
+    return "OK"
+}

compiler/testData/codegen/box/valueClasses/regularClassSecondaryConstructorWithMfvc.txt

@@ -0,0 +1,56 @@
+@kotlin.Metadata
+public final class Line {
+    // source: 'regularClassSecondaryConstructorWithMfvc.kt'
+    private final field a-x: double
+    private final field a-y: double
+    private final field b-x: double
+    private final field b-y: double
+    private method <init>(p0: double, p1: double, p2: double, p3: double): void
+    public synthetic method <init>(p0: double, p1: double, p2: double, p3: double, p4: int, p5: kotlin.jvm.internal.DefaultConstructorMarker): void
+    public synthetic method <init>(p0: double, p1: double, p2: double, p3: double, p4: kotlin.jvm.internal.DefaultConstructorMarker): void
+    private method <init>(p0: double, p1: double, p2: float, p3: float): void
+    public synthetic method <init>(p0: double, p1: double, p2: float, p3: float, p4: int, p5: kotlin.jvm.internal.DefaultConstructorMarker): void
+    public synthetic method <init>(p0: double, p1: double, p2: float, p3: float, p4: kotlin.jvm.internal.DefaultConstructorMarker): void
+    public method <init>(p0: float, p1: float, p2: float, p3: float): void
+    public final @org.jetbrains.annotations.NotNull method component1(): Point
+    public final @org.jetbrains.annotations.NotNull method component2(): Point
+    public synthetic static method copy-twsj498$default(p0: Line, p1: double, p2: double, p3: double, p4: double, p5: int, p6: java.lang.Object): Line
+    public final @org.jetbrains.annotations.NotNull method copy-twsj498(p0: double, p1: double, p2: double, p3: double): Line
+    public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
+    public final @org.jetbrains.annotations.NotNull method getA(): Point
+    public synthetic final method getA-x(): double
+    public synthetic final method getA-y(): double
+    public final @org.jetbrains.annotations.NotNull method getB(): Point
+    public synthetic final method getB-x(): double
+    public synthetic final method getB-y(): double
+    public method hashCode(): int
+    public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
+}
+
+@kotlin.jvm.JvmInline
+@kotlin.Metadata
+public final class Point {
+    // source: 'regularClassSecondaryConstructorWithMfvc.kt'
+    private final field x: double
+    private final field y: double
+    private synthetic method <init>(p0: double, p1: double): void
+    public synthetic final static method box-impl(p0: double, p1: double): Point
+    public final static method constructor-impl(p0: double, p1: double): void
+    public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
+    public static method equals-impl(p0: double, p1: double, p2: java.lang.Object): boolean
+    public final static method equals-impl0(p0: double, p1: double, p2: double, p3: double): boolean
+    public final method getX(): double
+    public final method getY(): double
+    public method hashCode(): int
+    public static method hashCode-impl(p0: double, p1: double): int
+    public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
+    public static method toString-impl(p0: double, p1: double): java.lang.String
+    public synthetic final method unbox-impl-x(): double
+    public synthetic final method unbox-impl-y(): double
+}
+
+@kotlin.Metadata
+public final class RegularClassSecondaryConstructorWithMfvcKt {
+    // source: 'regularClassSecondaryConstructorWithMfvc.kt'
+    public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
+}

compiler/testData/codegen/box/valueClasses/throwingMFVCReassignments.txt

@@ -30,7 +30,7 @@ public final class PointBox {
     public final @org.jetbrains.annotations.NotNull method getValue(): DPoint
     public synthetic final method getValue-x(): double
     public synthetic final method getValue-y(): double
-    public final method setValue-sUp7gFk(p0: double, p1: double): void
+    public final method setValue-nuuzChU(p0: double, p1: double): void
 }
 
 @kotlin.Metadata

compiler/testData/codegen/box/valueClasses/visibility.kt

@@ -4,15 +4,73 @@
 // TARGET_BACKEND: JVM_IR
 // LANGUAGE: +ValueClasses
 
+// MODULE: dependency
+@JvmInline
+value class MfvcDependency(val x: Int, val y: Int) {
+    val z: Int
+        get() = 1
+    val t: MfvcDependency
+        get() = MfvcDependency(10, 20)
+    companion object {
+        var x: Int = -100
+        val y: Int
+            get() = 1
+        var z: MfvcDependency = MfvcDependency(10, 20)
+        val t: MfvcDependency
+            get() = MfvcDependency(10, 20)
+
+        @JvmStatic
+        var xStatic: Int = -100
+        @JvmStatic
+        val yStatic: Int
+            get() = 1
+        @JvmStatic
+        var zStatic: MfvcDependency = MfvcDependency(10, 20)
+        @JvmStatic
+        val tStatic: MfvcDependency
+            get() = MfvcDependency(10, 20)
+    }
+}
+class RegularDependency {
+    var x: Int = -100
+    val y: Int
+        get() = 1
+    var z: MfvcDependency = MfvcDependency(10, 20)
+    val t: MfvcDependency
+        get() = MfvcDependency(10, 20)
+    
+    companion object {
+        var x: Int = -100
+        val y: Int
+            get() = 1
+        var z: MfvcDependency = MfvcDependency(10, 20)
+        val t: MfvcDependency
+            get() = MfvcDependency(10, 20)
+        
+        @JvmStatic
+        var xStatic: Int = -100
+        @JvmStatic
+        val yStatic: Int
+            get() = 1
+        @JvmStatic
+        var zStatic: MfvcDependency = MfvcDependency(10, 20)
+        @JvmStatic
+        val tStatic: MfvcDependency
+            get() = MfvcDependency(10, 20)
+    }
+}
+
+// MODULE: main(dependency)
+
 @JvmInline
 value class Public(val x: Int, val y: Int) {
     companion object {
-        var x: Int = 0
+        var x: Int = -100
         val y: Int
             get() = 1
-        var z: Public = Public(0, 0)
+        var z: Public = Public(10, 20)
         val t: Public
-            get() = Public(0, 0)
+            get() = Public(10, 20)
     }
 }
 
@@ -20,16 +78,16 @@ value class Public(val x: Int, val y: Int) {
 value class Internal(internal val x: Int, internal val y: Int) {
     companion object {
         @JvmStatic
-        var x: Int = 0
+        var x: Int = -100
 
         @JvmStatic
         val y: Int
             get() = 1
-        var z: Internal = Internal(0, 0)
+        var z: Internal = Internal(10, 20)
 
         @JvmStatic
         val t: Internal
-            get() = Internal(0, 0)
+            get() = Internal(10, 20)
     }
 }
 
@@ -291,6 +349,28 @@ fun box(): String {
         jvmStaticZ1; jvmStaticZ2; jvmStaticZ4; jvmStaticZ5; jvmStaticZ6
         jvmStaticZ1 = jvmStaticZ1; jvmStaticZ2 = jvmStaticZ2; jvmStaticZ6 = jvmStaticZ6
     }
+    
+    require(MfvcDependency.x == -100)
+    require(MfvcDependency.xStatic == -100)
+    require(MfvcDependency.y == 1)
+    require(MfvcDependency.yStatic == 1)
+    require(MfvcDependency.z == MfvcDependency(10, 20))
+    require(MfvcDependency.zStatic == MfvcDependency(10, 20))
+    require(MfvcDependency(1, 2).x == 1)
+    require(MfvcDependency(1, 2).y == 2)
+    require(MfvcDependency(1, 2).z == 1)
+    require(MfvcDependency(1, 2).t == MfvcDependency(10, 20))
+    
+    require(RegularDependency.x == -100)
+    require(RegularDependency.xStatic == -100)
+    require(RegularDependency.y == 1)
+    require(RegularDependency.yStatic == 1)
+    require(RegularDependency.z == MfvcDependency(10, 20))
+    require(RegularDependency.zStatic == MfvcDependency(10, 20))
+    require(RegularDependency().x == -100)
+    require(RegularDependency().y == 1)
+    require(RegularDependency().z == MfvcDependency(10, 20))
+    require(RegularDependency().t == MfvcDependency(10, 20))
 
     return "OK"
 }

compiler/testData/codegen/box/valueClasses/visibility.txt

@@ -1,6 +1,168 @@
+Module: dependency
+@kotlin.Metadata
+public final class MfvcDependency$Companion {
+    // source: 'module_dependency_visibility.kt'
+    private method <init>(): void
+    public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
+    public final @org.jetbrains.annotations.NotNull method getT(): MfvcDependency
+    public synthetic final method getT-x(): int
+    public synthetic final method getT-y(): int
+    public synthetic deprecated static @kotlin.jvm.JvmStatic method getTStatic$annotations(): void
+    public final @org.jetbrains.annotations.NotNull method getTStatic(): MfvcDependency
+    public synthetic final method getTStatic-x(): int
+    public synthetic final method getTStatic-y(): int
+    public final method getX(): int
+    public synthetic deprecated static @kotlin.jvm.JvmStatic method getXStatic$annotations(): void
+    public final method getXStatic(): int
+    public final method getY(): int
+    public synthetic deprecated static @kotlin.jvm.JvmStatic method getYStatic$annotations(): void
+    public final method getYStatic(): int
+    public final @org.jetbrains.annotations.NotNull method getZ(): MfvcDependency
+    public synthetic final method getZ-x(): int
+    public synthetic final method getZ-y(): int
+    public synthetic deprecated static @kotlin.jvm.JvmStatic method getZStatic$annotations(): void
+    public final @org.jetbrains.annotations.NotNull method getZStatic(): MfvcDependency
+    public synthetic final method getZStatic-x(): int
+    public synthetic final method getZStatic-y(): int
+    public final method setX(p0: int): void
+    public final method setXStatic(p0: int): void
+    public final method setZ-qW3ZXps(p0: int, p1: int): void
+    public final method setZStatic-qW3ZXps(p0: int, p1: int): void
+    public final inner class MfvcDependency$Companion
+}
+
+@kotlin.jvm.JvmInline
+@kotlin.Metadata
+public final class MfvcDependency {
+    // source: 'module_dependency_visibility.kt'
+    public final static @org.jetbrains.annotations.NotNull field Companion: MfvcDependency$Companion
+    private final field x$1: int
+    private static field x: int
+    private static field xStatic: int
+    private final field y: int
+    private static field z-x: int
+    private static field z-y: int
+    private static field zStatic-x: int
+    private static field zStatic-y: int
+    static method <clinit>(): void
+    private synthetic method <init>(p0: int, p1: int): void
+    public synthetic final static method access$getX$cp(): int
+    public synthetic final static method access$getXStatic$cp(): int
+    public synthetic final static method access$getZ-x$cp(): int
+    public synthetic final static method access$getZ-y$cp(): int
+    public synthetic final static method access$getZStatic-x$cp(): int
+    public synthetic final static method access$getZStatic-y$cp(): int
+    public synthetic final static method access$setX$cp(p0: int): void
+    public synthetic final static method access$setXStatic$cp(p0: int): void
+    public synthetic final static method access$setZ-x$cp(p0: int): void
+    public synthetic final static method access$setZ-y$cp(p0: int): void
+    public synthetic final static method access$setZStatic-x$cp(p0: int): void
+    public synthetic final static method access$setZStatic-y$cp(p0: int): void
+    public synthetic final static method box-impl(p0: int, p1: int): MfvcDependency
+    public final static method constructor-impl(p0: int, p1: int): void
+    public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean
+    public static method equals-impl(p0: int, p1: int, p2: java.lang.Object): boolean
+    public final static method equals-impl0(p0: int, p1: int, p2: int, p3: int): boolean
+    public final static @org.jetbrains.annotations.NotNull method getT-impl(p0: int, p1: int): MfvcDependency
+    public final static @org.jetbrains.annotations.NotNull method getTStatic(): MfvcDependency
+    public final method getX(): int
+    public final static method getXStatic(): int
+    public final method getY(): int
+    public final static method getYStatic(): int
+    public final static method getZ-impl(p0: int, p1: int): int
+    public final static @org.jetbrains.annotations.NotNull method getZStatic(): MfvcDependency
+    public method hashCode(): int
+    public static method hashCode-impl(p0: int, p1: int): int
+    public final static method setXStatic(p0: int): void
+    public final static method setZStatic-qW3ZXps(p0: int, p1: int): void
+    public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
+    public static method toString-impl(p0: int, p1: int): java.lang.String
+    public synthetic final method unbox-impl-x(): int
+    public synthetic final method unbox-impl-y(): int
+    public final inner class MfvcDependency$Companion
+}
+
+@kotlin.Metadata
+public final class RegularDependency$Companion {
+    // source: 'module_dependency_visibility.kt'
+    private method <init>(): void
+    public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
+    public final @org.jetbrains.annotations.NotNull method getT(): MfvcDependency
+    public synthetic final method getT-x(): int
+    public synthetic final method getT-y(): int
+    public synthetic deprecated static @kotlin.jvm.JvmStatic method getTStatic$annotations(): void
+    public final @org.jetbrains.annotations.NotNull method getTStatic(): MfvcDependency
+    public synthetic final method getTStatic-x(): int
+    public synthetic final method getTStatic-y(): int
+    public final method getX(): int
+    public synthetic deprecated static @kotlin.jvm.JvmStatic method getXStatic$annotations(): void
+    public final method getXStatic(): int
+    public final method getY(): int
+    public synthetic deprecated static @kotlin.jvm.JvmStatic method getYStatic$annotations(): void
+    public final method getYStatic(): int
+    public final @org.jetbrains.annotations.NotNull method getZ(): MfvcDependency
+    public synthetic final method getZ-x(): int
+    public synthetic final method getZ-y(): int
+    public synthetic deprecated static @kotlin.jvm.JvmStatic method getZStatic$annotations(): void
+    public final @org.jetbrains.annotations.NotNull method getZStatic(): MfvcDependency
+    public synthetic final method getZStatic-x(): int
+    public synthetic final method getZStatic-y(): int
+    public final method setX(p0: int): void
+    public final method setXStatic(p0: int): void
+    public final method setZ-qW3ZXps(p0: int, p1: int): void
+    public final method setZStatic-qW3ZXps(p0: int, p1: int): void
+    public final inner class RegularDependency$Companion
+}
+
+@kotlin.Metadata
+public final class RegularDependency {
+    // source: 'module_dependency_visibility.kt'
+    public final static @org.jetbrains.annotations.NotNull field Companion: RegularDependency$Companion
+    private field x$1: int
+    private static field x: int
+    private static field xStatic: int
+    private field z-x$1: int
+    private static field z-x: int
+    private field z-y$1: int
+    private static field z-y: int
+    private static field zStatic-x: int
+    private static field zStatic-y: int
+    static method <clinit>(): void
+    public method <init>(): void
+    public synthetic final static method access$getX$cp(): int
+    public synthetic final static method access$getXStatic$cp(): int
+    public synthetic final static method access$getZ-x$cp(): int
+    public synthetic final static method access$getZ-y$cp(): int
+    public synthetic final static method access$getZStatic-x$cp(): int
+    public synthetic final static method access$getZStatic-y$cp(): int
+    public synthetic final static method access$setX$cp(p0: int): void
+    public synthetic final static method access$setXStatic$cp(p0: int): void
+    public synthetic final static method access$setZ-x$cp(p0: int): void
+    public synthetic final static method access$setZ-y$cp(p0: int): void
+    public synthetic final static method access$setZStatic-x$cp(p0: int): void
+    public synthetic final static method access$setZStatic-y$cp(p0: int): void
+    public final @org.jetbrains.annotations.NotNull method getT(): MfvcDependency
+    public synthetic final method getT-x(): int
+    public synthetic final method getT-y(): int
+    public final static @org.jetbrains.annotations.NotNull method getTStatic(): MfvcDependency
+    public final method getX(): int
+    public final static method getXStatic(): int
+    public final method getY(): int
+    public final static method getYStatic(): int
+    public final @org.jetbrains.annotations.NotNull method getZ(): MfvcDependency
+    public synthetic final method getZ-x(): int
+    public synthetic final method getZ-y(): int
+    public final static @org.jetbrains.annotations.NotNull method getZStatic(): MfvcDependency
+    public final method setX(p0: int): void
+    public final static method setXStatic(p0: int): void
+    public final method setZ-qW3ZXps(p0: int, p1: int): void
+    public final static method setZStatic-qW3ZXps(p0: int, p1: int): void
+    public final inner class RegularDependency$Companion
+}
+Module: main
 @kotlin.Metadata
 public final class Internal$Companion {
-    // source: 'visibility.kt'
+    // source: 'module_main_visibility.kt'
     private method <init>(): void
     public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
     public synthetic deprecated static @kotlin.jvm.JvmStatic method getT$annotations(): void
@@ -15,18 +177,20 @@ public final class Internal$Companion {
     public synthetic final method getZ-x(): int
     public synthetic final method getZ-y(): int
     public final method setX(p0: int): void
-    public final method setZ-sUp7gFk(p0: int, p1: int): void
+    public final method setZ-LJYh5uw(p0: int, p1: int): void
     public final inner class Internal$Companion
 }
 
 @kotlin.jvm.JvmInline
 @kotlin.Metadata
 public final class Internal {
-    // source: 'visibility.kt'
+    // source: 'module_main_visibility.kt'
     public final static @org.jetbrains.annotations.NotNull field Companion: Internal$Companion
     private final field x$1: int
     private static field x: int
     private final field y: int
+    private static field z-x: int
+    private static field z-y: int
     static method <clinit>(): void
     private synthetic method <init>(p0: int, p1: int): void
     public synthetic final static method access$getX$cp(): int
@@ -58,7 +222,7 @@ public final class Internal {
 @kotlin.jvm.JvmInline
 @kotlin.Metadata
 public final class InternalInternal {
-    // source: 'visibility.kt'
+    // source: 'module_main_visibility.kt'
     private final field value-x: int
     private final field value-y: int
     private synthetic method <init>(p0: int, p1: int): void
@@ -80,7 +244,7 @@ public final class InternalInternal {
 @kotlin.jvm.JvmInline
 @kotlin.Metadata
 public final class InternalPrivate {
-    // source: 'visibility.kt'
+    // source: 'module_main_visibility.kt'
     private final field value-x: int
     private final field value-y: int
     private synthetic method <init>(p0: int, p1: int): void
@@ -102,7 +266,7 @@ public final class InternalPrivate {
 @kotlin.jvm.JvmInline
 @kotlin.Metadata
 public final class InternalPublic {
-    // source: 'visibility.kt'
+    // source: 'module_main_visibility.kt'
     private final field value-x: int
     private final field value-y: int
     private synthetic method <init>(p0: int, p1: int): void
@@ -121,10 +285,19 @@ public final class InternalPublic {
     public synthetic final method unbox-impl-value-y(): int
 }
 
+@kotlin.Metadata
+public final class Module_main_visibilityKt {
+    // source: 'module_main_visibility.kt'
+    public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
+    public final inner class MfvcDependency$Companion
+    public final inner class Regular$Companion
+    public final inner class RegularDependency$Companion
+}
+
 @kotlin.jvm.JvmInline
 @kotlin.Metadata
 public final class Private {
-    // source: 'visibility.kt'
+    // source: 'module_main_visibility.kt'
     private final field x: int
     private final field y: int
     private synthetic method <init>(p0: int, p1: int): void
@@ -144,7 +317,7 @@ public final class Private {
 @kotlin.jvm.JvmInline
 @kotlin.Metadata
 public final class PrivateInternal {
-    // source: 'visibility.kt'
+    // source: 'module_main_visibility.kt'
     private final field value-x: int
     private final field value-y: int
     private synthetic method <init>(p0: int, p1: int): void
@@ -166,7 +339,7 @@ public final class PrivateInternal {
 @kotlin.jvm.JvmInline
 @kotlin.Metadata
 public final class PrivatePrivate {
-    // source: 'visibility.kt'
+    // source: 'module_main_visibility.kt'
     private final field value-x: int
     private final field value-y: int
     private synthetic method <init>(p0: int, p1: int): void
@@ -188,7 +361,7 @@ public final class PrivatePrivate {
 @kotlin.jvm.JvmInline
 @kotlin.Metadata
 public final class PrivatePublic {
-    // source: 'visibility.kt'
+    // source: 'module_main_visibility.kt'
     private final field value-x: int
     private final field value-y: int
     private synthetic method <init>(p0: int, p1: int): void
@@ -209,7 +382,7 @@ public final class PrivatePublic {
 
 @kotlin.Metadata
 public final class Public$Companion {
-    // source: 'visibility.kt'
+    // source: 'module_main_visibility.kt'
     private method <init>(): void
     public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
     public final @org.jetbrains.annotations.NotNull method getT(): Public
@@ -221,18 +394,20 @@ public final class Public$Companion {
     public synthetic final method getZ-x(): int
     public synthetic final method getZ-y(): int
     public final method setX(p0: int): void
-    public final method setZ-sUp7gFk(p0: int, p1: int): void
+    public final method setZ-3S9c-qc(p0: int, p1: int): void
     public final inner class Public$Companion
 }
 
 @kotlin.jvm.JvmInline
 @kotlin.Metadata
 public final class Public {
-    // source: 'visibility.kt'
+    // source: 'module_main_visibility.kt'
     public final static @org.jetbrains.annotations.NotNull field Companion: Public$Companion
     private final field x$1: int
     private static field x: int
     private final field y: int
+    private static field z-x: int
+    private static field z-y: int
     static method <clinit>(): void
     private synthetic method <init>(p0: int, p1: int): void
     public synthetic final static method access$getX$cp(): int
@@ -260,7 +435,7 @@ public final class Public {
 @kotlin.jvm.JvmInline
 @kotlin.Metadata
 public final class PublicInternal {
-    // source: 'visibility.kt'
+    // source: 'module_main_visibility.kt'
     private final field value-x: int
     private final field value-y: int
     private synthetic method <init>(p0: int, p1: int): void
@@ -282,7 +457,7 @@ public final class PublicInternal {
 @kotlin.jvm.JvmInline
 @kotlin.Metadata
 public final class PublicPrivate {
-    // source: 'visibility.kt'
+    // source: 'module_main_visibility.kt'
     private final field value-x: int
     private final field value-y: int
     private synthetic method <init>(p0: int, p1: int): void
@@ -304,7 +479,7 @@ public final class PublicPrivate {
 @kotlin.jvm.JvmInline
 @kotlin.Metadata
 public final class PublicPublic {
-    // source: 'visibility.kt'
+    // source: 'module_main_visibility.kt'
     private final field value-x: int
     private final field value-y: int
     private synthetic method <init>(p0: int, p1: int): void
@@ -325,21 +500,21 @@ public final class PublicPublic {
 
 @kotlin.Metadata
 public final class Regular$Companion {
-    // source: 'visibility.kt'
+    // source: 'module_main_visibility.kt'
     private method <init>(): void
     public synthetic method <init>(p0: kotlin.jvm.internal.DefaultConstructorMarker): void
     public synthetic final static method access$getJvmStaticX3(p0: Regular$Companion): Public
     public synthetic final static method access$getJvmStaticY3(p0: Regular$Companion): Internal
     public synthetic final static method access$getJvmStaticZ3(p0: Regular$Companion): Private
-    public synthetic final static method access$setJvmStaticX3-sUp7gFk(p0: Regular$Companion, p1: int, p2: int): void
+    public synthetic final static method access$setJvmStaticX3-3S9c-qc(p0: Regular$Companion, p1: int, p2: int): void
-    public synthetic final static method access$setJvmStaticX4-sUp7gFk(p0: Regular$Companion, p1: int, p2: int): void
+    public synthetic final static method access$setJvmStaticX4-3S9c-qc(p0: Regular$Companion, p1: int, p2: int): void
-    public synthetic final static method access$setJvmStaticX5-sUp7gFk(p0: Regular$Companion, p1: int, p2: int): void
+    public synthetic final static method access$setJvmStaticX5-3S9c-qc(p0: Regular$Companion, p1: int, p2: int): void
-    public synthetic final static method access$setJvmStaticY3-sUp7gFk(p0: Regular$Companion, p1: int, p2: int): void
+    public synthetic final static method access$setJvmStaticY3-LJYh5uw(p0: Regular$Companion, p1: int, p2: int): void
-    public synthetic final static method access$setJvmStaticY4-sUp7gFk(p0: Regular$Companion, p1: int, p2: int): void
+    public synthetic final static method access$setJvmStaticY4-LJYh5uw(p0: Regular$Companion, p1: int, p2: int): void
-    public synthetic final static method access$setJvmStaticY5-sUp7gFk(p0: Regular$Companion, p1: int, p2: int): void
+    public synthetic final static method access$setJvmStaticY5-LJYh5uw(p0: Regular$Companion, p1: int, p2: int): void
-    public synthetic final static method access$setJvmStaticZ3-sUp7gFk(p0: Regular$Companion, p1: int, p2: int): void
+    public synthetic final static method access$setJvmStaticZ3-ebpot8A(p0: Regular$Companion, p1: int, p2: int): void
-    public synthetic final static method access$setJvmStaticZ4-sUp7gFk(p0: Regular$Companion, p1: int, p2: int): void
+    public synthetic final static method access$setJvmStaticZ4-ebpot8A(p0: Regular$Companion, p1: int, p2: int): void
-    public synthetic final static method access$setJvmStaticZ5-sUp7gFk(p0: Regular$Companion, p1: int, p2: int): void
+    public synthetic final static method access$setJvmStaticZ5-ebpot8A(p0: Regular$Companion, p1: int, p2: int): void
     public synthetic deprecated static @kotlin.jvm.JvmStatic method getJvmStaticX1$annotations(): void
     public final @org.jetbrains.annotations.NotNull method getJvmStaticX1(): Public
     public synthetic final method getJvmStaticX1-x(): int
@@ -466,48 +641,48 @@ public final class Regular$Companion {
     public final @org.jetbrains.annotations.NotNull method getStaticZ6(): Private
     public synthetic final method getStaticZ6-x(): int
     public synthetic final method getStaticZ6-y(): int
-    public final method setJvmStaticX1-sUp7gFk(p0: int, p1: int): void
+    public final method setJvmStaticX1-3S9c-qc(p0: int, p1: int): void
-    public final method setJvmStaticX2-sUp7gFk$main(p0: int, p1: int): void
+    public final method setJvmStaticX2-3S9c-qc$main(p0: int, p1: int): void
-    private final method setJvmStaticX3-sUp7gFk(p0: int, p1: int): void
+    private final method setJvmStaticX3-3S9c-qc(p0: int, p1: int): void
-    private final method setJvmStaticX4-sUp7gFk(p0: int, p1: int): void
+    private final method setJvmStaticX4-3S9c-qc(p0: int, p1: int): void
-    private final method setJvmStaticX5-sUp7gFk(p0: int, p1: int): void
+    private final method setJvmStaticX5-3S9c-qc(p0: int, p1: int): void
-    public final method setJvmStaticX6-sUp7gFk$main(p0: int, p1: int): void
+    public final method setJvmStaticX6-3S9c-qc$main(p0: int, p1: int): void
-    public final method setJvmStaticY1-sUp7gFk(p0: int, p1: int): void
+    public final method setJvmStaticY1-LJYh5uw(p0: int, p1: int): void
-    public final method setJvmStaticY2-sUp7gFk$main(p0: int, p1: int): void
+    public final method setJvmStaticY2-LJYh5uw$main(p0: int, p1: int): void
-    private final method setJvmStaticY3-sUp7gFk(p0: int, p1: int): void
+    private final method setJvmStaticY3-LJYh5uw(p0: int, p1: int): void
-    private final method setJvmStaticY4-sUp7gFk(p0: int, p1: int): void
+    private final method setJvmStaticY4-LJYh5uw(p0: int, p1: int): void
-    private final method setJvmStaticY5-sUp7gFk(p0: int, p1: int): void
+    private final method setJvmStaticY5-LJYh5uw(p0: int, p1: int): void
-    public final method setJvmStaticY6-sUp7gFk$main(p0: int, p1: int): void
+    public final method setJvmStaticY6-LJYh5uw$main(p0: int, p1: int): void
-    public final method setJvmStaticZ1-sUp7gFk(p0: int, p1: int): void
+    public final method setJvmStaticZ1-ebpot8A(p0: int, p1: int): void
-    public final method setJvmStaticZ2-sUp7gFk$main(p0: int, p1: int): void
+    public final method setJvmStaticZ2-ebpot8A$main(p0: int, p1: int): void
-    private final method setJvmStaticZ3-sUp7gFk(p0: int, p1: int): void
+    private final method setJvmStaticZ3-ebpot8A(p0: int, p1: int): void
-    private final method setJvmStaticZ4-sUp7gFk(p0: int, p1: int): void
+    private final method setJvmStaticZ4-ebpot8A(p0: int, p1: int): void
-    private final method setJvmStaticZ5-sUp7gFk(p0: int, p1: int): void
+    private final method setJvmStaticZ5-ebpot8A(p0: int, p1: int): void
-    public final method setJvmStaticZ6-sUp7gFk$main(p0: int, p1: int): void
+    public final method setJvmStaticZ6-ebpot8A$main(p0: int, p1: int): void
-    public final method setStaticX1-sUp7gFk(p0: int, p1: int): void
+    public final method setStaticX1-3S9c-qc(p0: int, p1: int): void
-    public final method setStaticX2-sUp7gFk$main(p0: int, p1: int): void
+    public final method setStaticX2-3S9c-qc$main(p0: int, p1: int): void
-    private final method setStaticX3-sUp7gFk(p0: int, p1: int): void
+    private final method setStaticX3-3S9c-qc(p0: int, p1: int): void
-    private final method setStaticX4-sUp7gFk(p0: int, p1: int): void
+    private final method setStaticX4-3S9c-qc(p0: int, p1: int): void
-    private final method setStaticX5-sUp7gFk(p0: int, p1: int): void
+    private final method setStaticX5-3S9c-qc(p0: int, p1: int): void
-    public final method setStaticX6-sUp7gFk$main(p0: int, p1: int): void
+    public final method setStaticX6-3S9c-qc$main(p0: int, p1: int): void
-    public final method setStaticY1-sUp7gFk(p0: int, p1: int): void
+    public final method setStaticY1-LJYh5uw(p0: int, p1: int): void
-    public final method setStaticY2-sUp7gFk$main(p0: int, p1: int): void
+    public final method setStaticY2-LJYh5uw$main(p0: int, p1: int): void
-    private final method setStaticY3-sUp7gFk(p0: int, p1: int): void
+    private final method setStaticY3-LJYh5uw(p0: int, p1: int): void
-    private final method setStaticY4-sUp7gFk(p0: int, p1: int): void
+    private final method setStaticY4-LJYh5uw(p0: int, p1: int): void
-    private final method setStaticY5-sUp7gFk(p0: int, p1: int): void
+    private final method setStaticY5-LJYh5uw(p0: int, p1: int): void
-    public final method setStaticY6-sUp7gFk$main(p0: int, p1: int): void
+    public final method setStaticY6-LJYh5uw$main(p0: int, p1: int): void
-    public final method setStaticZ1-sUp7gFk(p0: int, p1: int): void
+    public final method setStaticZ1-ebpot8A(p0: int, p1: int): void
-    public final method setStaticZ2-sUp7gFk$main(p0: int, p1: int): void
+    public final method setStaticZ2-ebpot8A$main(p0: int, p1: int): void
-    private final method setStaticZ3-sUp7gFk(p0: int, p1: int): void
+    private final method setStaticZ3-ebpot8A(p0: int, p1: int): void
-    private final method setStaticZ4-sUp7gFk(p0: int, p1: int): void
+    private final method setStaticZ4-ebpot8A(p0: int, p1: int): void
-    private final method setStaticZ5-sUp7gFk(p0: int, p1: int): void
+    private final method setStaticZ5-ebpot8A(p0: int, p1: int): void
-    public final method setStaticZ6-sUp7gFk$main(p0: int, p1: int): void
+    public final method setStaticZ6-ebpot8A$main(p0: int, p1: int): void
     public final inner class Regular$Companion
 }
 
 @kotlin.Metadata
 public final class Regular {
-    // source: 'visibility.kt'
+    // source: 'module_main_visibility.kt'
     public final static @org.jetbrains.annotations.NotNull field Companion: Regular$Companion
     private static field jvmStaticX1-x: int
     private static field jvmStaticX1-y: int
@@ -836,48 +1011,41 @@ public final class Regular {
     public final @org.jetbrains.annotations.NotNull method getZ6(): Private
     public synthetic final method getZ6-x(): int
     public synthetic final method getZ6-y(): int
-    public final static method setJvmStaticX1-sUp7gFk(p0: int, p1: int): void
+    public final static method setJvmStaticX1-3S9c-qc(p0: int, p1: int): void
-    public final static method setJvmStaticX2-sUp7gFk$main(p0: int, p1: int): void
+    public final static method setJvmStaticX2-3S9c-qc$main(p0: int, p1: int): void
-    private final static method setJvmStaticX3-sUp7gFk(p0: int, p1: int): void
+    private final static method setJvmStaticX3-3S9c-qc(p0: int, p1: int): void
-    private final static method setJvmStaticX4-sUp7gFk(p0: int, p1: int): void
+    private final static method setJvmStaticX4-3S9c-qc(p0: int, p1: int): void
-    private final static method setJvmStaticX5-sUp7gFk(p0: int, p1: int): void
+    private final static method setJvmStaticX5-3S9c-qc(p0: int, p1: int): void
-    public final static method setJvmStaticX6-sUp7gFk$main(p0: int, p1: int): void
+    public final static method setJvmStaticX6-3S9c-qc$main(p0: int, p1: int): void
-    public final static method setJvmStaticY1-sUp7gFk(p0: int, p1: int): void
+    public final static method setJvmStaticY1-LJYh5uw(p0: int, p1: int): void
-    public final static method setJvmStaticY2-sUp7gFk$main(p0: int, p1: int): void
+    public final static method setJvmStaticY2-LJYh5uw$main(p0: int, p1: int): void
-    private final static method setJvmStaticY3-sUp7gFk(p0: int, p1: int): void
+    private final static method setJvmStaticY3-LJYh5uw(p0: int, p1: int): void
-    private final static method setJvmStaticY4-sUp7gFk(p0: int, p1: int): void
+    private final static method setJvmStaticY4-LJYh5uw(p0: int, p1: int): void
-    private final static method setJvmStaticY5-sUp7gFk(p0: int, p1: int): void
+    private final static method setJvmStaticY5-LJYh5uw(p0: int, p1: int): void
-    public final static method setJvmStaticY6-sUp7gFk$main(p0: int, p1: int): void
+    public final static method setJvmStaticY6-LJYh5uw$main(p0: int, p1: int): void
-    public final static method setJvmStaticZ1-sUp7gFk(p0: int, p1: int): void
+    public final static method setJvmStaticZ1-ebpot8A(p0: int, p1: int): void
-    public final static method setJvmStaticZ2-sUp7gFk$main(p0: int, p1: int): void
+    public final static method setJvmStaticZ2-ebpot8A$main(p0: int, p1: int): void
-    private final static method setJvmStaticZ3-sUp7gFk(p0: int, p1: int): void
+    private final static method setJvmStaticZ3-ebpot8A(p0: int, p1: int): void
-    private final static method setJvmStaticZ4-sUp7gFk(p0: int, p1: int): void
+    private final static method setJvmStaticZ4-ebpot8A(p0: int, p1: int): void
-    private final static method setJvmStaticZ5-sUp7gFk(p0: int, p1: int): void
+    private final static method setJvmStaticZ5-ebpot8A(p0: int, p1: int): void
-    public final static method setJvmStaticZ6-sUp7gFk$main(p0: int, p1: int): void
+    public final static method setJvmStaticZ6-ebpot8A$main(p0: int, p1: int): void
-    public final method setX1-sUp7gFk(p0: int, p1: int): void
+    public final method setX1-3S9c-qc(p0: int, p1: int): void
-    public final method setX2-sUp7gFk$main(p0: int, p1: int): void
+    public final method setX2-3S9c-qc$main(p0: int, p1: int): void
-    private final method setX3-sUp7gFk(p0: int, p1: int): void
+    private final method setX3-3S9c-qc(p0: int, p1: int): void
-    private final method setX4-sUp7gFk(p0: int, p1: int): void
+    private final method setX4-3S9c-qc(p0: int, p1: int): void
-    private final method setX5-sUp7gFk(p0: int, p1: int): void
+    private final method setX5-3S9c-qc(p0: int, p1: int): void
-    public final method setX6-sUp7gFk$main(p0: int, p1: int): void
+    public final method setX6-3S9c-qc$main(p0: int, p1: int): void
-    public final method setY1-sUp7gFk(p0: int, p1: int): void
+    public final method setY1-LJYh5uw(p0: int, p1: int): void
-    public final method setY2-sUp7gFk$main(p0: int, p1: int): void
+    public final method setY2-LJYh5uw$main(p0: int, p1: int): void
-    private final method setY3-sUp7gFk(p0: int, p1: int): void
+    private final method setY3-LJYh5uw(p0: int, p1: int): void
-    private final method setY4-sUp7gFk(p0: int, p1: int): void
+    private final method setY4-LJYh5uw(p0: int, p1: int): void
-    private final method setY5-sUp7gFk(p0: int, p1: int): void
+    private final method setY5-LJYh5uw(p0: int, p1: int): void
-    public final method setY6-sUp7gFk$main(p0: int, p1: int): void
+    public final method setY6-LJYh5uw$main(p0: int, p1: int): void
-    public final method setZ1-sUp7gFk(p0: int, p1: int): void
+    public final method setZ1-ebpot8A(p0: int, p1: int): void
-    public final method setZ2-sUp7gFk$main(p0: int, p1: int): void
+    public final method setZ2-ebpot8A$main(p0: int, p1: int): void
-    private final method setZ3-sUp7gFk(p0: int, p1: int): void
+    private final method setZ3-ebpot8A(p0: int, p1: int): void
-    private final method setZ4-sUp7gFk(p0: int, p1: int): void
+    private final method setZ4-ebpot8A(p0: int, p1: int): void
-    private final method setZ5-sUp7gFk(p0: int, p1: int): void
+    private final method setZ5-ebpot8A(p0: int, p1: int): void
-    public final method setZ6-sUp7gFk$main(p0: int, p1: int): void
+    public final method setZ6-ebpot8A$main(p0: int, p1: int): void
-    public final inner class Regular$Companion
-}
-
-@kotlin.Metadata
-public final class VisibilityKt {
-    // source: 'visibility.kt'
-    public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
     public final inner class Regular$Companion
 }

compiler/testData/codegen/bytecodeListing/valueClasses/annotations.txt

@@ -49,12 +49,12 @@ public final class AnnotationsKt {
     public synthetic deprecated static @Ann$Container(value=[Ann, Ann]) method getT$annotations(p0: A): void
     public synthetic deprecated static @Ann$Container(value=[Ann, Ann]) method getT$annotations(p0: C): void
     public final static @Ann$Container(value=[Ann, Ann]) @org.jetbrains.annotations.NotNull method getT(@Ann$Container(value=[Ann, Ann]) @org.jetbrains.annotations.NotNull p0: C): A
-    public final static @Ann$Container(value=[Ann, Ann]) @org.jetbrains.annotations.NotNull method getT-sUp7gFk(p0: int, p1: int): A
+    public final static @Ann$Container(value=[Ann, Ann]) @org.jetbrains.annotations.NotNull method getT-iUtXLc0(p0: int, p1: int): A
-    public final static @Ann$Container(value=[Ann, Ann]) method setT-GPBa7dw(@Ann$Container(value=[Ann, Ann]) @org.jetbrains.annotations.NotNull p0: C, p1: int, p2: int): void
+    public final static @Ann$Container(value=[Ann, Ann]) method setT-0BsKfkc(p0: int, p1: int, p2: int, p3: int): void
-    public final static @Ann$Container(value=[Ann, Ann]) method setT-GPBa7dw(p0: int, p1: int, p2: int, p3: int): void
+    public final static @Ann$Container(value=[Ann, Ann]) method setT-sJYW7s8(@Ann$Container(value=[Ann, Ann]) @org.jetbrains.annotations.NotNull p0: C, p1: int, p2: int): void
-    public final static @Ann$Container(value=[Ann, Ann]) method t-552ch2I(@Ann$Container(value=[Ann, Ann]) @org.jetbrains.annotations.NotNull p0: C, p1: int, p2: int, p3: int, p4: int, @org.jetbrains.annotations.Nullable p5: A, @Ann$Container(value=[Ann, Ann]) @org.jetbrains.annotations.NotNull p6: C): int
+    public final static @Ann$Container(value=[Ann, Ann]) method t-9uZSGF8(@Ann$Container(value=[Ann, Ann]) @org.jetbrains.annotations.NotNull p0: C, p1: int, p2: int, p3: int, p4: int, @org.jetbrains.annotations.Nullable p5: A, @Ann$Container(value=[Ann, Ann]) @org.jetbrains.annotations.NotNull p6: C): int
-    public final static @Ann$Container(value=[Ann, Ann]) method t-552ch2I(p0: int, p1: int, p2: int, p3: int, p4: int, p5: int, @org.jetbrains.annotations.Nullable p6: A, @Ann$Container(value=[Ann, Ann]) @org.jetbrains.annotations.NotNull p7: C): void
+    public final static @Ann$Container(value=[Ann, Ann]) method t-bZ3EKo0(p0: int, p1: int, p2: int, p3: int, p4: int, p5: int, @org.jetbrains.annotations.Nullable p6: A, @Ann$Container(value=[Ann, Ann]) @org.jetbrains.annotations.NotNull p7: C): void
-    private final static method t_552ch2I$f(): void
+    private final static method t_bZ3EKo0$f(): void
     public inner class Ann$Container
 }
 
@@ -132,7 +132,7 @@ public final class C {
     public final @org.jetbrains.annotations.NotNull method getZ(): A
     public synthetic final method getZ-x(): int
     public synthetic final method getZ-y(): int
-    public final @Ann$Container(value=[Ann, Ann]) method setX-sUp7gFk(p0: int, p1: int): void
+    public final @Ann$Container(value=[Ann, Ann]) method setX-iUtXLc0(p0: int, p1: int): void
     public final @Ann$Container(value=[Ann, Ann]) method setY(@Ann$Container(value=[Ann, Ann]) @org.jetbrains.annotations.Nullable p0: A): void
     public inner class Ann$Container
 }

compiler/testData/codegen/bytecodeText/valueClasses/mfvcDeclaration.kt

@@ -71,6 +71,6 @@ fun functionWithoutBoxes(x: D, y: D) {
 // 1 INVOKESPECIAL D.<init> \(IILjava/lang/String;\)V
 // 2 INVOKESTATIC D.box-impl \(IILjava/lang/String;\)LD;
 // 3 INVOKESTATIC C.box-impl \(IILjava/lang/String;\)LC;
-// 1 public final static functionWithoutBoxes-GPBa7dw\(IILjava/lang/String;IILjava/lang/String;\)V
+// 1 public final static functionWithoutBoxes-d7Y4ALo\(IILjava/lang/String;IILjava/lang/String;\)V
 // 0 functionWithoutBoxes.*(\n {3}.*)*(\n {4}(NEW [ABCD]|.*(box|[ABCD]\.<init>|LA;|LB;|LC;|LD;)))
 // 1 privateAccess.*(\n   .+)*(\n    GETFIELD Regular\.x-x-x : I)(\n   .+)*(\n    INVOKEVIRTUAL Regular\.getX-x \(\)LC;)(\n   .+)*(\n    INVOKESPECIAL Regular\.getX \(\)LD;)

compiler/testData/codegen/bytecodeText/valueClasses/mfvcReassignments.kt

@@ -73,13 +73,11 @@ fun reassignField(x: DPoint, box: Box) {
 // 0 107(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){3}108
 // 0 108(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){1}109
 // 0 109(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){1}110
-// 1 109(\D|\d\D|\d\d\D)*(ASTORE(\D|\d\D|\d\d\D)*){1}110
+// 0 109(\D|\d\D|\d\d\D)*(ASTORE(\D|\d\D|\d\d\D)*){1}110
-// 0 109(\D|\d\D|\d\d\D)*(ASTORE(\D|\d\D|\d\d\D)*){2}110
 // 1 110(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){2}111
 // 0 110(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){3}111
 // 0 111(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){1}112
 // 0 112(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){1}113
-// 1 112(\D|\d\D|\d\d\D)*(ASTORE(\D|\d\D|\d\d\D)*){1}113
+// 0 112(\D|\d\D|\d\d\D)*(ASTORE(\D|\d\D|\d\d\D)*){1}113
-// 0 112(\D|\d\D|\d\d\D)*(ASTORE(\D|\d\D|\d\d\D)*){2}113
 // 1 113(\D|\d\D|\d\d\D)*(ASTORE(\D|\d\D|\d\d\D)*){1}114
 // 0 113(\D|\d\D|\d\d\D)*(ASTORE(\D|\d\D|\d\d\D)*){2}114

compiler/testData/codegen/bytecodeText/valueClasses/regularClassWithMFVC.kt

@@ -98,28 +98,28 @@ fun trySetSegment(segment: DSegment) {
 // 1 public synthetic <init>\(DDDDLkotlin/jvm/internal/DefaultConstructorMarker;\)V
 // 0 public synthetic <init>\(DDDDLkotlin/jvm/internal/DefaultConstructorMarker;\)V.*(\n {3}.*)*(\n {4}.*box)
 // 1 public final getP1\(\)LDPoint;
-// 1 public final setP1-sUp7gFk\(DD\)V
+// 1 public final setP1-nuuzChU\(DD\)V
 // 1 public final getP2\(\)LDPoint;
-// 1 public final setP2-sUp7gFk\(DD\)V
+// 1 public final setP2-nuuzChU\(DD\)V
 // 1 public final getCenter\(\)LDPoint;
 // 1 public final synthetic getCenter-x\(\)D
 // 1 public final synthetic getCenter-y\(\)D
 // 1 public final getNotImplemented\(\)LDPoint;
 // 1 public final synthetic getNotImplemented-x\(\)D
 // 1 public final synthetic getNotImplemented-y\(\)D
-// 1 public final setNotImplemented-sUp7gFk\(DD\)V
+// 1 public final setNotImplemented-nuuzChU\(DD\)V
 // 1 public final getPoint1WithBackingFieldAndDefaultGetter\(\)LDPoint;
 // 1 public final synthetic getPoint1WithBackingFieldAndDefaultGetter-x\(\)D
 // 1 public final synthetic getPoint1WithBackingFieldAndDefaultGetter-y\(\)D
-// 1 public final setPoint1WithBackingFieldAndDefaultGetter-sUp7gFk\(DD\)V
+// 1 public final setPoint1WithBackingFieldAndDefaultGetter-nuuzChU\(DD\)V
 // 1 public final getPoint2WithBackingFieldAndDefaultGetter\(\)LDPoint;
 // 1 public final synthetic getPoint2WithBackingFieldAndDefaultGetter-x\(\)D
 // 1 public final synthetic getPoint2WithBackingFieldAndDefaultGetter-y\(\)D
-// 1 public final setPoint2WithBackingFieldAndDefaultGetter-sUp7gFk\(DD\)V
+// 1 public final setPoint2WithBackingFieldAndDefaultGetter-nuuzChU\(DD\)V
 // 1 public final getPointWithBackingFieldAndCustomGetter\(\)LDPoint;
 // 1 public final synthetic getPointWithBackingFieldAndCustomGetter-x\(\)D
 // 1 public final synthetic getPointWithBackingFieldAndCustomGetter-y\(\)D
-// 1 public final setPointWithBackingFieldAndCustomGetter-sUp7gFk\(DD\)V
+// 1 public final setPointWithBackingFieldAndCustomGetter-nuuzChU\(DD\)V
 // 1 public final synthetic getP1-x\(\)D
 // 1 public final synthetic getP1-y\(\)D
 // 1 public final synthetic getP2-x\(\)D
@@ -133,21 +133,21 @@ fun trySetSegment(segment: DSegment) {
 // 0 try[GS]etSegment\(LDSegment;\)V.*(\n {3}.*)*(\n {4}.*\.box)
 // 1 tryGetSegment\(LDSegment;\)V.*\n(( {3}.*\n)*( {4}.*LDPoint;\n)){7}
 // 0 tryGetSegment\(LDSegment;\)V.*\n(( {3}.*\n)*( {4}.*LDPoint;\n)){8}
-// 1 trySetSegment\(LDSegment;\)V.*\n(( {3}.*\n)*( {4}.*LDPoint;\n)){6}
+// 0 trySetSegment\(LDSegment;\)V.*\n(( {3}.*\n)*( {4}.*LDPoint;\n)){1}
-// 0 trySetSegment\(LDSegment;\)V.*\n(( {3}.*\n)*( {4}.*LDPoint;\n)){7}
+// 1 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setNotImplemented-nuuzChU \(DD\)V)){1}
-// 1 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setNotImplemented-sUp7gFk \(DD\)V)){1}
+// 0 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setNotImplemented-nuuzChU \(DD\)V)){2}
-// 0 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setNotImplemented-sUp7gFk \(DD\)V)){2}
+// 1 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setPoint1WithBackingFieldAndDefaultGetter-nuuzChU \(DD\)V)){1}
-// 1 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setPoint1WithBackingFieldAndDefaultGetter-sUp7gFk \(DD\)V)){1}
+// 0 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setPoint1WithBackingFieldAndDefaultGetter-nuuzChU \(DD\)V)){2}
-// 0 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setPoint1WithBackingFieldAndDefaultGetter-sUp7gFk \(DD\)V)){2}
+// 1 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setPoint2WithBackingFieldAndDefaultGetter-nuuzChU \(DD\)V)){1}
-// 1 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setPoint2WithBackingFieldAndDefaultGetter-sUp7gFk \(DD\)V)){1}
+// 0 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setPoint2WithBackingFieldAndDefaultGetter-nuuzChU \(DD\)V)){2}
-// 0 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setPoint2WithBackingFieldAndDefaultGetter-sUp7gFk \(DD\)V)){2}
+// 1 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setPointWithBackingFieldAndCustomGetter-nuuzChU \(DD\)V)){1}
-// 1 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setPointWithBackingFieldAndCustomGetter-sUp7gFk \(DD\)V)){1}
+// 0 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setPointWithBackingFieldAndCustomGetter-nuuzChU \(DD\)V)){2}
-// 0 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setPointWithBackingFieldAndCustomGetter-sUp7gFk \(DD\)V)){2}
+// 1 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setP1-nuuzChU \(DD\)V)){1}
-// 1 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setP1-sUp7gFk \(DD\)V)){1}
+// 0 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setP1-nuuzChU \(DD\)V)){2}
-// 0 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setP1-sUp7gFk \(DD\)V)){2}
+// 1 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setP2-nuuzChU \(DD\)V)){1}
-// 1 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setP2-sUp7gFk \(DD\)V)){1}
+// 0 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setP2-nuuzChU \(DD\)V)){2}
-// 0 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DSegment\.setP2-sUp7gFk \(DD\)V)){2}
 // 0 try[GS]etSegment\(LDSegment;\)V.*(\n {3}.*)*(\n {4}INVOKEVIRTUAL DPoint\.get[XY] \(\)D)
 // 1 tryGetSegment\(LDSegment;\)V.*((\n {3}.*)*?(\n {4}INVOKEVIRTUAL DSegment\.get.*-[xy] \(\)D)){14}
 // 0 tryGetSegment\(LDSegment;\)V.*((\n {3}.*)*?(\n {4}INVOKEVIRTUAL DSegment\.get.*-[xy] \(\)D)){15}
-// 0 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*?(\n {4}INVOKEVIRTUAL DSegment\.get.*-[xy] \(\)D)){1}
+// 1 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*?(\n {4}INVOKEVIRTUAL DSegment\.get.*-[xy] \(\)D)){12}
+// 0 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*?(\n {4}INVOKEVIRTUAL DSegment\.get.*-[xy] \(\)D)){13}

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java

@@ -51731,6 +51731,12 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
             runTest("compiler/testData/codegen/box/valueClasses/equality.kt");
         }
 
+        @Test
+        @TestMetadata("fakeOverrideCall.kt")
+        public void testFakeOverrideCall() throws Exception {
+            runTest("compiler/testData/codegen/box/valueClasses/fakeOverrideCall.kt");
+        }
+
         @Test
         @TestMetadata("forStatement.kt")
         public void testForStatement() throws Exception {
@@ -51797,6 +51803,12 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
             runTest("compiler/testData/codegen/box/valueClasses/mfvcUntypedEqualsOverriden.kt");
         }
 
+        @Test
+        @TestMetadata("multiModules.kt")
+        public void testMultiModules() throws Exception {
+            runTest("compiler/testData/codegen/box/valueClasses/multiModules.kt");
+        }
+
         @Test
         @TestMetadata("mutableSharedMfvcVar.kt")
         public void testMutableSharedMfvcVar() throws Exception {
@@ -51821,6 +51833,12 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
             runTest("compiler/testData/codegen/box/valueClasses/overrides_typeParameters.kt");
         }
 
+        @Test
+        @TestMetadata("regularClassSecondaryConstructorWithMfvc.kt")
+        public void testRegularClassSecondaryConstructorWithMfvc() throws Exception {
+            runTest("compiler/testData/codegen/box/valueClasses/regularClassSecondaryConstructorWithMfvc.kt");
+        }
+
         @Test
         @TestMetadata("secondaryConstructorsWithBody.kt")
         public void testSecondaryConstructorsWithBody() throws Exception {