[IR] Integrate MFVC with Inline classes

#KT-1179

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

@@ -50213,6 +50213,12 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT
             runTest("compiler/testData/codegen/box/valueClasses/overrides.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
         }
 
+        @Test
+        @TestMetadata("overrides_inlineClass.kt")
+        public void testOverrides_inlineClass() throws Exception {
+            runTest("compiler/testData/codegen/box/valueClasses/overrides_inlineClass.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+        }
+
         @Test
         @TestMetadata("throwingMFVCReassignments.kt")
         public void testThrowingMFVCReassignments() throws Exception {

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

@@ -640,7 +640,9 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass
 
                 val targetStructure = run {
                     val mfvcOrOriginal =
-                        this@BridgeLowering.context.inlineClassReplacements.originalFunctionForMethodReplacement[target] ?: target
+                        this@BridgeLowering.context.inlineClassReplacements.originalFunctionForMethodReplacement[target]
+                            ?: this@BridgeLowering.context.inlineClassReplacements.originalFunctionForStaticReplacement[target]
+                            ?: target
                     this@BridgeLowering.context.multiFieldValueClassReplacements
                         .bindingNewFunctionToParameterTemplateStructure[mfvcOrOriginal]
                         ?.also { structure ->
@@ -651,7 +653,9 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass
 
                 val bridgeStructure = run {
                     val mfvcOrOriginal =
-                        this@BridgeLowering.context.inlineClassReplacements.originalFunctionForMethodReplacement[bridge] ?: bridge
+                        this@BridgeLowering.context.inlineClassReplacements.originalFunctionForMethodReplacement[bridge]
+                            ?: this@BridgeLowering.context.inlineClassReplacements.originalFunctionForStaticReplacement[bridge]
+                            ?: bridge
                     this@BridgeLowering.context.multiFieldValueClassReplacements
                         .bindingNewFunctionToParameterTemplateStructure[mfvcOrOriginal]
                         ?.also { structure ->

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

@@ -333,7 +333,7 @@ private class JvmMultiFieldValueClassLowering(context: JvmBackendContext) : JvmV
             val overriddenReplaced = replacement.overriddenSymbols.firstOrNull {
                 replacements.bindingNewFunctionToParameterTemplateStructure[it.owner] != null
             }?.owner
-            if (source.isFakeOverride && source.parentAsClass.isMultiFieldValueClass && overriddenReplaced != null) {
+            if (source.parentAsClass.isMultiFieldValueClass && overriddenReplaced != null) {
                 copyParameterDeclarationsFrom(overriddenReplaced)
                 dispatchReceiverParameter = source.dispatchReceiverParameter!!.copyTo(this)
                 val replacementStructure = replacement.overriddenSymbols.firstNotNullOf {
@@ -358,67 +358,95 @@ private class JvmMultiFieldValueClassLowering(context: JvmBackendContext) : JvmV
         allScopes.push(createScope(source))
         source.body = context.createIrBuilder(source.symbol, source.startOffset, source.endOffset).run {
             val sourceExplicitParameters = source.explicitParameters
-            if (inverted) {
-                irExprBody(irCall(target).apply {
-                    passTypeArgumentsFrom(source)
-                    val targetExplicitParameters = target.explicitParameters
-                    val originalStructure: List<RemappedParameter> = replacements.bindingOldFunctionToParameterTemplateStructure[original]!!
-                    val targetStructure = replacements.bindingNewFunctionToParameterTemplateStructure[target]
-                    require(
-                        when (targetStructure) {
-                            null -> originalStructure.size == targetExplicitParameters.size
-                            else -> originalStructure.size == targetStructure.size &&
-                                    targetStructure.sumOf { it.valueParameters.size } == targetExplicitParameters.size
+            irExprBody(irCall(target).apply {
+                passTypeArgumentsFrom(source)
+                val targetExplicitParameters = target.explicitParameters
+                val sourceStructure: List<RemappedParameter>? = replacements.bindingNewFunctionToParameterTemplateStructure[source]
+                val targetStructure: List<RemappedParameter>? = replacements.bindingNewFunctionToParameterTemplateStructure[target]
+                val errorMessage = {
+                    """
+                        Incompatible structures for
+                        Source: $sourceStructure
+                        ${source.render()}
+                        Target: $targetStructure
+                        ${target.render()}
+                        """.trimIndent()
+                }
+                when (targetStructure) {
+                    null -> when (sourceStructure) {
+                        null -> require(targetExplicitParameters.size == sourceExplicitParameters.size, errorMessage)
+                        else -> {
+                            require(targetExplicitParameters.size == sourceStructure.size, errorMessage)
+                            require(sourceExplicitParameters.size == sourceStructure.sumOf { it.valueParameters.size }, errorMessage)
                         }
-                    ) {
-                        "Incompatible structures: $originalStructure, $targetStructure"
                     }
-                    val structuresSizes = originalStructure.size
-                    var flattenedSourceIndex = 0
-                    var flattenedTargetIndex = 0
-                    for (i in 0 until structuresSizes) {
-                        val remappedOriginalParameter = originalStructure[i]
-                        val remappedTargetParameter = targetStructure?.get(i)
-                        when (remappedOriginalParameter) {
-                            is MultiFieldValueClassMapping -> {
-                                when (remappedTargetParameter) {
-                                    is MultiFieldValueClassMapping -> {
-                                        require(remappedTargetParameter.valueParameters.size == remappedOriginalParameter.valueParameters.size) {
-                                            "Incompatible structures: $remappedTargetParameter, $remappedOriginalParameter"
-                                        }
-                                        repeat(remappedTargetParameter.valueParameters.size) {
-                                            putArgument(
-                                                targetExplicitParameters[flattenedTargetIndex++],
-                                                irGet(sourceExplicitParameters[flattenedSourceIndex++])
-                                            )
-                                        }
+                    else -> when (sourceStructure) {
+                        null -> {
+                            require(targetStructure.size == sourceExplicitParameters.size, errorMessage)
+                            require(targetStructure.sumOf { it.valueParameters.size } == targetExplicitParameters.size, errorMessage)
+                        }
+                        else -> {
+                            require(targetStructure.size == sourceStructure.size, errorMessage)
+                            require(sourceStructure.sumOf { it.valueParameters.size } == sourceExplicitParameters.size, errorMessage)
+                            require(targetStructure.sumOf { it.valueParameters.size } == targetExplicitParameters.size, errorMessage)
+                            require((targetStructure zip sourceStructure).none { (t, s) ->
+                                t is MultiFieldValueClassMapping && s is MultiFieldValueClassMapping && t.declarations != s.declarations
+                            }, errorMessage)
+                        }
+                    }
+                }
+                val structuresSizes = sourceStructure?.size ?: targetStructure?.size ?: targetExplicitParameters.size
+                var flattenedSourceIndex = 0
+                var flattenedTargetIndex = 0
+                for (i in 0 until structuresSizes) {
+                    val remappedSourceParameter = sourceStructure?.get(i)
+                    val remappedTargetParameter = targetStructure?.get(i)
+                    when (remappedSourceParameter) {
+                        is MultiFieldValueClassMapping -> {
+                            when (remappedTargetParameter) {
+                                is MultiFieldValueClassMapping -> {
+                                    require(remappedTargetParameter.valueParameters.size == remappedSourceParameter.valueParameters.size) {
+                                        "Incompatible structures: $remappedTargetParameter, $remappedSourceParameter"
                                     }
-                                    is RegularMapping, null ->
+                                    repeat(remappedTargetParameter.valueParameters.size) {
                                         putArgument(
                                             targetExplicitParameters[flattenedTargetIndex++],
-                                            irCall(remappedOriginalParameter.declarations.boxMethod).apply {
-                                                sourceExplicitParameters
-                                                    .slice(flattenedSourceIndex until flattenedSourceIndex + remappedOriginalParameter.valueParameters.size)
-                                                    .forEachIndexed { index, boxParameter -> putValueArgument(index, irGet(boxParameter)) }
-                                                    .also { flattenedSourceIndex += remappedOriginalParameter.valueParameters.size }
-                                            })
+                                            irGet(sourceExplicitParameters[flattenedSourceIndex++])
+                                        )
+                                    }
+                                }
+                                is RegularMapping, null ->
+                                    putArgument(
+                                        targetExplicitParameters[flattenedTargetIndex++],
+                                        irCall(remappedSourceParameter.declarations.boxMethod).apply {
+                                            sourceExplicitParameters
+                                                .slice(flattenedSourceIndex until flattenedSourceIndex + remappedSourceParameter.valueParameters.size)
+                                                .forEachIndexed { index, boxParameter -> putValueArgument(index, irGet(boxParameter)) }
+                                                .also { flattenedSourceIndex += remappedSourceParameter.valueParameters.size }
+                                        })
+                            }
+                        }
+                        is RegularMapping, null -> when (remappedTargetParameter) {
+                            is MultiFieldValueClassMapping -> {
+                                val receiver = sourceExplicitParameters[flattenedSourceIndex++]
+                                for (unboxMethod in remappedTargetParameter.declarations.unboxMethods) {
+                                    putArgument(
+                                        targetExplicitParameters[flattenedTargetIndex++],
+                                        irCall(unboxMethod).apply { dispatchReceiver = irGet(receiver) }
+                                    )
                                 }
                             }
-                            is RegularMapping -> putArgument(
+                            else -> putArgument(
                                 targetExplicitParameters[flattenedTargetIndex++],
                                 irGet(sourceExplicitParameters[flattenedSourceIndex++])
                             )
                         }
                     }
-                })
-            } else {
-                irExprBody(irCall(original).apply { // not target as it will be replaced during lowering
-                    passTypeArgumentsFrom(source)
-                    for ((parameter, newParameter) in sourceExplicitParameters.zip(original.explicitParameters)) {
-                        putArgument(newParameter, irGet(parameter))
-                    }
-                }).transform(this@JvmMultiFieldValueClassLowering, null)
-            }
+                }
+                require(flattenedTargetIndex == targetExplicitParameters.size && flattenedSourceIndex == sourceExplicitParameters.size) {
+                    "Incorrect source:\n${source.dump()}\n\nfor target\n${target.dump()}"
+                }
+            })
         }
         allScopes.pop()
     }

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

@@ -53,7 +53,6 @@ class MemoizedInlineClassReplacements(
                         (it.origin == IrDeclarationOrigin.DELEGATED_PROPERTY_ACCESSOR && it.visibility == DescriptorVisibilities.LOCAL) ||
                         it.isStaticValueClassReplacement ||
                         it.origin == JvmLoweredDeclarationOrigin.MULTI_FIELD_VALUE_CLASS_GENERATED_IMPL_METHOD ||
-                        it.origin == IrDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_MEMBER ||
                         it.origin.isSynthetic && it.origin != IrDeclarationOrigin.SYNTHETIC_GENERATED_SAM_IMPLEMENTATION ->
                     null
 
@@ -166,6 +165,11 @@ class MemoizedInlineClassReplacements(
                     it.defaultValue = parameter.defaultValue?.patchDeclarationParents(this)
                 }
             }
+            context.multiFieldValueClassReplacements.run {
+                bindingNewFunctionToParameterTemplateStructure[function]?.also {
+                    bindingNewFunctionToParameterTemplateStructure[this@buildReplacement] = it
+                }
+            }
         }
 
     override fun createStaticReplacement(function: IrFunction): IrSimpleFunction =
@@ -201,6 +205,11 @@ class MemoizedInlineClassReplacements(
                 }
             }
             valueParameters = newValueParameters
+            context.multiFieldValueClassReplacements.run {
+                bindingNewFunctionToParameterTemplateStructure[function]?.also {
+                    bindingNewFunctionToParameterTemplateStructure[this@buildReplacement] = it
+                }
+            }
         }
 
     private fun buildReplacement(

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

@@ -231,8 +231,8 @@ class MultiFieldValueClassSpecificDeclarations(
             this.name = nodeFullNames[leaf]!!
             this.type = leaf.type
             visibility = DescriptorVisibilities.PRIVATE
-        }.apply { 
-            parent = valueClass 
+        }.apply {
+            parent = valueClass
         }
     }
 
@@ -276,12 +276,12 @@ class MultiFieldValueClassSpecificDeclarations(
         })
     }
 
-    fun IrBuilderWithScope.fieldGetter(receiver: IrValueParameter, field: IrField): IrGetField =
+    private fun IrBuilderWithScope.fieldGetter(receiver: IrValueParameter, field: IrField): IrGetField =
         irGetField(irGet(receiver), field)
 
-    fun IrFunction.fieldGetter(field: IrField): IrBuilderWithScope.() -> IrGetField = { fieldGetter(dispatchReceiverParameter!!, field) }
+    private fun IrFunction.fieldGetter(field: IrField): IrBuilderWithScope.() -> IrGetField = { fieldGetter(dispatchReceiverParameter!!, field) }
 
-    val selfImplementationAgnosticDeclarations = ImplementationAgnostic(
+    private val selfImplementationAgnosticDeclarations = ImplementationAgnostic(
         fields.map {
             VirtualProperty(
                 type = it.type,
@@ -462,7 +462,7 @@ class MultiFieldValueClassSpecificDeclarations(
             }
         }
 
-        val nodeToSymbols = indexesByInternalNode.mapValues { (_, indexes) -> virtualFields.slice(indexes) } +
+        private val nodeToSymbols = indexesByInternalNode.mapValues { (_, indexes) -> virtualFields.slice(indexes) } +
                 indexByLeaf.mapValues { (_, index) -> listOf(virtualFields[index]) }
 
         private val internalNodeToExpressionGetters: Map<InternalNode<Unit, Unit>, ExpressionGenerator<T>> =

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

@@ -2,6 +2,7 @@
 // TARGET_BACKEND: JVM_IR
 // WORKS_WHEN_VALUE_CLASS
 // LANGUAGE: +ValueClasses
+// CHECK_BYTECODE_LISTING
 
 @JvmInline
 value class DPoint(val x: Double, val y: Double)

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

@@ -0,0 +1,61 @@
+@kotlin.Metadata
+public final class A {
+    // source: 'MFVCFieldInitializationOrder.kt'
+    private field x$x: double
+    private field x$y: double
+    public method <init>(p0: double, p1: double): void
+    public final method getX$x(): double
+    public final method getX$y(): double
+    public final @org.jetbrains.annotations.NotNull method getX(): DPoint
+    public final method setX-sUp7gFk(p0: double, p1: double): void
+}
+
+@kotlin.Metadata
+public final class B {
+    // source: 'MFVCFieldInitializationOrder.kt'
+    private field a$x: double
+    private field a$y: double
+    private field b$x: double
+    private field b$y: double
+    private field c$x: double
+    private field c$y: double
+    public method <init>(): void
+    public final method getA$x(): double
+    public final method getA$y(): double
+    public final @org.jetbrains.annotations.NotNull method getA(): DPoint
+    public final method getB$x(): double
+    public final method getB$y(): double
+    public final @org.jetbrains.annotations.NotNull method getB(): DPoint
+    public final method getC$x(): double
+    public final method getC$y(): double
+    public final @org.jetbrains.annotations.NotNull method getC(): DPoint
+    public final method setA-sUp7gFk(p0: double, p1: double): void
+}
+
+@kotlin.jvm.JvmInline
+@kotlin.Metadata
+public final class DPoint {
+    // source: 'MFVCFieldInitializationOrder.kt'
+    private field x: double
+    private 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-impl0(): double
+    public synthetic final method unbox-impl1(): double
+}
+
+@kotlin.Metadata
+public final class MFVCFieldInitializationOrderKt {
+    // source: 'MFVCFieldInitializationOrder.kt'
+    public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
+}

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

@@ -86,7 +86,7 @@ public final class C {
     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 method getX(): int
-    public final method getY(): int
+    public final method getY-GsR9Xnw(): int
     public final @org.jetbrains.annotations.NotNull method getZ(): java.lang.String
     public method hashCode(): int
     public static method hashCode-impl(p0: int, p1: int, p2: java.lang.String): int
@@ -128,7 +128,7 @@ public final class D {
     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 method getX$x(): int
-    public final method getX$y(): int
+    public final method getX$y-GsR9Xnw(): int
     public final @org.jetbrains.annotations.NotNull method getX$z(): java.lang.String
     public final @org.jetbrains.annotations.NotNull method getX(): C
     public method hashCode(): int
@@ -155,7 +155,7 @@ public final class E {
     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 getWithNonTrivialSetters-impl(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): D
     public final method getX$x$x(): int
-    public final method getX$x$y(): int
+    public final method getX$x$y-GsR9Xnw(): int
     public final @org.jetbrains.annotations.NotNull method getX$x$z(): java.lang.String
     public final @org.jetbrains.annotations.NotNull method getX$x(): C
     public final @org.jetbrains.annotations.NotNull method getX(): D
@@ -195,11 +195,11 @@ public final class NotInlined {
     public synthetic method <init>(p0: int, p1: int, p2: int, p3: int, p4: java.lang.String, p5: java.util.List, p6: int, p7: kotlin.jvm.internal.DefaultConstructorMarker): void
     public @org.jetbrains.annotations.NotNull method getFakeOverrideMFVC(): R
     public method getFakeOverrideRegular(): int
-    public final @org.jetbrains.annotations.NotNull method getL$t(): java.util.List
+    public final @org.jetbrains.annotations.NotNull method getL$t-GKOAj6k(): java.util.List
     public final method getL$x(): int
-    public final method getL$y(): int
+    public final method getL$y-pVg5ArA(): int
     public final method getL$z$x$x$x(): int
-    public final method getL$z$x$x$y(): int
+    public final method getL$z$x$x$y-GsR9Xnw(): int
     public final @org.jetbrains.annotations.NotNull method getL$z$x$x$z(): java.lang.String
     public final @org.jetbrains.annotations.NotNull method getL$z$x$x(): C
     public final @org.jetbrains.annotations.NotNull method getL$z$x(): D
@@ -239,11 +239,11 @@ public final class R {
     public static @org.jetbrains.annotations.NotNull method getFakeOverrideMFVC-impl(p0: int, p1: int, p2: int, p3: int, @org.jetbrains.annotations.NotNull p4: java.lang.String, @org.jetbrains.annotations.NotNull p5: java.util.List): R
     public method getFakeOverrideRegular(): int
     public static method getFakeOverrideRegular-impl(p0: int, p1: int, p2: int, p3: int, @org.jetbrains.annotations.NotNull p4: java.lang.String, @org.jetbrains.annotations.NotNull p5: java.util.List): int
-    public final @org.jetbrains.annotations.NotNull method getT(): java.util.List
+    public final @org.jetbrains.annotations.NotNull method getT-GKOAj6k(): java.util.List
     public final method getX(): int
-    public final method getY(): int
+    public final method getY-pVg5ArA(): int
     public final method getZ$x$x$x(): int
-    public final method getZ$x$x$y(): int
+    public final method getZ$x$x$y-GsR9Xnw(): int
     public final @org.jetbrains.annotations.NotNull method getZ$x$x$z(): java.lang.String
     public final @org.jetbrains.annotations.NotNull method getZ$x$x(): C
     public final @org.jetbrains.annotations.NotNull method getZ$x(): D

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

@@ -1,7 +1,10 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// https://youtrack.jetbrains.com/issue/KT-52236/Different-modality-in-psi-and-fir
 // WITH_STDLIB
 // TARGET_BACKEND: JVM_IR
 // WORKS_WHEN_VALUE_CLASS
 // LANGUAGE: +ValueClasses
+// CHECK_BYTECODE_LISTING
 
 OPTIONAL_JVM_INLINE_ANNOTATION
 value class F1(val x: Int)

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

@@ -0,0 +1,249 @@
+@kotlin.jvm.JvmInline
+@kotlin.Metadata
+public final class A {
+    // source: 'equality.kt'
+    private field f1: int
+    private field f2: int
+    private field f3$x: int
+    private field f3$y: int
+    private field f4: int
+    private field f5: int
+    private @org.jetbrains.annotations.NotNull field f6: java.lang.String
+    private field f7: int
+    private field f8: int
+    private @org.jetbrains.annotations.NotNull field f9: java.lang.String
+    private synthetic method <init>(p0: int, p1: int, p2: int, p3: int, p4: int, p5: int, p6: java.lang.String, p7: int, p8: int, p9: java.lang.String): void
+    public synthetic final static method box-impl(p0: int, p1: int, p2: int, p3: int, p4: int, p5: int, p6: java.lang.String, p7: int, p8: int, p9: java.lang.String): A
+    public final static method constructor-impl(p0: int, p1: int, p2: int, p3: int, p4: int, p5: int, @org.jetbrains.annotations.NotNull p6: java.lang.String, p7: int, p8: int, @org.jetbrains.annotations.NotNull p9: 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: int, p3: int, p4: int, p5: int, p6: java.lang.String, p7: int, p8: int, p9: java.lang.String, p10: java.lang.Object): boolean
+    public final static method equals-impl0(p0: int, p1: int, p2: int, p3: int, p4: int, p5: int, p6: java.lang.String, p7: int, p8: int, p9: java.lang.String, p10: int, p11: int, p12: int, p13: int, p14: int, p15: int, p16: java.lang.String, p17: int, p18: int, p19: java.lang.String): boolean
+    public final method getF1-DbFnDB4(): int
+    public final method getF2-ejSTSP4(): int
+    public final method getF3$x-DbFnDB4(): int
+    public final method getF3$y-ejSTSP4(): int
+    public final @org.jetbrains.annotations.NotNull method getF3(): F3
+    public final method getF4-4yoqybc(): int
+    public final method getF5-z3qHWqM(): int
+    public final @org.jetbrains.annotations.NotNull method getF6-OgMO970(): java.lang.String
+    public final method getF7(): int
+    public final method getF8-pVg5ArA(): int
+    public final @org.jetbrains.annotations.NotNull method getF9(): java.lang.String
+    public method hashCode(): int
+    public static method hashCode-impl(p0: int, p1: int, p2: int, p3: int, p4: int, p5: int, p6: java.lang.String, p7: int, p8: int, p9: java.lang.String): int
+    public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
+    public static method toString-impl(p0: int, p1: int, p2: int, p3: int, p4: int, p5: int, p6: java.lang.String, p7: int, p8: int, p9: java.lang.String): java.lang.String
+    public synthetic final method unbox-impl0(): int
+    public synthetic final method unbox-impl1(): int
+    public synthetic final method unbox-impl2(): int
+    public synthetic final method unbox-impl3(): int
+    public synthetic final method unbox-impl4(): int
+    public synthetic final method unbox-impl5(): int
+    public synthetic final method unbox-impl6(): java.lang.String
+    public synthetic final method unbox-impl7(): int
+    public synthetic final method unbox-impl8(): int
+    public synthetic final method unbox-impl9(): java.lang.String
+}
+
+@kotlin.jvm.JvmInline
+@kotlin.Metadata
+public final class B {
+    // source: 'equality.kt'
+    private field a1$f1: int
+    private field a1$f2: int
+    private field a1$f3$x: int
+    private field a1$f3$y: int
+    private field a1$f4: int
+    private field a1$f5: int
+    private @org.jetbrains.annotations.NotNull field a1$f6: java.lang.String
+    private field a1$f7: int
+    private field a1$f8: int
+    private @org.jetbrains.annotations.NotNull field a1$f9: java.lang.String
+    private field a2$f1: int
+    private field a2$f2: int
+    private field a2$f3$x: int
+    private field a2$f3$y: int
+    private field a2$f4: int
+    private field a2$f5: int
+    private @org.jetbrains.annotations.NotNull field a2$f6: java.lang.String
+    private field a2$f7: int
+    private field a2$f8: int
+    private @org.jetbrains.annotations.NotNull field a2$f9: java.lang.String
+    private synthetic method <init>(p0: int, p1: int, p2: int, p3: int, p4: int, p5: int, p6: java.lang.String, p7: int, p8: int, p9: java.lang.String, p10: int, p11: int, p12: int, p13: int, p14: int, p15: int, p16: java.lang.String, p17: int, p18: int, p19: java.lang.String): void
+    public synthetic final static method box-impl(p0: int, p1: int, p2: int, p3: int, p4: int, p5: int, p6: java.lang.String, p7: int, p8: int, p9: java.lang.String, p10: int, p11: int, p12: int, p13: int, p14: int, p15: int, p16: java.lang.String, p17: int, p18: int, p19: java.lang.String): B
+    public final static method constructor-impl(p0: int, p1: int, p2: int, p3: int, p4: int, p5: int, @org.jetbrains.annotations.NotNull p6: java.lang.String, p7: int, p8: int, @org.jetbrains.annotations.NotNull p9: java.lang.String, p10: int, p11: int, p12: int, p13: int, p14: int, p15: int, @org.jetbrains.annotations.NotNull p16: java.lang.String, p17: int, p18: int, @org.jetbrains.annotations.NotNull p19: 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: int, p3: int, p4: int, p5: int, p6: java.lang.String, p7: int, p8: int, p9: java.lang.String, p10: int, p11: int, p12: int, p13: int, p14: int, p15: int, p16: java.lang.String, p17: int, p18: int, p19: java.lang.String, p20: java.lang.Object): boolean
+    public final static method equals-impl0(p0: int, p1: int, p2: int, p3: int, p4: int, p5: int, p6: java.lang.String, p7: int, p8: int, p9: java.lang.String, p10: int, p11: int, p12: int, p13: int, p14: int, p15: int, p16: java.lang.String, p17: int, p18: int, p19: java.lang.String, p20: int, p21: int, p22: int, p23: int, p24: int, p25: int, p26: java.lang.String, p27: int, p28: int, p29: java.lang.String, p30: int, p31: int, p32: int, p33: int, p34: int, p35: int, p36: java.lang.String, p37: int, p38: int, p39: java.lang.String): boolean
+    public final method getA1$f1-DbFnDB4(): int
+    public final method getA1$f2-ejSTSP4(): int
+    public final method getA1$f3$x-DbFnDB4(): int
+    public final method getA1$f3$y-ejSTSP4(): int
+    public final @org.jetbrains.annotations.NotNull method getA1$f3(): F3
+    public final method getA1$f4-4yoqybc(): int
+    public final method getA1$f5-z3qHWqM(): int
+    public final @org.jetbrains.annotations.NotNull method getA1$f6-OgMO970(): java.lang.String
+    public final method getA1$f7(): int
+    public final method getA1$f8-pVg5ArA(): int
+    public final @org.jetbrains.annotations.NotNull method getA1$f9(): java.lang.String
+    public final @org.jetbrains.annotations.NotNull method getA1(): A
+    public final method getA2$f1-DbFnDB4(): int
+    public final method getA2$f2-ejSTSP4(): int
+    public final method getA2$f3$x-DbFnDB4(): int
+    public final method getA2$f3$y-ejSTSP4(): int
+    public final @org.jetbrains.annotations.NotNull method getA2$f3(): F3
+    public final method getA2$f4-4yoqybc(): int
+    public final method getA2$f5-z3qHWqM(): int
+    public final @org.jetbrains.annotations.NotNull method getA2$f6-OgMO970(): java.lang.String
+    public final method getA2$f7(): int
+    public final method getA2$f8-pVg5ArA(): int
+    public final @org.jetbrains.annotations.NotNull method getA2$f9(): java.lang.String
+    public final @org.jetbrains.annotations.NotNull method getA2(): A
+    public method hashCode(): int
+    public static method hashCode-impl(p0: int, p1: int, p2: int, p3: int, p4: int, p5: int, p6: java.lang.String, p7: int, p8: int, p9: java.lang.String, p10: int, p11: int, p12: int, p13: int, p14: int, p15: int, p16: java.lang.String, p17: int, p18: int, p19: java.lang.String): int
+    public @org.jetbrains.annotations.NotNull method toString(): java.lang.String
+    public static @org.jetbrains.annotations.NotNull method toString-impl(p0: int, p1: int, p2: int, p3: int, p4: int, p5: int, @org.jetbrains.annotations.NotNull p6: java.lang.String, p7: int, p8: int, @org.jetbrains.annotations.NotNull p9: java.lang.String, p10: int, p11: int, p12: int, p13: int, p14: int, p15: int, @org.jetbrains.annotations.NotNull p16: java.lang.String, p17: int, p18: int, @org.jetbrains.annotations.NotNull p19: java.lang.String): java.lang.String
+    public synthetic final method unbox-impl0(): int
+    public synthetic final method unbox-impl1(): int
+    public synthetic final method unbox-impl10(): int
+    public synthetic final method unbox-impl11(): int
+    public synthetic final method unbox-impl12(): int
+    public synthetic final method unbox-impl13(): int
+    public synthetic final method unbox-impl14(): int
+    public synthetic final method unbox-impl15(): int
+    public synthetic final method unbox-impl16(): java.lang.String
+    public synthetic final method unbox-impl17(): int
+    public synthetic final method unbox-impl18(): int
+    public synthetic final method unbox-impl19(): java.lang.String
+    public synthetic final method unbox-impl2(): int
+    public synthetic final method unbox-impl3(): int
+    public synthetic final method unbox-impl4(): int
+    public synthetic final method unbox-impl5(): int
+    public synthetic final method unbox-impl6(): java.lang.String
+    public synthetic final method unbox-impl7(): int
+    public synthetic final method unbox-impl8(): int
+    public synthetic final method unbox-impl9(): java.lang.String
+}
+
+@kotlin.Metadata
+public final class EqualityKt {
+    // source: 'equality.kt'
+    public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
+}
+
+@kotlin.jvm.JvmInline
+@kotlin.Metadata
+public final class F1 {
+    // source: 'equality.kt'
+    private final field x: int
+    private synthetic method <init>(p0: int): void
+    public synthetic final static method box-impl(p0: int): F1
+    public static method constructor-impl(p0: int): int
+    public method equals(p0: java.lang.Object): boolean
+    public static method equals-impl(p0: int, p1: java.lang.Object): boolean
+    public final static method equals-impl0(p0: int, p1: int): boolean
+    public final method getX(): int
+    public method hashCode(): int
+    public static method hashCode-impl(p0: int): int
+    public method toString(): java.lang.String
+    public static method toString-impl(p0: int): java.lang.String
+    public synthetic final method unbox-impl(): int
+}
+
+@kotlin.jvm.JvmInline
+@kotlin.Metadata
+public final class F2 {
+    // source: 'equality.kt'
+    private final field x: int
+    private synthetic method <init>(p0: int): void
+    public synthetic final static method box-impl(p0: int): F2
+    public static method constructor-impl(p0: int): int
+    public method equals(p0: java.lang.Object): boolean
+    public static method equals-impl(p0: int, p1: java.lang.Object): boolean
+    public final static method equals-impl0(p0: int, p1: int): boolean
+    public final method getX-pVg5ArA(): int
+    public method hashCode(): int
+    public static method hashCode-impl(p0: int): int
+    public method toString(): java.lang.String
+    public static method toString-impl(p0: int): java.lang.String
+    public synthetic final method unbox-impl(): int
+}
+
+@kotlin.jvm.JvmInline
+@kotlin.Metadata
+public final class F3 {
+    // source: 'equality.kt'
+    private field x: int
+    private field y: int
+    private synthetic method <init>(p0: int, p1: int): void
+    public synthetic final static method box-impl(p0: int, p1: int): F3
+    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 method getX-DbFnDB4(): int
+    public final method getY-ejSTSP4(): int
+    public method hashCode(): int
+    public static method hashCode-impl(p0: int, p1: int): int
+    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-impl0(): int
+    public synthetic final method unbox-impl1(): int
+}
+
+@kotlin.jvm.JvmInline
+@kotlin.Metadata
+public final class F4 {
+    // source: 'equality.kt'
+    private final field x: int
+    private synthetic method <init>(p0: int): void
+    public synthetic final static method box-impl(p0: int): F4
+    public static method constructor-impl(p0: int): int
+    public method equals(p0: java.lang.Object): boolean
+    public static method equals-impl(p0: int, p1: java.lang.Object): boolean
+    public final static method equals-impl0(p0: int, p1: int): boolean
+    public final method getX(): int
+    public method hashCode(): int
+    public static method hashCode-impl(p0: int): int
+    public method toString(): java.lang.String
+    public static method toString-impl(p0: int): java.lang.String
+    public synthetic final method unbox-impl(): int
+}
+
+@kotlin.jvm.JvmInline
+@kotlin.Metadata
+public final class F5 {
+    // source: 'equality.kt'
+    private final field x: int
+    private synthetic method <init>(p0: int): void
+    public synthetic final static method box-impl(p0: int): F5
+    public static method constructor-impl(p0: int): int
+    public method equals(p0: java.lang.Object): boolean
+    public static method equals-impl(p0: int, p1: java.lang.Object): boolean
+    public final static method equals-impl0(p0: int, p1: int): boolean
+    public final method getX-pVg5ArA(): int
+    public method hashCode(): int
+    public static method hashCode-impl(p0: int): int
+    public method toString(): java.lang.String
+    public static method toString-impl(p0: int): java.lang.String
+    public synthetic final method unbox-impl(): int
+}
+
+@kotlin.jvm.JvmInline
+@kotlin.Metadata
+public final class F6 {
+    // source: 'equality.kt'
+    private final @org.jetbrains.annotations.NotNull field x: java.lang.String
+    private synthetic method <init>(p0: java.lang.String): void
+    public synthetic final static method box-impl(p0: java.lang.String): F6
+    public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String
+    public method equals(p0: java.lang.Object): boolean
+    public static method equals-impl(p0: java.lang.String, p1: java.lang.Object): boolean
+    public final static method equals-impl0(p0: java.lang.String, p1: java.lang.String): boolean
+    public final @org.jetbrains.annotations.NotNull method getX(): java.lang.String
+    public method hashCode(): int
+    public static method hashCode-impl(p0: java.lang.String): int
+    public method toString(): java.lang.String
+    public static method toString-impl(p0: java.lang.String): java.lang.String
+    public synthetic final method unbox-impl(): java.lang.String
+}

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

@@ -1,7 +1,10 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// https://youtrack.jetbrains.com/issue/KT-52236/Different-modality-in-psi-and-fir
 // WITH_STDLIB
 // TARGET_BACKEND: JVM_IR
 // WORKS_WHEN_VALUE_CLASS
 // LANGUAGE: +ValueClasses
+// CHECK_BYTECODE_LISTING
 
 interface AbstractPoint<T> {
     val x: T

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

@@ -0,0 +1,287 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// https://youtrack.jetbrains.com/issue/KT-52236/Different-modality-in-psi-and-fir
+// WITH_STDLIB
+// TARGET_BACKEND: JVM_IR
+// WORKS_WHEN_VALUE_CLASS
+// LANGUAGE: +ValueClasses
+// CHECK_BYTECODE_LISTING
+
+interface AbstractPoint<T> {
+    val x: T
+    val y: T
+}
+
+@JvmInline
+value class MyDouble(val value: Double)
+
+val Double.my
+    get() = MyDouble(this)
+
+@JvmInline
+value class DPoint(override val x: MyDouble, override val y: MyDouble): AbstractPoint<MyDouble>
+
+interface GenericMFVCHolder<T> {
+    var p: T
+    var p1: T
+}
+
+interface GenericMFVCHolderWithMFVCUpperBound<T : DPoint> {
+    var p: T
+    var p1: T
+}
+
+interface ReifiedMFVCHolder {
+    var p: DPoint
+    var p1: DPoint
+}
+
+data class DataClassException(val value: Any?): Exception()
+
+interface GenericMFVCHolderWithImpls<T> {
+    var p: T
+        get() = throw DataClassException(1)
+        set(value) = throw DataClassException(2 to value)
+
+    var p1: T
+        get() = throw DataClassException(3)
+        set(value) = throw DataClassException(4 to value)
+}
+
+interface GenericMFVCHolderWithMFVCUpperBoundWithImpls<T : DPoint> {
+    var p: T
+        get() = throw DataClassException(5)
+        set(value) = throw DataClassException(6 to value)
+
+    var p1: T
+        get() = throw DataClassException(7)
+        set(value) = throw DataClassException(8 to value)
+}
+
+interface ReifiedMFVCHolderWithImpls {
+    var p: DPoint
+        get() = throw DataClassException(9)
+        set(value) = throw DataClassException(10 to value)
+
+    var p1: DPoint
+        get() = throw DataClassException(11)
+        set(value) = throw DataClassException(12 to value)
+}
+
+class RealOverride(override var p: DPoint) : GenericMFVCHolder<DPoint>, ReifiedMFVCHolder, GenericMFVCHolderWithMFVCUpperBound<DPoint> {
+    override var p1: DPoint
+        get() = throw DataClassException(13)
+        set(value) = throw DataClassException(14 to value)
+}
+
+class GenericFakeOverride : GenericMFVCHolderWithImpls<DPoint>
+class ReifiedFakeOverride : ReifiedMFVCHolderWithImpls
+class GenericFakeOverrideWithMFVCUpperBound : GenericMFVCHolderWithMFVCUpperBoundWithImpls<DPoint>
+
+
+@JvmInline
+value class GenericFakeOverrideMFVC(val field1: MyDouble, val field2: MyDouble) : GenericMFVCHolderWithImpls<DPoint>
+@JvmInline
+value class ReifiedFakeOverrideMFVC(val field1: MyDouble, val field2: MyDouble) : ReifiedMFVCHolderWithImpls
+@JvmInline
+value class GenericFakeOverrideMFVCWithMFVCUpperBound(val field1: MyDouble, val field2: MyDouble) : GenericMFVCHolderWithMFVCUpperBoundWithImpls<DPoint>
+
+
+interface SomePointInterface<T> {
+    var somethingRegular: Int
+
+    var somethingGeneric: T
+
+    var somethingMFVC: DPoint
+}
+
+interface SomePointInterfaceWithMFVCBound<T : DPoint> {
+    var somethingRegular: Int
+
+    var somethingGeneric: T
+
+    var somethingMFVC: DPoint
+}
+
+@JvmInline
+value class DPointWithInterface(val x: MyDouble, val y: MyDouble) : SomePointInterface<DPoint>, SomePointInterfaceWithMFVCBound<DPoint> {
+    override var somethingGeneric: DPoint
+        get() = throw DataClassException(15)
+        set(value) = throw DataClassException(16 to value)
+
+    override var somethingMFVC: DPoint
+        get() = throw DataClassException(17)
+        set(value) = throw DataClassException(18 to value)
+
+    override var somethingRegular: Int
+        get() = throw DataClassException(19)
+        set(value) = throw DataClassException(20 to value)
+}
+
+
+interface AbstractSegment<T> {
+    val p1: T
+    val p2: T
+}
+
+@JvmInline
+value class DSegment(override val p1: DPoint, override val p2: DPoint): AbstractSegment<DPoint>
+
+fun <T> equal(expected: () -> T, actual: () -> T) {
+    val expectedResult = runCatching { expected() }
+    val actualResult = runCatching { actual() }
+    require(expectedResult == actualResult) { "Expected: $expectedResult\nActual: $actualResult" }
+}
+
+fun box(): String {
+    val dPoint = DPoint(1.0.my, 2.0.my)
+    equal({ dPoint.toString() }, { (dPoint as Any).toString() })
+
+    equal({ dPoint.equals(dPoint) }, { dPoint.equals(dPoint as Any) })
+    equal({ dPoint.equals(dPoint) }, { (dPoint as Any).equals(dPoint) })
+    equal({ dPoint.equals(dPoint) }, { dPoint.equals(dPoint as Any) })
+    equal({ dPoint.equals(dPoint) }, { (dPoint as Any).equals(dPoint as Any) })
+
+    val otherDPoint = DPoint(3.0.my, 4.0.my)
+    equal({ dPoint.equals(otherDPoint) }, { dPoint.equals(otherDPoint as Any) })
+    equal({ dPoint.equals(otherDPoint) }, { (dPoint as Any).equals(otherDPoint) })
+    equal({ dPoint.equals(otherDPoint) }, { dPoint.equals(otherDPoint as Any) })
+    equal({ dPoint.equals(otherDPoint) }, { (dPoint as Any).equals(otherDPoint as Any) })
+
+    equal({ dPoint.hashCode() }, { (dPoint as Any).hashCode() })
+
+    equal({ dPoint.x }, { (dPoint as AbstractPoint<MyDouble>).x })
+    equal({ dPoint.y }, { (dPoint as AbstractPoint<MyDouble>).y })
+
+
+    val realOverride = RealOverride(dPoint)
+
+    equal({ realOverride.p }, { (realOverride as GenericMFVCHolder<DPoint>).p })
+    equal({ realOverride.p1 }, { (realOverride as GenericMFVCHolder<DPoint>).p1 })
+    equal({ realOverride.p }, { (realOverride as ReifiedMFVCHolder).p })
+    equal({ realOverride.p1 }, { (realOverride as ReifiedMFVCHolder).p1 })
+    equal({ realOverride.p }, { (realOverride as GenericMFVCHolderWithMFVCUpperBound<DPoint>).p })
+    equal({ realOverride.p1 }, { (realOverride as GenericMFVCHolderWithMFVCUpperBound<DPoint>).p1 })
+
+    equal({ realOverride.p = dPoint }, { (realOverride as GenericMFVCHolder<DPoint>).p = dPoint })
+    equal({ realOverride.p1 = dPoint }, { (realOverride as GenericMFVCHolder<DPoint>).p1 = dPoint })
+    equal({ realOverride.p = dPoint }, { (realOverride as ReifiedMFVCHolder).p = dPoint })
+    equal({ realOverride.p1 = dPoint }, { (realOverride as ReifiedMFVCHolder).p1 = dPoint })
+    equal({ realOverride.p = dPoint }, { (realOverride as GenericMFVCHolderWithMFVCUpperBound<DPoint>).p = dPoint })
+    equal({ realOverride.p1 = dPoint }, { (realOverride as GenericMFVCHolderWithMFVCUpperBound<DPoint>).p1 = dPoint })
+
+
+    val genericFakeOverride = GenericFakeOverride()
+
+    equal({ genericFakeOverride.p }, { (genericFakeOverride as GenericMFVCHolderWithImpls<DPoint>).p })
+    equal({ genericFakeOverride.p1 }, { (genericFakeOverride as GenericMFVCHolderWithImpls<DPoint>).p1 })
+    val reifiedFakeOverride = ReifiedFakeOverride()
+    equal({ reifiedFakeOverride.p }, { (reifiedFakeOverride as ReifiedMFVCHolderWithImpls).p })
+    equal({ reifiedFakeOverride.p1 }, { (reifiedFakeOverride as ReifiedMFVCHolderWithImpls).p1 })
+    val genericFakeOverrideWithMFVCUpperBound = GenericFakeOverrideWithMFVCUpperBound()
+    equal(
+        { genericFakeOverrideWithMFVCUpperBound.p },
+        { (genericFakeOverrideWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls<DPoint>).p }
+    )
+    equal(
+        { genericFakeOverrideWithMFVCUpperBound.p1 },
+        { (genericFakeOverrideWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls<DPoint>).p1 }
+    )
+
+    equal({ genericFakeOverride.p = dPoint }, { (genericFakeOverride as GenericMFVCHolderWithImpls<DPoint>).p = dPoint })
+    equal({ genericFakeOverride.p1 = dPoint }, { (genericFakeOverride as GenericMFVCHolderWithImpls<DPoint>).p1 = dPoint })
+    equal({ reifiedFakeOverride.p = dPoint }, { (reifiedFakeOverride as ReifiedMFVCHolderWithImpls).p = dPoint })
+    equal({ reifiedFakeOverride.p1 = dPoint }, { (reifiedFakeOverride as ReifiedMFVCHolderWithImpls).p1 = dPoint })
+    equal(
+        { genericFakeOverrideWithMFVCUpperBound.p = dPoint },
+        { (genericFakeOverrideWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls<DPoint>).p = dPoint }
+    )
+    equal(
+        { genericFakeOverrideWithMFVCUpperBound.p1 = dPoint },
+        { (genericFakeOverrideWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls<DPoint>).p1 = dPoint }
+    )
+
+
+    val genericFakeOverrideMFVC = GenericFakeOverrideMFVC(1.0.my, 2.0.my)
+
+    equal({ genericFakeOverrideMFVC.p }, { (genericFakeOverrideMFVC as GenericMFVCHolderWithImpls<DPoint>).p })
+    equal({ genericFakeOverrideMFVC.p1 }, { (genericFakeOverrideMFVC as GenericMFVCHolderWithImpls<DPoint>).p1 })
+
+    val reifiedFakeOverrideMFVC = ReifiedFakeOverrideMFVC(1.0.my, 2.0.my)
+    equal({ reifiedFakeOverrideMFVC.p }, { (reifiedFakeOverrideMFVC as ReifiedMFVCHolderWithImpls).p })
+    equal({ reifiedFakeOverrideMFVC.p1 }, { (reifiedFakeOverrideMFVC as ReifiedMFVCHolderWithImpls).p1 })
+
+    val genericFakeOverrideMFVCWithMFVCUpperBound = GenericFakeOverrideMFVCWithMFVCUpperBound(1.0.my, 2.0.my)
+    equal(
+        { genericFakeOverrideMFVCWithMFVCUpperBound.p }, 
+        { (genericFakeOverrideMFVCWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls<DPoint>).p },
+    )
+    equal(
+        { genericFakeOverrideMFVCWithMFVCUpperBound.p1 },
+        { (genericFakeOverrideMFVCWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls<DPoint>).p1 },
+    )
+
+    equal({ genericFakeOverrideMFVC.p = dPoint }, { (genericFakeOverrideMFVC as GenericMFVCHolderWithImpls<DPoint>).p = dPoint })
+    equal({ genericFakeOverrideMFVC.p1 = dPoint }, { (genericFakeOverrideMFVC as GenericMFVCHolderWithImpls<DPoint>).p1 = dPoint })
+
+    equal({ reifiedFakeOverrideMFVC.p = dPoint }, { (reifiedFakeOverrideMFVC as ReifiedMFVCHolderWithImpls).p = dPoint })
+    equal({ reifiedFakeOverrideMFVC.p1 = dPoint }, { (reifiedFakeOverrideMFVC as ReifiedMFVCHolderWithImpls).p1 = dPoint })
+
+    equal(
+        { genericFakeOverrideMFVCWithMFVCUpperBound.p = dPoint }, 
+        { (genericFakeOverrideMFVCWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls<DPoint>).p = dPoint },
+    )
+    equal(
+        { genericFakeOverrideMFVCWithMFVCUpperBound.p1 = dPoint },
+        { (genericFakeOverrideMFVCWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls<DPoint>).p1 = dPoint },
+    )
+
+
+    val dPointWithInterface = DPointWithInterface(1.0.my, 2.0.my)
+
+    equal({ dPointWithInterface.somethingGeneric }, { (dPointWithInterface as SomePointInterface<DPoint>).somethingGeneric })
+    equal({ dPointWithInterface.somethingRegular }, { (dPointWithInterface as SomePointInterface<DPoint>).somethingRegular })
+    equal({ dPointWithInterface.somethingMFVC }, { (dPointWithInterface as SomePointInterface<DPoint>).somethingMFVC })
+
+    equal({ dPointWithInterface.somethingGeneric }, { (dPointWithInterface as SomePointInterfaceWithMFVCBound<DPoint>).somethingGeneric })
+    equal({ dPointWithInterface.somethingRegular }, { (dPointWithInterface as SomePointInterfaceWithMFVCBound<DPoint>).somethingRegular })
+    equal({ dPointWithInterface.somethingMFVC }, { (dPointWithInterface as SomePointInterfaceWithMFVCBound<DPoint>).somethingMFVC })
+
+    equal(
+        { dPointWithInterface.somethingGeneric = dPoint },
+        { (dPointWithInterface as SomePointInterface<DPoint>).somethingGeneric = dPoint }
+    )
+    equal({ dPointWithInterface.somethingRegular = 1 }, { (dPointWithInterface as SomePointInterface<DPoint>).somethingRegular = 1 })
+    equal({ dPointWithInterface.somethingMFVC = dPoint }, { (dPointWithInterface as SomePointInterface<DPoint>).somethingMFVC = dPoint })
+
+    equal(
+        { dPointWithInterface.somethingGeneric = dPoint }, 
+        { (dPointWithInterface as SomePointInterfaceWithMFVCBound<DPoint>).somethingGeneric = dPoint }
+    )
+    equal(
+        { dPointWithInterface.somethingRegular = 2 }, 
+        { (dPointWithInterface as SomePointInterfaceWithMFVCBound<DPoint>).somethingRegular = 2 }
+    )
+    equal(
+        { dPointWithInterface.somethingMFVC = dPoint},
+        { (dPointWithInterface as SomePointInterfaceWithMFVCBound<DPoint>).somethingMFVC = dPoint }
+    )
+
+
+    val dSegment = DSegment(dPoint, otherDPoint)
+    (dSegment as AbstractSegment<DPoint>).p1.x
+    
+    equal({ dPoint }, { dSegment.p1 })
+    equal({ otherDPoint }, { dSegment.p2 })
+    equal({ dPoint.x }, { dSegment.p1.x })
+    equal({ otherDPoint.x }, { dSegment.p2.x })
+    equal({ dPoint.y }, { dSegment.p1.y })
+    equal({ otherDPoint.y }, { dSegment.p2.y })
+    equal({ dSegment.p1 }, { (dSegment as AbstractSegment<DPoint>).p1 })
+    equal({ dSegment.p2 }, { (dSegment as AbstractSegment<DPoint>).p2 })
+    equal({ dSegment.p1.x }, { (dSegment as AbstractSegment<DPoint>).p1.x })
+    equal({ dSegment.p2.x }, { (dSegment as AbstractSegment<DPoint>).p2.x })
+    equal({ dSegment.p1.y }, { (dSegment as AbstractSegment<DPoint>).p1.y })
+    equal({ dSegment.p2.y }, { (dSegment as AbstractSegment<DPoint>).p2.y })
+
+    return "OK"
+}

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

@@ -2,6 +2,7 @@
 // TARGET_BACKEND: JVM_IR
 // WORKS_WHEN_VALUE_CLASS
 // LANGUAGE: +ValueClasses
+// CHECK_BYTECODE_LISTING
 
 @JvmInline
 value class DPoint(val x: Double, val y: Double)

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

@@ -0,0 +1,39 @@
+@kotlin.jvm.JvmInline
+@kotlin.Metadata
+public final class DPoint {
+    // source: 'throwingMFVCReassignments.kt'
+    private field x: double
+    private 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-impl0(): double
+    public synthetic final method unbox-impl1(): double
+}
+
+@kotlin.Metadata
+public final class PointBox {
+    // source: 'throwingMFVCReassignments.kt'
+    private field value$x: double
+    private field value$y: double
+    public method <init>(p0: double, p1: double): void
+    public final method getValue$x(): double
+    public final method getValue$y(): double
+    public final @org.jetbrains.annotations.NotNull method getValue(): DPoint
+    public final method setValue-sUp7gFk(p0: double, p1: double): void
+}
+
+@kotlin.Metadata
+public final class ThrowingMFVCReassignmentsKt {
+    // source: 'throwingMFVCReassignments.kt'
+    public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String
+}

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

@@ -43,7 +43,7 @@ fun functionWithoutBoxes(x: D, y: D) {
 // 2 INVOKESTATIC C.constructor-impl \(IILjava/lang/String;\)V
 // 1 public final getX\(\)LC;
 // 1 public final getX\$x\(\)I
-// 1 public final getX\$y\(\)I
+// 1 public final getX\$y-\w*\(\)I
 // 1 public final getX\$z\(\)Ljava/lang/String;
 // 2 private synthetic <init>\(IILjava/lang/String;\)V
 // 1 public final static synthetic box-impl\(IILjava/lang/String;\)LD;

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

@@ -50213,6 +50213,12 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
             runTest("compiler/testData/codegen/box/valueClasses/overrides.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
         }
 
+        @Test
+        @TestMetadata("overrides_inlineClass.kt")
+        public void testOverrides_inlineClass() throws Exception {
+            runTest("compiler/testData/codegen/box/valueClasses/overrides_inlineClass.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal());
+        }
+
         @Test
         @TestMetadata("throwingMFVCReassignments.kt")
         public void testThrowingMFVCReassignments() throws Exception {