From b7f5c039a6bab59d5d8d369c436e858fc8722797 Mon Sep 17 00:00:00 2001 From: "Evgeniy.Zhelenskiy" Date: Thu, 6 Oct 2022 20:45:45 +0000 Subject: [PATCH] rra/zhelenskiy/flattening_impl [IR] Remove unused MFVC getters Signed-off-by: Evgeniy.Zhelenskiy #KT-1179 [IR] Add context receivers test, fix a flattening fields bug Signed-off-by: Evgeniy.Zhelenskiy #KT-1179 [IR] Support `try` for MFVC #KT-1179 [IR] Support `if` and `when` for MFVC, fix several bugs, refactor #KT-1179 [IR] Rename MFVC tests + Add test for get-field optimization #KT-1179 [IR] Suppress temporary test failing on Android Bug is fixed in https://jetbrains.team/p/kt/reviews/6452 #KT-1179 [IR] Document the new MFVC lowering classes when necessary #KT-1179 [IR] Correct work of the new MFVC lowering classes #KT-1179 [IR] Prepare MFVC-lowering for the new MFVC classes #KT-1179 [IR] Fix MFVC with type arguments/parameters #KT-1179 [IR] Support MFVC with type parameters #KT-1179 [IR] Integrate MFVC with Inline classes #KT-1179 [IR] Fix compilation of MFVC in different module #KT-1179 [IR] Add MFVC generation tests #KT-1179 [IR] Implement equals call correct generation for MFVC #KT-1179 [IR] Implement bridges generation for MFVC #KT-1179 [IR] Implement MFVC basic flattening #KT-1179 Merge-request: KT-MR-6213 Merged-by: Evgeniy Zhelenskiy --- .../optimization/boxing/BoxingInterpreter.kt | 6 +- .../FirBlackBoxCodegenTestGenerated.java | 60 + .../codegen/FirBytecodeTextTestGenerated.java | 53 + .../backend/jvm/codegen/AnnotationCodegen.kt | 1 + .../backend/jvm/codegen/ExpressionCodegen.kt | 1 + .../kotlin/backend/jvm/intrinsics/HashCode.kt | 3 +- .../jetbrains/kotlin/backend/jvm/JvmLower.kt | 1 + .../backend/jvm/lower/BridgeLowering.kt | 161 +- ...nheritedDefaultMethodsOnClassesLowering.kt | 54 +- .../lower/JvmDefaultConstructorLowering.kt | 2 +- .../jvm/lower/JvmInlineClassLowering.kt | 153 +- .../lower/JvmMultiFieldValueClassLowering.kt | 1311 +++++++- .../jvm/lower/JvmPropertiesLowering.kt | 4 +- .../lower/JvmValueClassAbstractLowering.kt | 170 +- .../jvm/lower/SyntheticAccessorLowering.kt | 2 +- .../kotlin/backend/jvm/InlineClassAbi.kt | 33 +- .../kotlin/backend/jvm/JvmBackendContext.kt | 17 +- .../backend/jvm/JvmCachedDeclarations.kt | 5 +- .../jvm/JvmLoweredDeclarationOrigin.kt | 5 + .../jvm/MemoizedInlineClassReplacements.kt | 116 +- ...emoizedMultiFieldValueClassReplacements.kt | 297 +- .../MemoizedValueClassAbstractReplacements.kt | 103 +- .../jetbrains/kotlin/backend/jvm/MfvcNode.kt | 457 +++ .../kotlin/backend/jvm/MfvcNodeFactory.kt | 487 +++ .../kotlin/backend/jvm/MfvcNodeInstance.kt | 279 ++ .../kotlin/backend/jvm/ir/JvmIrTypeUtils.kt | 7 +- .../kotlin/backend/jvm/ir/JvmIrUtils.kt | 17 +- .../jvm/mapping/MethodSignatureMapper.kt | 2 +- .../kotlin/ir/builders/ExpressionHelpers.kt | 4 +- .../ir/declarations/IrDeclarationOrigin.kt | 3 + .../ir/util/DataClassMembersGenerator.kt | 2 +- .../box/valueClasses/classFlattening.kt | 149 +- .../box/valueClasses/classFlattening.txt | 175 ++ .../codegen/box/valueClasses/complex.kt | 304 ++ .../codegen/box/valueClasses/complex.txt | 317 ++ .../valueClasses/conditionalExpressions.kt | 53 + .../valueClasses/conditionalExpressions.txt | 49 + .../codegen/box/valueClasses/equality.kt | 3 + .../codegen/box/valueClasses/equality.txt | 217 ++ .../codegen/box/valueClasses/forStatement.kt | 16 + .../mfvcFieldInitializationOrder.kt | 27 + .../mfvcFieldInitializationOrder.txt | 59 + .../codegen/box/valueClasses/overrides.kt | 311 ++ .../codegen/box/valueClasses/overrides.txt | 2586 ++++++++++++++++ .../box/valueClasses/overrides_inlineClass.kt | 317 ++ .../valueClasses/overrides_inlineClass.txt | 2603 ++++++++++++++++ .../valueClasses/overrides_typeParameters.kt | 327 ++ .../valueClasses/overrides_typeParameters.txt | 2625 +++++++++++++++++ .../valueClasses/throwingMFVCReassignments.kt | 34 + .../throwingMFVCReassignments.txt | 37 + .../box/valueClasses/tryExpressions.kt | 43 + .../box/valueClasses/tryExpressions.txt | 29 + .../codegen/box/valueClasses/visibility.kt | 296 ++ .../codegen/box/valueClasses/visibility.txt | 780 +++++ .../valueClasses/conditionalExpressions.kt | 41 + .../valueClasses/equalsBoxTest.kt | 67 + .../valueClasses/mfvcDeclaration.kt | 76 + .../valueClasses/mfvcReassignments.kt | 71 + .../valueClasses/passingMFVC2Functions.kt | 49 + .../valueClasses/regularClassWithMFVC.kt | 144 + .../valueClasses/tryExpressions.kt | 38 + .../codegen/BytecodeTextTestGenerated.java | 11 + .../IrBlackBoxCodegenTestGenerated.java | 60 + .../codegen/IrBytecodeTextTestGenerated.java | 53 + 64 files changed, 15451 insertions(+), 332 deletions(-) create mode 100644 compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNode.kt create mode 100644 compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNodeFactory.kt create mode 100644 compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNodeInstance.kt create mode 100644 compiler/testData/codegen/box/valueClasses/classFlattening.txt create mode 100644 compiler/testData/codegen/box/valueClasses/complex.kt create mode 100644 compiler/testData/codegen/box/valueClasses/complex.txt create mode 100644 compiler/testData/codegen/box/valueClasses/conditionalExpressions.kt create mode 100644 compiler/testData/codegen/box/valueClasses/conditionalExpressions.txt create mode 100644 compiler/testData/codegen/box/valueClasses/equality.txt create mode 100644 compiler/testData/codegen/box/valueClasses/forStatement.kt create mode 100644 compiler/testData/codegen/box/valueClasses/mfvcFieldInitializationOrder.kt create mode 100644 compiler/testData/codegen/box/valueClasses/mfvcFieldInitializationOrder.txt create mode 100644 compiler/testData/codegen/box/valueClasses/overrides.kt create mode 100644 compiler/testData/codegen/box/valueClasses/overrides.txt create mode 100644 compiler/testData/codegen/box/valueClasses/overrides_inlineClass.kt create mode 100644 compiler/testData/codegen/box/valueClasses/overrides_inlineClass.txt create mode 100644 compiler/testData/codegen/box/valueClasses/overrides_typeParameters.kt create mode 100644 compiler/testData/codegen/box/valueClasses/overrides_typeParameters.txt create mode 100644 compiler/testData/codegen/box/valueClasses/throwingMFVCReassignments.kt create mode 100644 compiler/testData/codegen/box/valueClasses/throwingMFVCReassignments.txt create mode 100644 compiler/testData/codegen/box/valueClasses/tryExpressions.kt create mode 100644 compiler/testData/codegen/box/valueClasses/tryExpressions.txt create mode 100644 compiler/testData/codegen/box/valueClasses/visibility.kt create mode 100644 compiler/testData/codegen/box/valueClasses/visibility.txt create mode 100644 compiler/testData/codegen/bytecodeText/valueClasses/conditionalExpressions.kt create mode 100644 compiler/testData/codegen/bytecodeText/valueClasses/equalsBoxTest.kt create mode 100644 compiler/testData/codegen/bytecodeText/valueClasses/mfvcDeclaration.kt create mode 100644 compiler/testData/codegen/bytecodeText/valueClasses/mfvcReassignments.kt create mode 100644 compiler/testData/codegen/bytecodeText/valueClasses/passingMFVC2Functions.kt create mode 100644 compiler/testData/codegen/bytecodeText/valueClasses/regularClassWithMFVC.kt create mode 100644 compiler/testData/codegen/bytecodeText/valueClasses/tryExpressions.kt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxingInterpreter.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxingInterpreter.kt index 5b18f7bd2bb..816ac95141a 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxingInterpreter.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxingInterpreter.kt @@ -301,14 +301,16 @@ private fun MethodInsnNode.isInlineClassBoxingMethodDescriptor(state: Generation if (name != KotlinTypeMapper.BOX_JVM_METHOD_NAME) return false val ownerType = Type.getObjectType(owner) - return desc == Type.getMethodDescriptor(ownerType, unboxedTypeOfInlineClass(ownerType, state)) + val unboxedType = unboxedTypeOfInlineClass(ownerType, state) ?: return false + return desc == Type.getMethodDescriptor(ownerType, unboxedType) } private fun MethodInsnNode.isInlineClassUnboxingMethodDescriptor(state: GenerationState): Boolean { if (name != KotlinTypeMapper.UNBOX_JVM_METHOD_NAME) return false val ownerType = Type.getObjectType(owner) - return desc == Type.getMethodDescriptor(unboxedTypeOfInlineClass(ownerType, state)) + val unboxedType = unboxedTypeOfInlineClass(ownerType, state) ?: return false + return desc == Type.getMethodDescriptor(unboxedType) } fun AbstractInsnNode.isNextMethodCallOfProgressionIterator(values: List) = diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java index 9e441406cf8..b473a20fda2 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java @@ -50171,11 +50171,71 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT runTest("compiler/testData/codegen/box/valueClasses/classFlattening.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } + @Test + @TestMetadata("complex.kt") + public void testComplex() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/complex.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("conditionalExpressions.kt") + public void testConditionalExpressions() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/conditionalExpressions.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + @Test @TestMetadata("equality.kt") public void testEquality() throws Exception { runTest("compiler/testData/codegen/box/valueClasses/equality.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } + + @Test + @TestMetadata("forStatement.kt") + public void testForStatement() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/forStatement.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("mfvcFieldInitializationOrder.kt") + public void testMfvcFieldInitializationOrder() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/mfvcFieldInitializationOrder.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("overrides.kt") + public void testOverrides() throws Exception { + 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("overrides_typeParameters.kt") + public void testOverrides_typeParameters() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/overrides_typeParameters.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("throwingMFVCReassignments.kt") + public void testThrowingMFVCReassignments() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/throwingMFVCReassignments.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("tryExpressions.kt") + public void testTryExpressions() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/tryExpressions.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("visibility.kt") + public void testVisibility() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/visibility.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } } @Nested diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBytecodeTextTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBytecodeTextTestGenerated.java index ce3303b8985..c4bd88a01fa 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBytecodeTextTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBytecodeTextTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.test.runners.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.utils.TransformersFunctions; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; @@ -5779,6 +5780,58 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } } + @Nested + @TestMetadata("compiler/testData/codegen/bytecodeText/valueClasses") + @TestDataPath("$PROJECT_ROOT") + public class ValueClasses { + @Test + public void testAllFilesPresentInValueClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("conditionalExpressions.kt") + public void testConditionalExpressions() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/valueClasses/conditionalExpressions.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("equalsBoxTest.kt") + public void testEqualsBoxTest() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/valueClasses/equalsBoxTest.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("mfvcDeclaration.kt") + public void testMfvcDeclaration() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/valueClasses/mfvcDeclaration.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("mfvcReassignments.kt") + public void testMfvcReassignments() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/valueClasses/mfvcReassignments.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("passingMFVC2Functions.kt") + public void testPassingMFVC2Functions() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/valueClasses/passingMFVC2Functions.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("regularClassWithMFVC.kt") + public void testRegularClassWithMFVC() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/valueClasses/regularClassWithMFVC.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("tryExpressions.kt") + public void testTryExpressions() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/valueClasses/tryExpressions.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + } + @Nested @TestMetadata("compiler/testData/codegen/bytecodeText/varargs") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt index b3a89cfc0dd..caf15c4b8f7 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt @@ -346,6 +346,7 @@ abstract class AnnotationCodegen( declaration.origin.isSynthetic -> true declaration.origin == JvmLoweredDeclarationOrigin.INLINE_CLASS_GENERATED_IMPL_METHOD || + declaration.origin == JvmLoweredDeclarationOrigin.MULTI_FIELD_VALUE_CLASS_GENERATED_IMPL_METHOD || declaration.origin == IrDeclarationOrigin.GENERATED_SAM_IMPLEMENTATION -> true else -> diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt index 3e2253e62bd..cae3d0ae2b8 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt @@ -294,6 +294,7 @@ class ExpressionCodegen( (irFunction is IrConstructor && irFunction.parentAsClass.isAnonymousObject) || // TODO: Implement this as a lowering, so that we can more easily exclude generated methods. irFunction.origin == JvmLoweredDeclarationOrigin.INLINE_CLASS_GENERATED_IMPL_METHOD || + irFunction.origin == JvmLoweredDeclarationOrigin.MULTI_FIELD_VALUE_CLASS_GENERATED_IMPL_METHOD || // Although these are accessible from Java, the functions they bridge to already have the assertions. irFunction.origin == IrDeclarationOrigin.BRIDGE_SPECIAL || irFunction.origin == JvmLoweredDeclarationOrigin.SUPER_INTERFACE_METHOD_BRIDGE || diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/HashCode.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/HashCode.kt index 4233c25df5f..1333b221491 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/HashCode.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/HashCode.kt @@ -37,9 +37,10 @@ object HashCode : IntrinsicMethod() { val target = context.state.target when { irFunction.origin == JvmLoweredDeclarationOrigin.INLINE_CLASS_GENERATED_IMPL_METHOD || + irFunction.origin == JvmLoweredDeclarationOrigin.MULTI_FIELD_VALUE_CLASS_GENERATED_IMPL_METHOD || irFunction.origin == IrDeclarationOrigin.GENERATED_DATA_CLASS_MEMBER || irFunction.origin == IrDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_MEMBER -> { - // TODO generate or lower IR for data class / inline class 'hashCode'? + // TODO generate or lower IR for data class / value class 'hashCode'? DescriptorAsmUtil.genHashCode(mv, mv, receiverType, target) } target >= JvmTarget.JVM_1_8 && AsmUtil.isPrimitive(receiverJvmType) -> { diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/JvmLower.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/JvmLower.kt index d7ffe0f2f25..ca0fbf7d257 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/JvmLower.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/JvmLower.kt @@ -309,6 +309,7 @@ private val jvmFilePhases = listOf( forLoopsPhase, collectionStubMethodLowering, singleAbstractMethodPhase, + jvmMultiFieldValueClassPhase, jvmInlineClassPhase, tailrecPhase, // makePatchParentsPhase(), diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt index eb099727bfe..a1cd62c548e 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt @@ -11,9 +11,9 @@ import org.jetbrains.kotlin.backend.common.lower.VariableRemapper import org.jetbrains.kotlin.backend.common.lower.createIrBuilder import org.jetbrains.kotlin.backend.common.lower.irNot import org.jetbrains.kotlin.backend.common.phaser.makeIrFilePhase -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext -import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin -import org.jetbrains.kotlin.backend.jvm.SpecialBridge +import org.jetbrains.kotlin.backend.jvm.* +import org.jetbrains.kotlin.backend.jvm.MemoizedMultiFieldValueClassReplacements.RemappedParameter.MultiFieldValueClassMapping +import org.jetbrains.kotlin.backend.jvm.MemoizedMultiFieldValueClassReplacements.RemappedParameter.RegularMapping import org.jetbrains.kotlin.backend.jvm.ir.* import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.descriptors.DescriptorVisibilities @@ -32,6 +32,7 @@ import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.utils.SmartList import org.jetbrains.org.objectweb.asm.Type import org.jetbrains.org.objectweb.asm.commons.Method +import kotlin.collections.set /* * Generate bridge methods to fix virtual dispatch after type erasure and to adapt Kotlin collections to @@ -112,7 +113,7 @@ internal val bridgePhase = makeIrFilePhase( ::BridgeLowering, name = "Bridge", description = "Generate bridges", - prerequisite = setOf(jvmInlineClassPhase) + prerequisite = setOf(jvmInlineClassPhase, jvmMultiFieldValueClassPhase, inheritedDefaultMethodsOnClassesPhase) ) internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass, IrElementTransformerVoid() { @@ -234,6 +235,7 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass irClass.declarations.remove(irFunction) irClass.addAbstractMethodStub(irFunction) } + irFunction.modality != Modality.FINAL -> { // If we have a non-abstract, non-final fake-override we need to put in an additional bridge which uses // INVOKESPECIAL to call the special bridge implementation in the superclass. @@ -262,6 +264,7 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass irClass.addSpecialBridge(superBridge, superTarget) } } + else -> { // If the method is final, // then we will not override it in a subclass and we do not need to generate an additional stub method. @@ -431,6 +434,11 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass }.apply { copyAttributes(target) copyParametersWithErasure(this@addBridge, bridge.overridden) + with(context.multiFieldValueClassReplacements) { + bindingNewFunctionToParameterTemplateStructure[bridge.overridden]?.also { + bindingNewFunctionToParameterTemplateStructure[this@apply] = it + } + } // If target is a throwing stub, bridge also should just throw UnsupportedOperationException. // Otherwise, it might throw ClassCastException when downcasting bridge argument to expected type. @@ -486,6 +494,11 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass context.functionsWithSpecialBridges.add(target) copyParametersWithErasure(this@addSpecialBridge, specialBridge.overridden, specialBridge.substitutedParameterTypes) + with(context.multiFieldValueClassReplacements) { + bindingNewFunctionToParameterTemplateStructure[specialBridge.overridden]?.also { + bindingNewFunctionToParameterTemplateStructure[this@apply] = it + } + } body = context.createIrBuilder(symbol, startOffset, endOffset).irBlockBody { specialBridge.methodInfo?.let { info -> @@ -610,22 +623,132 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass target: IrSimpleFunction, superQualifierSymbol: IrClassSymbol? = null ) = - irCastIfNeeded( - irCall(target, origin = IrStatementOrigin.BRIDGE_DELEGATION, superQualifierSymbol = superQualifierSymbol).apply { - for ((param, targetParam) in bridge.explicitParameters.zip(target.explicitParameters)) { - putArgument( - targetParam, - irGet(param).let { argument -> - if (param == bridge.dispatchReceiverParameter) - argument - else - irCastIfNeeded(argument, targetParam.type.upperBound) - } - ) + irCastIfNeeded(irBlock { + +irReturn(irCall(target, origin = IrStatementOrigin.BRIDGE_DELEGATION, superQualifierSymbol = superQualifierSymbol).apply { + + val targetStructure = getStructure(target) + val bridgeStructure = getStructure(bridge) + + if (targetStructure == null && bridgeStructure == null) { + for ((param, targetParam) in bridge.explicitParameters.zip(target.explicitParameters)) { + putArgument(targetParam, irGetOrCast(bridge, param, targetParam)) + } + } else { + this@irBlock.addBoxedAndUnboxedMfvcArguments(targetStructure, bridgeStructure, target, bridge, this) } - }, - bridge.returnType.upperBound - ) + }) + }.unwrapBlock(), bridge.returnType.upperBound) + + private fun getStructure(function: IrSimpleFunction): List? { + val mfvcOrOriginal = context.inlineClassReplacements.originalFunctionForMethodReplacement[function] + ?: context.inlineClassReplacements.originalFunctionForStaticReplacement[function] + ?: function + val structure = context.multiFieldValueClassReplacements + .bindingNewFunctionToParameterTemplateStructure[mfvcOrOriginal] ?: return null + require(structure.sumOf { it.valueParameters.size } == function.explicitParametersCount) { + "Bad parameters structure: $structure" + } + + return structure + } + + private fun IrBlockBuilder.addBoxedAndUnboxedMfvcArguments( + targetStructure: List?, + bridgeStructure: List?, + target: IrSimpleFunction, + bridge: IrSimpleFunction, + irCall: IrCall + ) { + require( + targetStructure == null || bridgeStructure == null || + bridgeStructure.size == targetStructure.size && + (targetStructure zip bridgeStructure).none { (targetParameter, bridgeParameter) -> + targetParameter is MultiFieldValueClassMapping && bridgeParameter is MultiFieldValueClassMapping && + targetParameter.rootMfvcNode != bridgeParameter.rootMfvcNode + } + ) { "Incompatible structures: $bridgeStructure and $targetStructure" } + + val targetExplicitParameters = target.explicitParameters + val bridgeExplicitParameters = bridge.explicitParameters + var targetIndex = 0 + var bridgeIndex = 0 + var structureIndex = 0 + while (targetIndex < targetExplicitParameters.size && bridgeIndex < bridgeExplicitParameters.size) { + val targetRemappedParameter = targetStructure?.get(structureIndex) + val bridgeRemappedParameter = bridgeStructure?.get(structureIndex) + when (targetRemappedParameter) { + is MultiFieldValueClassMapping -> when (bridgeRemappedParameter) { + is MultiFieldValueClassMapping -> { + require(bridgeRemappedParameter.rootMfvcNode == targetRemappedParameter.rootMfvcNode) { + "Incompatible parameters: $bridgeRemappedParameter, $targetRemappedParameter" + } + repeat(bridgeRemappedParameter.valueParameters.size) { + val bridgeParameter = bridgeExplicitParameters[bridgeIndex++] + val targetParameter = targetExplicitParameters[targetIndex++] + irCall.putArgument(targetParameter, irGetOrCast(bridge, bridgeParameter, targetParameter)) + } + } + + is RegularMapping, null -> { + val bridgeParameter = bridgeExplicitParameters[bridgeIndex++] + val targetParameterType = targetRemappedParameter.rootMfvcNode.mfvc.defaultType + val instance = targetRemappedParameter.rootMfvcNode.createInstanceFromBox( + this, + irCastIfNeeded(irGet(bridgeParameter), targetParameterType), + getOptimizedPublicAccess(target, targetRemappedParameter.rootMfvcNode.mfvc) + ) { error("Not applicable") } + val newArguments = instance.makeFlattenedGetterExpressions(this) + for (newArgument in newArguments) { + irCall.putArgument(targetExplicitParameters[targetIndex++], newArgument) + } + } + } + + is RegularMapping, null -> { + val targetParameter = targetExplicitParameters[targetIndex] + when (bridgeRemappedParameter) { + is MultiFieldValueClassMapping -> { + val valueArguments = List(bridgeRemappedParameter.rootMfvcNode.leavesCount) { + irGet(bridgeExplicitParameters[bridgeIndex++]) + } + val boxCall = bridgeRemappedParameter.rootMfvcNode.makeBoxedExpression( + this, bridgeRemappedParameter.typeArguments, valueArguments + ) + irCall.putArgument(targetParameter, irCastIfNeeded(boxCall, targetParameter.type.upperBound)) + } + + is RegularMapping, null -> { + val bridgeParameter = bridgeExplicitParameters[bridgeIndex++] + irCall.putArgument(targetParameter, irGetOrCast(bridge, bridgeParameter, targetParameter)) + } + } + targetIndex++ + } + } + structureIndex++ + } + require(targetIndex == targetExplicitParameters.size && bridgeIndex == bridgeExplicitParameters.size) { + "Incorrect bridge:\n${bridge.dump()}\n\nfor target\n${target.dump()}" + } + require((targetStructure == null || structureIndex == targetStructure.size)) { + "Invalid structure index $structureIndex for $targetStructure" + } + require((bridgeStructure == null || structureIndex == bridgeStructure.size)) { + "Invalid structure index $structureIndex for $bridgeStructure" + } + } + + private fun IrBuilderWithScope.irGetOrCast( + bridge: IrSimpleFunction, + bridgeParameter: IrValueParameter, + targetParameter: IrValueParameter + ) = + irGet(bridgeParameter).let { argument -> + if (bridgeParameter == bridge.dispatchReceiverParameter) + argument + else + irCastIfNeeded(argument, targetParameter.type.upperBound) + } private fun IrBuilderWithScope.irCastIfNeeded(expression: IrExpression, to: IrType): IrExpression = if (expression.type == to || to.isAny() || to.isNullableAny()) expression else irImplicitCast(expression, to) diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InheritedDefaultMethodsOnClassesLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InheritedDefaultMethodsOnClassesLowering.kt index 120cae230f1..c82836a7760 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InheritedDefaultMethodsOnClassesLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/InheritedDefaultMethodsOnClassesLowering.kt @@ -12,7 +12,11 @@ import org.jetbrains.kotlin.backend.common.lower.createIrBuilder import org.jetbrains.kotlin.backend.common.phaser.makeIrFilePhase import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin +import org.jetbrains.kotlin.backend.jvm.MemoizedMultiFieldValueClassReplacements.RemappedParameter.MultiFieldValueClassMapping +import org.jetbrains.kotlin.backend.jvm.MemoizedMultiFieldValueClassReplacements.RemappedParameter.RegularMapping +import org.jetbrains.kotlin.backend.jvm.fullValueParameterList import org.jetbrains.kotlin.backend.jvm.ir.* +import org.jetbrains.kotlin.backend.jvm.makeBoxedExpression import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.config.JvmDefaultMode import org.jetbrains.kotlin.descriptors.DescriptorVisibilities @@ -91,6 +95,7 @@ private class InheritedDefaultMethodsOnClassesLowering(val context: JvmBackendCo val superClassType = superMethod.parentAsClass.defaultType val defaultImplFun = context.cachedDeclarations.getDefaultImplsFunction(superMethod) val classStartOffset = classOverride.parentAsClass.startOffset + val backendContext = context context.createIrBuilder(irFunction.symbol, classStartOffset, classStartOffset).apply { irFunction.body = irBlockBody { +irReturn( @@ -100,15 +105,50 @@ private class InheritedDefaultMethodsOnClassesLowering(val context: JvmBackendCo } passTypeArgumentsFrom(irFunction, offset = superMethod.parentAsClass.typeParameters.size) - var offset = 0 irFunction.dispatchReceiverParameter?.let { - putValueArgument( - offset++, - irGet(it).reinterpretAsDispatchReceiverOfType(superClassType) - ) + putValueArgument(0, irGet(it).reinterpretAsDispatchReceiverOfType(superClassType)) + } + val mfvcOrOriginal = backendContext.inlineClassReplacements.originalFunctionForMethodReplacement[classOverride] + ?: classOverride + val bindingNewFunctionToParameterTemplateStructure = backendContext.multiFieldValueClassReplacements + .bindingNewFunctionToParameterTemplateStructure + val structure = bindingNewFunctionToParameterTemplateStructure[mfvcOrOriginal]?.let { structure -> + require(structure.sumOf { it.valueParameters.size } == classOverride.explicitParametersCount) { + "Bad parameters structure: $structure" + } + if (defaultImplFun.explicitParametersCount == irFunction.explicitParametersCount) { + null + } else { + require(structure.size == defaultImplFun.explicitParametersCount) { "Bad parameters structure: $structure" } + structure + } + } + require(structure == null || structure.first() is RegularMapping) { + "Dispatch receiver for method replacement cannot be flattened" + } + val sourceFullValueParameterList = irFunction.fullValueParameterList + if (structure == null) { + for ((index, parameter) in sourceFullValueParameterList.withIndex()) { + putValueArgument(1 + index, irGet(parameter)) + } + } else { + var flattenedIndex = 0 + for (i in 1 until structure.size) { + when (val remappedParameter = structure[i]) { + is MultiFieldValueClassMapping -> { + val valueArguments = remappedParameter.valueParameters.indices.map { + irGet(sourceFullValueParameterList[flattenedIndex++]) + } + val boxedExpression = remappedParameter.rootMfvcNode.makeBoxedExpression( + this@irBlockBody, remappedParameter.typeArguments, valueArguments + ) + putValueArgument(i, boxedExpression) + } + + is RegularMapping -> putValueArgument(i, irGet(sourceFullValueParameterList[flattenedIndex++])) + } + } } - irFunction.extensionReceiverParameter?.let { putValueArgument(offset++, irGet(it)) } - irFunction.valueParameters.mapIndexed { i, parameter -> putValueArgument(i + offset, irGet(parameter)) } } ) } diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmDefaultConstructorLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmDefaultConstructorLowering.kt index f7abcb4d358..75f87f0a1e7 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmDefaultConstructorLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmDefaultConstructorLowering.kt @@ -47,7 +47,7 @@ private class JvmDefaultConstructorLowering(val context: JvmBackendContext) : Cl if (DescriptorVisibilities.isPrivate(primaryConstructor.visibility)) return - if (primaryConstructor.hasMangledParameters) + if (primaryConstructor.hasMangledParameters()) return if (primaryConstructor.valueParameters.isEmpty() || !primaryConstructor.valueParameters.all { it.hasDefaultValue() }) diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt index 500a8c65f83..78552284b1d 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmInlineClassLowering.kt @@ -9,8 +9,6 @@ import org.jetbrains.kotlin.backend.common.lower.createIrBuilder import org.jetbrains.kotlin.backend.common.lower.irBlockBody import org.jetbrains.kotlin.backend.common.lower.loops.forLoopsPhase import org.jetbrains.kotlin.backend.common.phaser.makeIrFilePhase -import org.jetbrains.kotlin.backend.common.pop -import org.jetbrains.kotlin.backend.common.push import org.jetbrains.kotlin.backend.jvm.* import org.jetbrains.kotlin.backend.jvm.ir.erasedUpperBound import org.jetbrains.kotlin.builtins.StandardNames @@ -24,6 +22,7 @@ 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.* +import org.jetbrains.kotlin.ir.symbols.IrValueSymbol import org.jetbrains.kotlin.ir.transformStatement import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.types.classOrNull @@ -31,7 +30,6 @@ import org.jetbrains.kotlin.ir.types.isNullable import org.jetbrains.kotlin.ir.types.makeNotNull import org.jetbrains.kotlin.ir.util.* import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid -import org.jetbrains.kotlin.load.java.JvmAbi import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.JVM_INLINE_ANNOTATION_FQ_NAME @@ -43,7 +41,9 @@ val jvmInlineClassPhase = makeIrFilePhase( // Standard library replacements are done on the unmangled names for UInt and ULong classes. // Collection stubs may require mangling by inline class rules. // SAM wrappers may require mangling for fun interfaces with inline class parameters - prerequisite = setOf(forLoopsPhase, jvmBuiltInsPhase, collectionStubMethodLowering, singleAbstractMethodPhase), + prerequisite = setOf( + forLoopsPhase, jvmBuiltInsPhase, collectionStubMethodLowering, singleAbstractMethodPhase, jvmMultiFieldValueClassPhase + ), ) /** @@ -58,73 +58,15 @@ private class JvmInlineClassLowering(context: JvmBackendContext) : JvmValueClass override val replacements: MemoizedValueClassAbstractReplacements get() = context.inlineClassReplacements - override fun IrClass.isSpecificLoweringLogicApplicable(): Boolean = isSingleFieldValueClass + private val valueMap = mutableMapOf() - override fun IrFunction.isSpecificFieldGetter(): Boolean = isInlineClassFieldGetter - - override fun addJvmInlineAnnotation(valueClass: IrClass) { - if (valueClass.hasAnnotation(JVM_INLINE_ANNOTATION_FQ_NAME)) return - val constructor = context.ir.symbols.jvmInlineAnnotation.constructors.first() - valueClass.annotations = valueClass.annotations + IrConstructorCallImpl.fromSymbolOwner( - constructor.owner.returnType, - constructor - ) + override fun addBindingsFor(original: IrFunction, replacement: IrFunction) { + for ((param, newParam) in original.explicitParameters.zip(replacement.explicitParameters)) { + valueMap[param.symbol] = newParam + } } - override fun transformSimpleFunctionFlat(function: IrSimpleFunction, replacement: IrSimpleFunction): List { - replacement.valueParameters.forEach { - it.transformChildrenVoid() - it.defaultValue?.patchDeclarationParents(replacement) - } - allScopes.push(createScope(function)) - replacement.body = function.body?.transform(this, null)?.patchDeclarationParents(replacement) - allScopes.pop() - replacement.copyAttributes(function) - - // Don't create a wrapper for functions which are only used in an unboxed context - if (function.overriddenSymbols.isEmpty() || replacement.dispatchReceiverParameter != null) - return listOf(replacement) - - val bridgeFunction = createBridgeDeclaration( - function, - when { - // If the original function has signature which need mangling we still need to replace it with a mangled version. - (!function.isFakeOverride || function.findInterfaceImplementation(context.state.jvmDefaultMode) != null) && - function.signatureRequiresMangling() -> - replacement.name - // Since we remove the corresponding property symbol from the bridge we need to resolve getter/setter - // names at this point. - replacement.isGetter -> - Name.identifier(JvmAbi.getterName(replacement.correspondingPropertySymbol!!.owner.name.asString())) - replacement.isSetter -> - Name.identifier(JvmAbi.setterName(replacement.correspondingPropertySymbol!!.owner.name.asString())) - else -> - function.name - } - ) - - // Update the overridden symbols to point to their inline class replacements - bridgeFunction.overriddenSymbols = replacement.overriddenSymbols - - // Replace the function body with a wrapper - if (bridgeFunction.isFakeOverride && bridgeFunction.parentAsClass.isSingleFieldValueClass) { - // Fake overrides redirect from the replacement to the original function, which is in turn replaced during interfacePhase. - createBridgeBody(replacement, bridgeFunction) - } else { - createBridgeBody(bridgeFunction, replacement) - } - - return listOf(replacement, bridgeFunction) - } - - private fun IrSimpleFunction.signatureRequiresMangling() = - fullValueParameterList.any { it.type.requiresMangling } || - context.state.functionsWithInlineClassReturnTypesMangled && returnType.requiresMangling - - // We may need to add a bridge method for inline class methods with static replacements. Ideally, we'd do this in BridgeLowering, - // but unfortunately this is a special case in the old backend. The bridge method is not marked as such and does not follow the normal - // visibility rules for bridge methods. - private fun createBridgeDeclaration(source: IrSimpleFunction, mangledName: Name) = + override fun createBridgeDeclaration(source: IrSimpleFunction, replacement: IrSimpleFunction, mangledName: Name): IrSimpleFunction = context.irFactory.buildFun { updateFrom(source) name = mangledName @@ -139,7 +81,59 @@ private class JvmInlineClassLowering(context: JvmBackendContext) : JvmValueClass copyAttributes(source) } - private fun createBridgeBody(source: IrSimpleFunction, target: IrSimpleFunction) { + override fun IrClass.isSpecificLoweringLogicApplicable(): Boolean = isSingleFieldValueClass + + override val specificMangle: SpecificMangle + get() = SpecificMangle.Inline + + override fun visitClassNew(declaration: IrClass): IrStatement { + // The arguments to the primary constructor are in scope in the initializers of IrFields. + + declaration.primaryConstructor?.let { + replacements.getReplacementFunction(it)?.let { replacement -> addBindingsFor(it, replacement) } + } + + declaration.transformDeclarationsFlat { memberDeclaration -> + if (memberDeclaration is IrFunction) { + withinScope(memberDeclaration) { + transformFunctionFlat(memberDeclaration) + } + } else { + memberDeclaration.accept(this, null) + null + } + } + + if (declaration.isSpecificLoweringLogicApplicable()) { + handleSpecificNewClass(declaration) + } + + return declaration + } + + override fun handleSpecificNewClass(declaration: IrClass) { + val irConstructor = declaration.primaryConstructor!! + // The field getter is used by reflection and cannot be removed here unless it is internal. + declaration.declarations.removeIf { + it == irConstructor || (it is IrFunction && it.isInlineClassFieldGetter && !it.visibility.isPublicAPI) + } + buildPrimaryInlineClassConstructor(declaration, irConstructor) + buildBoxFunction(declaration) + buildUnboxFunction(declaration) + buildSpecializedEqualsMethod(declaration) + addJvmInlineAnnotation(declaration) + } + + fun addJvmInlineAnnotation(valueClass: IrClass) { + if (valueClass.hasAnnotation(JVM_INLINE_ANNOTATION_FQ_NAME)) return + val constructor = context.ir.symbols.jvmInlineAnnotation.constructors.first() + valueClass.annotations = valueClass.annotations + IrConstructorCallImpl.fromSymbolOwner( + constructor.owner.returnType, + constructor + ) + } + + override fun createBridgeBody(source: IrSimpleFunction, target: IrSimpleFunction, original: IrFunction, inverted: Boolean) { source.body = context.createIrBuilder(source.symbol, source.startOffset, source.endOffset).run { irExprBody(irCall(target).apply { passTypeArgumentsFrom(source) @@ -153,7 +147,7 @@ private class JvmInlineClassLowering(context: JvmBackendContext) : JvmValueClass // Secondary constructors for boxed types get translated to static functions returning // unboxed arguments. We remove the original constructor. // Primary constructors' case is handled at the start of transformFunctionFlat - override fun transformConstructorFlat(constructor: IrConstructor, replacement: IrSimpleFunction): List { + override fun transformSecondaryConstructorFlat(constructor: IrConstructor, replacement: IrSimpleFunction): List { replacement.valueParameters.forEach { it.transformChildrenVoid() } replacement.body = context.createIrBuilder(replacement.symbol, replacement.startOffset, replacement.endOffset).irBlockBody( replacement @@ -211,12 +205,6 @@ private class JvmInlineClassLowering(context: JvmBackendContext) : JvmValueClass return listOf(replacement) } - private fun typedArgumentList(function: IrFunction, expression: IrMemberAccessExpression<*>) = - listOfNotNull( - function.dispatchReceiverParameter?.let { it to expression.dispatchReceiver }, - function.extensionReceiverParameter?.let { it to expression.extensionReceiver } - ) + function.valueParameters.map { it to expression.getValueArgument(it.index) } - private fun IrMemberAccessExpression<*>.buildReplacement( originalFunction: IrFunction, original: IrMemberAccessExpression<*>, @@ -287,6 +275,8 @@ private class JvmInlineClassLowering(context: JvmBackendContext) : JvmValueClass private fun IrExpression.coerceToUnboxed() = coerceInlineClasses(this, this.type, this.type.unboxInlineClass()) + override fun keepOldFunctionInsteadOfNew(function: IrFunction): Boolean = false + // Precondition: left has an inline class type, but may not be unboxed private fun IrBuilderWithScope.specializeEqualsCall(left: IrExpression, right: IrExpression): IrExpression? { // There's already special handling for null-comparisons in the Equals intrinsic. @@ -363,6 +353,7 @@ private class JvmInlineClassLowering(context: JvmBackendContext) : JvmValueClass .specializeEqualsCall(expression.getValueArgument(0)!!, expression.getValueArgument(1)!!) ?: expression } + else -> super.visitCall(expression) } @@ -420,7 +411,7 @@ private class JvmInlineClassLowering(context: JvmBackendContext) : JvmValueClass return super.visitSetValue(expression) } - override fun buildPrimaryValueClassConstructor(valueClass: IrClass, irConstructor: IrConstructor) { + fun buildPrimaryInlineClassConstructor(valueClass: IrClass, irConstructor: IrConstructor) { // Add the default primary constructor valueClass.addConstructor { updateFrom(irConstructor) @@ -465,7 +456,7 @@ private class JvmInlineClassLowering(context: JvmBackendContext) : JvmValueClass valueClass.declarations += function } - override fun buildBoxFunction(valueClass: IrClass) { + fun buildBoxFunction(valueClass: IrClass) { val function = context.inlineClassReplacements.getBoxFunction(valueClass) with(context.createIrBuilder(function.symbol)) { function.body = irExprBody( @@ -478,10 +469,6 @@ private class JvmInlineClassLowering(context: JvmBackendContext) : JvmValueClass valueClass.declarations += function } - override fun buildUnboxFunctions(valueClass: IrClass) { - buildUnboxFunction(valueClass) - } - private fun buildUnboxFunction(irClass: IrClass) { val function = context.inlineClassReplacements.getUnboxFunction(irClass) val field = getInlineClassBackingField(irClass) @@ -494,7 +481,7 @@ private class JvmInlineClassLowering(context: JvmBackendContext) : JvmValueClass irClass.declarations += function } - override fun buildSpecializedEqualsMethod(valueClass: IrClass) { + fun buildSpecializedEqualsMethod(valueClass: IrClass) { val function = context.inlineClassReplacements.getSpecializedEqualsMethod(valueClass, context.irBuiltIns) val left = function.valueParameters[0] val right = function.valueParameters[1] diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmMultiFieldValueClassLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmMultiFieldValueClassLowering.kt index 3342d36be91..28d7122f7a4 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmMultiFieldValueClassLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmMultiFieldValueClassLowering.kt @@ -5,45 +5,646 @@ package org.jetbrains.kotlin.backend.jvm.lower -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext -import org.jetbrains.kotlin.backend.jvm.MemoizedValueClassAbstractReplacements -import org.jetbrains.kotlin.backend.jvm.isMultiFieldValueClassFieldGetter +import org.jetbrains.kotlin.backend.common.lower.MethodsFromAnyGeneratorForLowerings.Companion.isEquals +import org.jetbrains.kotlin.backend.common.lower.MethodsFromAnyGeneratorForLowerings.Companion.isToString +import org.jetbrains.kotlin.backend.common.lower.createIrBuilder +import org.jetbrains.kotlin.backend.common.lower.irCatch +import org.jetbrains.kotlin.backend.common.phaser.makeIrFilePhase +import org.jetbrains.kotlin.backend.common.pop +import org.jetbrains.kotlin.backend.common.push +import org.jetbrains.kotlin.backend.jvm.* +import org.jetbrains.kotlin.backend.jvm.MemoizedMultiFieldValueClassReplacements.RemappedParameter +import org.jetbrains.kotlin.backend.jvm.MemoizedMultiFieldValueClassReplacements.RemappedParameter.MultiFieldValueClassMapping +import org.jetbrains.kotlin.backend.jvm.MemoizedMultiFieldValueClassReplacements.RemappedParameter.RegularMapping +import org.jetbrains.kotlin.backend.jvm.ir.createJvmIrBuilder +import org.jetbrains.kotlin.backend.jvm.ir.erasedUpperBound +import org.jetbrains.kotlin.backend.jvm.lower.BlockOrBody.Block +import org.jetbrains.kotlin.ir.IrElement +import org.jetbrains.kotlin.ir.IrStatement +import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET +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.symbols.IrSymbol +import org.jetbrains.kotlin.ir.symbols.IrValueSymbol +import org.jetbrains.kotlin.ir.symbols.impl.IrAnonymousInitializerSymbolImpl +import org.jetbrains.kotlin.ir.transformStatement +import org.jetbrains.kotlin.ir.types.* +import org.jetbrains.kotlin.ir.util.* +import org.jetbrains.kotlin.ir.visitors.* +import org.jetbrains.kotlin.name.Name + +val jvmMultiFieldValueClassPhase = makeIrFilePhase( + ::JvmMultiFieldValueClassLowering, + name = "Multi-field Value Classes", + description = "Lower multi-field value classes", + // Collection stubs may require mangling by multi-field value class rules. + // SAM wrappers may require mangling for fun interfaces with multi-field value class parameters + prerequisite = setOf(collectionStubMethodLowering, singleAbstractMethodPhase), +) private class JvmMultiFieldValueClassLowering(context: JvmBackendContext) : JvmValueClassAbstractLowering(context) { - override val replacements: MemoizedValueClassAbstractReplacements + private sealed class MfvcNodeInstanceAccessor { + abstract val instance: MfvcNodeInstance + abstract operator fun get(name: Name): MfvcNodeInstanceAccessor? + data class Getter(override val instance: MfvcNodeInstance) : MfvcNodeInstanceAccessor() { + override operator fun get(name: Name): Getter? = instance[name]?.let { Getter(it) } + } + + data class Setter(override val instance: MfvcNodeInstance, val values: List) : MfvcNodeInstanceAccessor() { + override operator fun get(name: Name): Setter? = instance[name]?.let { + val indices = (instance as MfvcNodeWithSubnodes).subnodeIndices[it.node]!! + Setter(it, values.slice(indices)) + } + } + } + + /** + * The class is used to get replacing expression and MFVC instance if present for the given old value declaration. + */ + private inner class ValueDeclarationRemapper { + + private val expression2MfvcNodeInstanceAccessor = mutableMapOf() + private val oldSymbol2MfvcNodeInstance = mutableMapOf() + private val oldValueSymbol2NewValueSymbol = mutableMapOf() + + /** + * Registers one-to-one replacement + */ + fun registerReplacement(original: IrValueDeclaration, replacement: IrValueDeclaration) { + oldValueSymbol2NewValueSymbol[original.symbol] = replacement.symbol + } + + /** + * Registers replacement of a simple expression with flattened MFVC instance + */ + fun registerReplacement(original: IrValueDeclaration, replacement: ValueDeclarationMfvcNodeInstance) { + oldSymbol2MfvcNodeInstance[original.symbol] = replacement + } + + 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) + expression2MfvcNodeInstanceAccessor[res] = MfvcNodeInstanceAccessor.Getter(instance) + return res + } + + private fun splitExpressions(expressions: List): Pair, List> { + val repeatable = expressions.takeLastWhile { it.isRepeatableGetter() } + return expressions.subList(0, expressions.size - repeatable.size) to repeatable + } + + fun IrBlockBuilder.addReplacement(expression: IrSetValue, safe: Boolean): IrExpression? { + oldValueSymbol2NewValueSymbol[expression.symbol]?.let { return irSet(it.owner, expression.value) } + val instance = oldSymbol2MfvcNodeInstance[expression.symbol] ?: return null + val values: List = makeFlattenedExpressionsWithGivenSafety(instance.node, safe, expression.value) + val setterExpressions = instance.makeSetterExpressions(this, values) + expression2MfvcNodeInstanceAccessor[setterExpressions] = MfvcNodeInstanceAccessor.Setter(instance, values) + +setterExpressions + return setterExpressions + } + + /** + * @param safe whether protect from partial (because of a potential exception) initialization or not + */ + private fun IrBlockBuilder.makeFlattenedExpressionsWithGivenSafety( + node: MfvcNode, safe: Boolean, expression: IrExpression + ) = if (safe) { + val (forVariables, rest) = splitExpressions(flattenExpression(expression)) + val variables = when (node) { + is LeafMfvcNode -> forVariables.map { expr -> irTemporary(expr) } + is MfvcNodeWithSubnodes -> forVariables.zip(node.leaves) { expr, leaf -> + irTemporary(expr, nameHint = leaf.fullFieldName.asString()) + } + } + variables.map { irGet(it) } + rest + } else { + flattenExpression(expression) + } + + private val IrFieldAccessExpression.field: IrField + get() = this.symbol.owner + + fun IrBlockBuilder.addReplacement(expression: IrGetField): IrExpression? { + val property = expression.field.property ?: return null + expression.receiver?.get(this, property.name)?.let { +it; return it } + val node = replacements.getMfvcPropertyNode(property) ?: return null + val typeArguments = makeTypeArgumentsFromField(expression) + val instance: ReceiverBasedMfvcNodeInstance = + node.createInstanceFromBox(this, typeArguments, expression.receiver, AccessType.AlwaysPrivate, ::variablesSaver) + val getterExpression = instance.makeGetterExpression(this) + expression2MfvcNodeInstanceAccessor[getterExpression] = MfvcNodeInstanceAccessor.Getter(instance) + +getterExpression + return getterExpression + } + + fun IrBlockBuilder.addReplacement(expression: IrSetField, safe: Boolean): IrExpression? { + val property = expression.field.property ?: return null + expression.receiver?.get(this, property.name)?.let { +it; return it } + val node = replacements.getMfvcPropertyNode(property) ?: return null + val typeArguments = makeTypeArgumentsFromField(expression) + val instance: ReceiverBasedMfvcNodeInstance = + node.createInstanceFromBox(this, typeArguments, expression.receiver, AccessType.AlwaysPrivate, ::variablesSaver) + val values: List = makeFlattenedExpressionsWithGivenSafety(node, safe, expression.value) + val setterExpressions = instance.makeSetterExpressions(this, values) + expression2MfvcNodeInstanceAccessor[setterExpressions] = MfvcNodeInstanceAccessor.Setter(instance, values) + +setterExpressions + return setterExpressions + } + + fun IrBlockBuilder.addReplacement(expression: IrCall): IrExpression? { + val function = expression.symbol.owner + val property = function.property?.takeIf { function.isGetter } ?: return null + val dispatchReceiver = expression.dispatchReceiver + dispatchReceiver?.get(this, property.name)?.let { +it; return it } + 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) + val getterExpression = instance.makeGetterExpression(this) + expression2MfvcNodeInstanceAccessor[getterExpression] = MfvcNodeInstanceAccessor.Getter(instance) + +getterExpression + return getterExpression + } + + private fun makeTypeArgumentsFromField(expression: IrFieldAccessExpression) = buildMap { + val field = expression.symbol.owner + putAll(makeTypeArgumentsFromType(field.type as IrSimpleType)) + expression.receiver?.type?.let { putAll(makeTypeArgumentsFromType(it as IrSimpleType)) } + } + + private fun makeTypeArgumentsFromFunction(expression: IrCall) = buildMap { + val function = expression.symbol.owner + putAll(makeTypeArgumentsFromType(function.returnType as IrSimpleType)) + expression.dispatchReceiver?.type?.let { putAll(makeTypeArgumentsFromType(it as IrSimpleType)) } + } + + private inline fun IrBuilderWithScope.irContainer(oldBlock: IrContainerExpression, builder: IrBlockBuilder.() -> Unit) = + oldBlock.run { + if (isTransparentScope) irComposite(startOffset, endOffset, origin, body = builder) + else irBlock(startOffset, endOffset, origin, body = builder) + } + + private fun IrBuilderWithScope.handleSavedExpression( + expression: IrExpression, handler: IrBuilderWithScope.(accessor: MfvcNodeInstanceAccessor) -> IrExpression? + ): IrExpression? { + val accessor = expression2MfvcNodeInstanceAccessor[expression] + return when { + accessor != null -> handler(accessor) ?: return null + expression !is IrContainerExpression -> null + else -> when (val lastExpression = expression.statements.lastOrNull()) { + is IrExpression -> irContainer(expression) { + val inner = handleSavedExpression(lastExpression, handler) ?: return null + for (oldStatement in expression.statements.dropLast(1)) { + +oldStatement + } + +inner + } + + else -> null + } + } + } + + fun IrExpression.get(scope: IrBuilderWithScope, name: Name): IrExpression? = scope.handleSavedExpression(this) { accessor -> + val newAccessor = accessor[name] ?: return@handleSavedExpression null + val expression = when (newAccessor) { + is MfvcNodeInstanceAccessor.Getter -> newAccessor.instance.makeGetterExpression(scope) + is MfvcNodeInstanceAccessor.Setter -> newAccessor.instance.makeSetterExpressions(scope, newAccessor.values) + } + expression2MfvcNodeInstanceAccessor[expression] = newAccessor + expression + } + + fun handleFlattenedGetterExpressions( + scope: IrBuilderWithScope, + expression: IrExpression, + handler: IrBlockBuilder.(values: List) -> IrExpression + ): IrExpression? = + scope.handleSavedExpression(expression) { irBlock { +handler(it.instance.makeFlattenedGetterExpressions(this)) } } + + fun registerReplacement(expression: IrExpression, instance: MfvcNodeInstance) { + expression2MfvcNodeInstanceAccessor[expression] = MfvcNodeInstanceAccessor.Getter(instance) + } + } + + private val IrField.property + get() = correspondingPropertySymbol?.owner + private val IrSimpleFunction.property + get() = correspondingPropertySymbol?.owner + + private val valueDeclarationsRemapper = ValueDeclarationRemapper() + + override val replacements get() = context.multiFieldValueClassReplacements override fun IrClass.isSpecificLoweringLogicApplicable(): Boolean = isMultiFieldValueClass - override fun IrFunction.isSpecificFieldGetter(): Boolean = isMultiFieldValueClassFieldGetter + override val specificMangle: SpecificMangle + get() = SpecificMangle.MultiField - override fun transformSimpleFunctionFlat(function: IrSimpleFunction, replacement: IrSimpleFunction): List { - TODO() + override fun keepOldFunctionInsteadOfNew(function: IrFunction): Boolean = + function.isMultiFieldValueClassFieldGetter + + private val variablesToAdd = mutableMapOf>() + + private fun variablesSaver(variable: IrVariable) { + variablesToAdd.getOrPut(variable.parent) { mutableSetOf() }.add(variable) } - override fun buildPrimaryValueClassConstructor(valueClass: IrClass, irConstructor: IrConstructor) { - TODO("Not yet implemented") + override fun visitClassNew(declaration: IrClass): IrStatement { + + if (declaration.isSpecificLoweringLogicApplicable()) { + handleSpecificNewClass(declaration) + } else { + handleNonSpecificNewClass(declaration) + } + + declaration.transformDeclarationsFlat { memberDeclaration -> + (if (memberDeclaration is IrFunction) withinScope(memberDeclaration) { + transformFunctionFlat(memberDeclaration) + } else { + memberDeclaration.accept(this, null) + null + }).also { declarations -> + for (replacingDeclaration in declarations ?: listOf(memberDeclaration)) { + when (replacingDeclaration) { + is IrFunction -> replacingDeclaration.body = replacingDeclaration.body?.makeBodyWithAddedVariables( + context, variablesToAdd[replacingDeclaration] ?: emptySet(), replacingDeclaration.symbol + )?.apply { removeAllExtraBoxes() } + + is IrAnonymousInitializer -> replacingDeclaration.body = replacingDeclaration.body.makeBodyWithAddedVariables( + context, variablesToAdd[replacingDeclaration.parent] ?: emptySet(), replacingDeclaration.symbol + ).apply { removeAllExtraBoxes() } as IrBlockBody + + else -> Unit + } + } + } + } + + return declaration } - override fun buildBoxFunction(valueClass: IrClass) { - TODO("Not yet implemented") + private fun handleNonSpecificNewClass(irClass: IrClass) { + irClass.primaryConstructor?.let { + replacements.getReplacementForRegularClassConstructor(it)?.let { replacement -> addBindingsFor(it, replacement) } + } + val properties = collectPropertiesAfterLowering(irClass) + val oldBackingFields = properties.mapNotNull { property -> property.backingField?.let { property to it } }.toMap() + val propertiesReplacement = collectRegularClassMfvcPropertiesReplacement(properties) // resets backing fields + + val fieldsToRemove = propertiesReplacement.keys.mapNotNull { oldBackingFields[it] }.toSet() + + val newDeclarations = makeNewDeclarationsForRegularClass(fieldsToRemove, propertiesReplacement, irClass) + irClass.declarations.replaceAll(newDeclarations) } - override fun buildUnboxFunctions(valueClass: IrClass) { - TODO("Not yet implemented") + private fun collectRegularClassMfvcPropertiesReplacement(properties: LinkedHashSet) = + LinkedHashMap().apply { + for (property in properties) { + val node = replacements.getRegularClassMfvcPropertyNode(property) ?: continue + put(property, node) + } + } + + private fun makeNewDeclarationsForRegularClass( + fieldsToRemove: Set, + propertiesReplacement: Map, + irClass: IrClass, + ) = buildList { + for (element in irClass.declarations) { + when (element) { + !is IrField, !in fieldsToRemove -> add(element) + else -> { + val replacement = propertiesReplacement[element.property!!]!! + addAll(replacement.fields!!) + element.initializer?.let { initializer -> add(makeInitializerReplacement(irClass, element, initializer)) } + } + } + } + + for (node in propertiesReplacement.values) { + addAll(node.allInnerUnboxMethods.filter { it.parent == irClass }) + } } - override fun buildSpecializedEqualsMethod(valueClass: IrClass) { - TODO("Not yet implemented") + private fun makeInitializerReplacement(irClass: IrClass, element: IrField, initializer: IrExpressionBody): IrAnonymousInitializer = + context.irFactory.createAnonymousInitializer( + startOffset = UNDEFINED_OFFSET, + endOffset = UNDEFINED_OFFSET, origin = IrDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_MEMBER, + symbol = IrAnonymousInitializerSymbolImpl() + ).apply { + parent = irClass + body = context.createIrBuilder(symbol).irBlockBody { + +irSetField( + irClass.thisReceiver!!.takeUnless { element.isStatic }?.let { irGet(it) }, element, initializer.expression, + origin = UNSAFE_MFVC_SET_ORIGIN + ) + } + element.initializer = null + } + + override fun handleSpecificNewClass(declaration: IrClass) { + val rootNode = replacements.getRootMfvcNode(declaration)!! + rootNode.replaceFields() + declaration.declarations.removeIf { it is IrSimpleFunction && it.isMultiFieldValueClassFieldGetter && it.overriddenSymbols.isEmpty() } + declaration.declarations += rootNode.run { allUnboxMethods + listOf(boxMethod, specializedEqualsMethod) } + rootNode.replacePrimaryMultiFieldValueClassConstructor() } - override fun addJvmInlineAnnotation(valueClass: IrClass) = Unit + override fun transformSecondaryConstructorFlat(constructor: IrConstructor, replacement: IrSimpleFunction): List { + for (param in replacement.valueParameters) { + param.transformChildrenVoid() + } - @Suppress("UNUSED_PARAMETER") - override fun transformConstructorFlat(constructor: IrConstructor, replacement: IrSimpleFunction): List { - TODO() + allScopes.push(createScope(replacement)) + replacement.body = context.createIrBuilder(replacement.symbol).irBlockBody { + val thisVar = irTemporary(irType = replacement.returnType, nameHint = "\$this") + constructor.body?.statements?.forEach { statement -> + +statement.transformStatement(object : IrElementTransformerVoid() { + override fun visitClass(declaration: IrClass): IrStatement = declaration + + override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall): IrExpression { + val oldPrimaryConstructor = replacements.getRootMfvcNode(constructor.constructedClass)!!.oldPrimaryConstructor + thisVar.initializer = irCall(oldPrimaryConstructor).apply { + copyTypeAndValueArgumentsFrom(expression) + } + return irBlock {} + } + + override fun visitGetValue(expression: IrGetValue): IrExpression = when (expression.symbol.owner) { + constructor.constructedClass.thisReceiver!! -> irGet(thisVar) + else -> super.visitGetValue(expression) + } + + override fun visitReturn(expression: IrReturn): IrExpression { + expression.transformChildrenVoid() + if (expression.returnTargetSymbol != constructor.symbol) + return expression + + return irReturn(irBlock(expression.startOffset, expression.endOffset) { + +expression.value + +irGet(thisVar) + }) + } + }) + } + +irReturn(irGet(thisVar)) + } + .also { addBindingsFor(constructor, replacement) } + .transform(this@JvmMultiFieldValueClassLowering, null) + .patchDeclarationParents(replacement) + allScopes.pop() + return listOf(replacement) + } + + private object UNSAFE_MFVC_SET_ORIGIN : IrStatementOrigin + + private fun RootMfvcNode.replaceFields() { + mfvc.declarations.removeIf { it is IrField && (!it.isStatic || it.type.needsMfvcFlattening()) } + mfvc.declarations += fields + } + + override fun createBridgeDeclaration(source: IrSimpleFunction, replacement: IrSimpleFunction, mangledName: Name): IrSimpleFunction = + context.irFactory.buildFun { + updateFrom(source) + name = mangledName + returnType = source.returnType + }.apply { + val isAnyOverriddenReplaced = replacement.overriddenSymbols.any { + it.owner in replacements.bindingNewFunctionToParameterTemplateStructure + } + if (source.parentAsClass.isMultiFieldValueClass && isAnyOverriddenReplaced) { + copyTypeParametersFrom(source) // without static type parameters + val substitutionMap = makeTypeParameterSubstitutionMap(source, this) + dispatchReceiverParameter = source.dispatchReceiverParameter!!.let { // source!!! + it.copyTo(this, type = it.type.substitute(substitutionMap)) + } + require(replacement.dispatchReceiverParameter == null) { + """ + Ambiguous receivers: + ${source.dispatchReceiverParameter!!.render()} + ${replacement.dispatchReceiverParameter!!.render()} + """.trimIndent() + } + require(replacement.extensionReceiverParameter == null) { + "Static replacement must have no extension receiver but ${replacement.extensionReceiverParameter!!.render()} found" + } + val replacementStructure = replacements.bindingNewFunctionToParameterTemplateStructure[replacement]!! + val offset = replacementStructure[0].valueParameters.size + valueParameters = replacement.valueParameters.drop(offset).map { + it.copyTo(this, type = it.type.substitute(substitutionMap), index = it.index - offset) + } + val bridgeStructure = replacementStructure.toMutableList().apply { + set(0, RegularMapping(dispatchReceiverParameter!!)) + } + replacements.bindingNewFunctionToParameterTemplateStructure[this] = bridgeStructure + } else { + copyParameterDeclarationsFrom(source) + } + annotations = source.annotations + parent = source.parent + // We need to ensure that this bridge has the same attribute owner as its static inline class replacement, since this + // is used in [CoroutineCodegen.isStaticInlineClassReplacementDelegatingCall] to identify the bridge and avoid generating + // a continuation class. + copyAttributes(source) + } + + override fun createBridgeBody(source: IrSimpleFunction, target: IrSimpleFunction, original: IrFunction, inverted: Boolean) { + allScopes.push(createScope(source)) + source.body = context.createIrBuilder(source.symbol, source.startOffset, source.endOffset).run { + val sourceExplicitParameters = source.explicitParameters + val targetExplicitParameters = target.explicitParameters + irExprBody(irBlock { + +irReturn(irCall(target).apply { + passTypeArgumentsWithOffsets(target, source) { source.typeParameters[it].defaultType } + val sourceStructure: List? = replacements.bindingNewFunctionToParameterTemplateStructure[source] + val targetStructure: List? = 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) + } + } + + 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.rootMfvcNode != s.rootMfvcNode + }, 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" + } + repeat(remappedTargetParameter.valueParameters.size) { + putArgument( + targetExplicitParameters[flattenedTargetIndex++], + irGet(sourceExplicitParameters[flattenedSourceIndex++]) + ) + } + } + + is RegularMapping, null -> { + val valueArguments = sourceExplicitParameters + .slice(flattenedSourceIndex until flattenedSourceIndex + remappedSourceParameter.valueParameters.size) + .map { irGet(it) } + val targetParameter = targetExplicitParameters[flattenedTargetIndex++] + val boxedExpression = remappedSourceParameter.rootMfvcNode.makeBoxedExpression( + this@irBlock, remappedSourceParameter.typeArguments, valueArguments + ) + putArgument(targetParameter, boxedExpression) + .also { flattenedSourceIndex += remappedSourceParameter.valueParameters.size } + } + } + } + + is RegularMapping, null -> when (remappedTargetParameter) { + is MultiFieldValueClassMapping -> { + val receiver = sourceExplicitParameters[flattenedSourceIndex++] + val rootNode = remappedTargetParameter.rootMfvcNode + val instance = rootNode.createInstanceFromBox( + this@irBlock, irGet(receiver), getOptimizedPublicAccess(rootNode.mfvc), ::variablesSaver, + ) + val flattenedExpressions = instance.makeFlattenedGetterExpressions(this@irBlock) + for (expression in flattenedExpressions) { + putArgument(targetExplicitParameters[flattenedTargetIndex++], expression) + } + } + + else -> putArgument( + targetExplicitParameters[flattenedTargetIndex++], + irGet(sourceExplicitParameters[flattenedSourceIndex++]) + ) + } + } + } + require(flattenedTargetIndex == targetExplicitParameters.size && flattenedSourceIndex == sourceExplicitParameters.size) { + "Incorrect source:\n${source.dump()}\n\nfor target\n${target.dump()}" + } + }) + }) + } + allScopes.pop() + } + + private fun IrFunctionAccessExpression.passTypeArgumentsWithOffsets( + target: IrFunction, source: IrFunction, forCommonTypeParameters: (targetIndex: Int) -> IrType + ) { + val passedTypeParametersSize = minOf(target.typeParameters.size, source.typeParameters.size) + val targetOffset = target.typeParameters.size - passedTypeParametersSize + val sourceOffset = source.typeParameters.size - passedTypeParametersSize + if (sourceOffset > 0) { + // static fun calls method + val dispatchReceiverType = source.parentAsClass.defaultType + require(dispatchReceiverType.let { + it.needsMfvcFlattening() && it.erasedUpperBound.typeParameters.size == sourceOffset + }) { "Unexpected dispatcher receiver type: ${dispatchReceiverType.render()}" } + } + if (targetOffset > 0) { + // method calls static fun + val dispatchReceiverType = source.parentAsClass.defaultType + require(dispatchReceiverType.let { + it.needsMfvcFlattening() && it.erasedUpperBound.typeParameters.size == targetOffset + }) { "Unexpected dispatcher receiver type: ${dispatchReceiverType.render()}" } + dispatchReceiverType.erasedUpperBound.typeParameters.forEachIndexed { index, typeParameter -> + putTypeArgument(index, typeParameter.defaultType) + } + } + for (i in 0 until passedTypeParametersSize) { + putTypeArgument(i + targetOffset, forCommonTypeParameters(i + sourceOffset)) + } + } + + override fun addBindingsFor(original: IrFunction, replacement: IrFunction) { + val parametersStructure = replacements.bindingOldFunctionToParameterTemplateStructure[original]!! + require(parametersStructure.size == original.explicitParameters.size) { + "Wrong value parameters structure: $parametersStructure" + } + require(parametersStructure.sumOf { it.valueParameters.size } == replacement.explicitParameters.size) { + "Wrong value parameters structure: $parametersStructure" + } + val old2newList = original.explicitParameters.zip( + parametersStructure.scan(0) { partial: Int, templates: RemappedParameter -> partial + templates.valueParameters.size } + .zipWithNext { start: Int, finish: Int -> replacement.explicitParameters.slice(start until finish) } + ) + for (i in old2newList.indices) { + val (param, newParamList) = old2newList[i] + when (val structure = parametersStructure[i]) { + is MultiFieldValueClassMapping -> { + val mfvcNodeInstance = structure.rootMfvcNode.createInstanceFromValueDeclarationsAndBoxType( + structure.boxedType, newParamList + ) + valueDeclarationsRemapper.registerReplacement(param, mfvcNodeInstance) + } + + is RegularMapping -> valueDeclarationsRemapper.registerReplacement(param, newParamList.single()) + } + } + } + + fun RootMfvcNode.replacePrimaryMultiFieldValueClassConstructor() { + val rootMfvcNode = this + mfvc.declarations.removeIf { it is IrConstructor && it.isPrimary } + mfvc.declarations += listOf(newPrimaryConstructor, primaryConstructorImpl) + + val initializersBlocks = mfvc.declarations.filterIsInstance() + val typeArguments = makeTypeParameterSubstitutionMap(mfvc, primaryConstructorImpl) + primaryConstructorImpl.body = context.createIrBuilder(primaryConstructorImpl.symbol).irBlockBody { + val mfvcNodeInstance = + ValueDeclarationMfvcNodeInstance(rootMfvcNode, typeArguments, primaryConstructorImpl.valueParameters) + valueDeclarationsRemapper.registerReplacement( + oldPrimaryConstructor.constructedClass.thisReceiver!!, + mfvcNodeInstance + ) + for (initializer in initializersBlocks) { + +irBlock { + for (stmt in initializer.body.statements) { + +stmt.patchDeclarationParents(primaryConstructorImpl) // transformation is done later + } + } + } + } + mfvc.declarations.removeIf { it is IrAnonymousInitializer } } override fun visitFunctionReference(expression: IrFunctionReference): IrExpression { @@ -52,27 +653,675 @@ private class JvmMultiFieldValueClassLowering(context: JvmBackendContext) : JvmV } override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression { - // todo implement - return super.visitFunctionAccess(expression) + val function = expression.symbol.owner + val replacement = replacements.getReplacementFunction(function) + val currentScope = currentScope!!.irElement as IrDeclaration + return when { + function is IrConstructor && function.isPrimary && function.constructedClass.isMultiFieldValueClass && + currentScope.origin != JvmLoweredDeclarationOrigin.SYNTHETIC_MULTI_FIELD_VALUE_CLASS_MEMBER -> { + context.createIrBuilder(currentScope.symbol).irBlock { + val rootNode = replacements.getRootMfvcNode(function.constructedClass)!! + val instance = rootNode.createInstanceFromValueDeclarationsAndBoxType( + this, function.constructedClassType as IrSimpleType, Name.identifier("constructor_tmp"), ::variablesSaver + ) + flattenExpressionTo(expression, instance) + val getterExpression = instance.makeGetterExpression(this) + valueDeclarationsRemapper.registerReplacement(getterExpression, instance) + +getterExpression + } + } + + replacement != null -> context.createIrBuilder(currentScope.symbol).irBlock { + buildReplacement(function, expression, replacement) + } + + else -> { + val newConstructor = (function as? IrConstructor) + ?.let { replacements.getReplacementForRegularClassConstructor(it) } + ?: return super.visitFunctionAccess(expression) + context.createIrBuilder(currentScope.symbol).irBlock { + buildReplacement(function, expression, newConstructor) + } + } + } } override fun visitCall(expression: IrCall): IrExpression { - // todo implement + val callee = expression.symbol.owner + val property = callee.property + if ( + property != null && + callee.extensionReceiverParameter == null && + callee.contextReceiverParametersCount == 0 && + callee.isGetter && + (expression.type.needsMfvcFlattening() || expression.dispatchReceiver?.type?.needsMfvcFlattening() == true) + ) { + require(callee.valueParameters.isEmpty()) { "Unexpected getter:\n${callee.dump()}" } + expression.dispatchReceiver = expression.dispatchReceiver?.transform(this, null) + return context.createIrBuilder(getCurrentScopeSymbol()).irBlock { + with(valueDeclarationsRemapper) { + addReplacement(expression) ?: return expression + } + } + } + if (expression.isSpecializedMFVCEqEq) { + val backendContext = context + return context.createIrBuilder(getCurrentScopeSymbol()).irBlock { + val leftArgument = expression.getValueArgument(0)!! + val rightArgument = expression.getValueArgument(1)!! + val leftClass = leftArgument.type.erasedUpperBound + val leftNode = if (leftArgument.type.needsMfvcFlattening()) replacements.getRootMfvcNode(leftClass) else null + val rightClass = rightArgument.type.erasedUpperBound + val rightNode = if (rightArgument.type.needsMfvcFlattening()) replacements.getRootMfvcNode(rightClass) else null + if (leftNode != null) { + if (rightNode != null) { + // both are unboxed + val leftExpressions = flattenExpression(leftArgument) + require((leftExpressions.size > 1) == leftArgument.type.needsMfvcFlattening()) { + "Illegal flattening of ${leftArgument.dump()}\n\n${leftExpressions.joinToString("\n") { it.dump() }}" + } + val rightExpressions = flattenExpression(rightArgument) + require((rightExpressions.size > 1) == rightArgument.type.needsMfvcFlattening()) { + "Illegal flattening of ${rightArgument.dump()}\n\n${rightExpressions.joinToString("\n") { it.dump() }}" + } + require(leftNode == rightNode) { "Different node: $leftNode, $rightNode" } + require(leftClass == rightClass) { "Equals for different classes: $leftClass and $rightClass called" } + + +irCall(leftNode.specializedEqualsMethod).apply { + ((leftArgument.type as IrSimpleType).arguments + (rightArgument.type as IrSimpleType).arguments).forEachIndexed { index, argument -> + putTypeArgument(index, argument.typeOrNull) + } + val arguments = leftExpressions + rightExpressions + arguments.forEachIndexed { index, argument -> putValueArgument(index, argument) } + } + } else { + // left one is unboxed, right is not + val equals = leftClass.functions.single { it.isEquals(backendContext) } + +irCall(equals).apply { + copyTypeArgumentsFrom(expression) + dispatchReceiver = leftArgument + putValueArgument(0, rightArgument) + }.transform(this@JvmMultiFieldValueClassLowering, null) + } + } else if (rightNode != null) { + // left one is boxed, right one is unboxed + if (leftArgument.isNullConst()) { + // left argument is always null, right one is unboxed + val hasPureFlattenedGetters = rightNode.mapLeaves { it.hasPureUnboxMethod }.all { it } + if (hasPureFlattenedGetters) { + val rightExpressions = flattenExpression(rightArgument) + require((rightExpressions.size > 1) == rightArgument.type.needsMfvcFlattening()) { + "Illegal flattening of ${rightArgument.dump()}\n\n${rightExpressions.joinToString("\n") { it.dump() }}" + } + rightExpressions.filterNot { it.isRepeatableGetter() }.forEach { +it } + } else { + +rightArgument.transform(this@JvmMultiFieldValueClassLowering, null) + } + +irFalse() + } else if (leftArgument.type.erasedUpperBound == rightArgument.type.erasedUpperBound && leftArgument.type.isNullable()) { + // left argument can be unboxed if it is not null, right one is unboxed + +irBlock { + val leftValue = irTemporary(leftArgument) + +irIfNull(context.irBuiltIns.booleanType, irGet(leftValue), irFalse(), irBlock { + val nonNullLeftArgumentVariable = + irTemporary(irImplicitCast(irGet(leftValue), leftArgument.type.makeNotNull())) + +irCall(context.irBuiltIns.eqeqSymbol).apply { + copyTypeArgumentsFrom(expression) + putValueArgument(0, irGet(nonNullLeftArgumentVariable)) + putValueArgument(1, rightArgument) + } + }) + }.transform(this@JvmMultiFieldValueClassLowering, null) + } else { + // right one is unboxed but left one is boxed and no intrinsics can be used + return super.visitCall(expression) + } + } else { + // both are boxed + return super.visitCall(expression) + } + } + } return super.visitCall(expression) } + private fun IrBlockBuilder.buildReplacement( + originalFunction: IrFunction, + original: IrMemberAccessExpression<*>, + replacement: IrFunction + ) { + val parameter2expression = typedArgumentList(originalFunction, original) + val structure = replacements.bindingOldFunctionToParameterTemplateStructure[originalFunction]!! + require(parameter2expression.size == structure.size) + require(structure.sumOf { it.valueParameters.size } == replacement.explicitParametersCount) + val newArguments: List = + makeNewArguments(parameter2expression.map { (_, argument) -> argument }, structure.map { it.valueParameters }) + +irCall(replacement.symbol).apply { + passTypeArgumentsWithOffsets(replacement, originalFunction) { original.getTypeArgument(it)!! } + for ((parameter, argument) in replacement.explicitParameters zip newArguments) { + if (argument == null) continue + putArgument(replacement, parameter, argument.transform(this@JvmMultiFieldValueClassLowering, null)) + } + } + } + + override fun visitStringConcatenation(expression: IrStringConcatenation): IrExpression { + for (i in expression.arguments.indices) { + val argument = expression.arguments[i] + if (argument.type.needsMfvcFlattening()) { + expression.arguments[i] = context.createIrBuilder(getCurrentScopeSymbol()).run { + val toString = argument.type.erasedUpperBound.functions.single { it.isToString() } + require(toString.typeParameters.isEmpty()) { "Bad toString: ${toString.render()}" } + irCall(toString).apply { + dispatchReceiver = argument + } + } + } + } + return super.visitStringConcatenation(expression) + } + + private fun IrBlockBuilder.makeNewArguments( + oldArguments: List, + structure: List> + ): List { + val argumentSizes: List = structure.map { argTemplate -> argTemplate.size } + val newArguments = (oldArguments zip argumentSizes).flatMap { (oldArgument, parametersCount) -> + when { + oldArgument == null -> List(parametersCount) { null } + parametersCount == 1 -> listOf(oldArgument.transform(this@JvmMultiFieldValueClassLowering, null)) + else -> { + val type = oldArgument.type as IrSimpleType + require(type.needsMfvcFlattening()) { "Unexpected type: ${type.render()}" } + flattenExpression(oldArgument).also { + require(it.size == parametersCount) { "Expected $parametersCount arguments but got ${it.size}" } + } + } + } + } + return newArguments + } + + /** + * Inlines initialization of variables when possible and returns their values + * + * Example: + * Before: + * val a = 2 + * val b = 3 + * val c = b + 1 + * [a, b, c] + * + * After: + * val a = 2 + * val b = 3 + * [a, b, b + 1] + */ + fun IrBuilderWithScope.removeExtraSetVariablesFromExpressionList( + block: IrContainerExpression, + variables: List + ): List { + val forbiddenVariables = mutableSetOf() + val variablesSet = variables.toSet() + val standaloneExpressions = mutableListOf() + val resultVariables = variables.toMutableList() + + fun recur(block: IrContainerExpression): Boolean /* stop optimization */ { + while (block.statements.isNotEmpty() && resultVariables.isNotEmpty()) { + val statement = block.statements.last() + //also stop + when { + statement is IrContainerExpression -> if (recur(statement)) { + if (statement.statements.isEmpty()) { + block.statements.removeLast() + } + return true + } else { + require(statement.statements.isEmpty() || resultVariables.isEmpty()) { "Not all statements removed" } + if (statement.statements.isEmpty()) { + block.statements.removeLast() + } + } + + statement !is IrSetValue -> return true + statement.symbol.owner != resultVariables.last() -> return true + statement.symbol.owner in forbiddenVariables -> return true + else -> { + standaloneExpressions.add(statement.value) + resultVariables.removeLast() + block.statements.removeLast() + statement.value.acceptVoid(object : IrElementVisitorVoid { + override fun visitElement(element: IrElement) { + element.acceptChildrenVoid(this) + } + + override fun visitValueAccess(expression: IrValueAccessExpression) { + val valueDeclaration = expression.symbol.owner + if (valueDeclaration is IrVariable && valueDeclaration in variablesSet) { + forbiddenVariables.add(valueDeclaration) + } + super.visitValueAccess(expression) + } + }) + } + } + } + return false + } + recur(block) + return resultVariables.map { irGet(it) } + standaloneExpressions.asReversed() + } + + // Note that reference equality (x === y) is not allowed on values of MFVC class type, + // so it is enough to check for eqeq. + private val IrCall.isSpecializedMFVCEqEq: Boolean + get() = symbol == context.irBuiltIns.eqeqSymbol && + listOf(getValueArgument(0), getValueArgument(1)) + .any { it!!.type.erasedUpperBound.isMultiFieldValueClass } + override fun visitGetField(expression: IrGetField): IrExpression { - // todo implement - return super.visitGetField(expression) + expression.receiver = expression.receiver?.transform(this, null) + with(valueDeclarationsRemapper) { + return context.createIrBuilder(expression.symbol).irBlock { + addReplacement(expression) ?: return expression + } + } } - override fun visitGetValue(expression: IrGetValue): IrExpression { - // todo implement - return super.visitGetValue(expression) + override fun visitSetField(expression: IrSetField): IrExpression { + expression.receiver = expression.receiver?.transform(this, null) + with(valueDeclarationsRemapper) { + return context.createIrBuilder(getCurrentScopeSymbol()).irBlock { + addReplacement(expression, safe = expression.origin != UNSAFE_MFVC_SET_ORIGIN) + ?: return expression.also { it.value = it.value.transform(this@JvmMultiFieldValueClassLowering, null) } + } + } } - override fun visitSetValue(expression: IrSetValue): IrExpression { - // todo implement - return super.visitSetValue(expression) + override fun visitGetValue(expression: IrGetValue): IrExpression = + with(valueDeclarationsRemapper) { + context.createIrBuilder(getCurrentScopeSymbol()).makeReplacement(expression) ?: super.visitGetValue(expression) + } + + override fun visitSetValue(expression: IrSetValue): IrExpression = context.createIrBuilder(getCurrentScopeSymbol()).irBlock { + with(valueDeclarationsRemapper) { + addReplacement(expression, safe = expression.origin != UNSAFE_MFVC_SET_ORIGIN) + ?: return super.visitSetValue(expression) + } } -} \ No newline at end of file + + override fun visitVariable(declaration: IrVariable): IrStatement { + val initializer = declaration.initializer + if (declaration.type.needsMfvcFlattening()) { + val irClass = declaration.type.erasedUpperBound + val rootNode = replacements.getRootMfvcNode(irClass)!! + return context.createIrBuilder(getCurrentScopeSymbol()).irBlock { + val instance = rootNode.createInstanceFromValueDeclarationsAndBoxType( + this, declaration.type as IrSimpleType, declaration.name, ::variablesSaver + ) + valueDeclarationsRemapper.registerReplacement(declaration, instance) + initializer?.let { + flattenExpressionTo(it, instance) + } + } + } + return super.visitVariable(declaration) + } + + private fun getCurrentScopeSymbol() = (currentScope!!.irElement as IrSymbolOwner).symbol + + /** + * Takes not transformed expression and returns its flattened transformed representation (expressions) + */ + fun IrBlockBuilder.flattenExpression(expression: IrExpression): List { + if (!expression.type.needsMfvcFlattening()) { + return listOf(expression.transform(this@JvmMultiFieldValueClassLowering, null)) + } + val rootMfvcNode = replacements.getRootMfvcNode(expression.type.erasedUpperBound)!! + val typeArguments = makeTypeArgumentsFromType(expression.type as IrSimpleType) + val variables = rootMfvcNode.leaves.map { + savableStandaloneVariable( + type = it.type.substitute(typeArguments), + origin = IrDeclarationOrigin.MULTI_FIELD_VALUE_CLASS_REPRESENTATION_VARIABLE, + saveVariable = ::variablesSaver + ) + } + val instance = ValueDeclarationMfvcNodeInstance(rootMfvcNode, typeArguments, variables) + val block = irBlock { + flattenExpressionTo(expression, instance) + } + val expressions = removeExtraSetVariablesFromExpressionList(block, variables) + if (block.statements.isNotEmpty()) { + +block + } + return expressions + } + + /** + * Takes not transformed expression and initialized given MfvcNodeInstance with transformed version of it + */ + fun IrBlockBuilder.flattenExpressionTo(expression: IrExpression, instance: MfvcNodeInstance) { + val rootNode = replacements.getRootMfvcNode( + if (expression is IrConstructorCall) expression.symbol.owner.constructedClass else expression.type.erasedUpperBound + ) + val type = if (expression is IrConstructorCall) expression.symbol.owner.constructedClass.defaultType else expression.type + val lowering = this@JvmMultiFieldValueClassLowering + if (rootNode == null || !type.needsMfvcFlattening()) { + require(instance.size == 1) { "Required 1 variable/field to store regular value but got ${instance.size}" } + instance.addSetterStatements(this, listOf(expression.transform(lowering, null))) + return + } + require(rootNode.leavesCount == instance.size) { + "Required ${rootNode.leavesCount} variable/field to store regular value but got ${instance.size}" + } + if (expression is IrWhen) { + for (branch in expression.branches) { + branch.condition = branch.condition.transform(lowering, null) + branch.result = irBlock { + flattenExpressionTo(branch.result, instance) + }.unwrapBlock() + } + +expression + return + } + if (expression is IrTry) { + expression.tryResult = irBlock { flattenExpressionTo(expression.tryResult, instance) }.unwrapBlock() + expression.catches.replaceAll { irCatch(it.catchParameter, irBlock { flattenExpressionTo(it.result, instance) }.unwrapBlock()) } + expression.finallyExpression = expression.finallyExpression?.transform(lowering, null) + +expression + return + } + if (expression is IrConstructorCall) { + val constructor = expression.symbol.owner + if (constructor.isPrimary && constructor.constructedClass.isMultiFieldValueClass && + constructor.origin != JvmLoweredDeclarationOrigin.STATIC_MULTI_FIELD_VALUE_CLASS_CONSTRUCTOR + ) { + val oldArguments = List(expression.valueArgumentsCount) { expression.getValueArgument(it) } + require(rootNode.subnodes.size == oldArguments.size) { + "Old ${constructor.render()} must have ${rootNode.subnodes.size} arguments but got ${oldArguments.size}" + } + for ((subnode, argument) in rootNode.subnodes zip oldArguments) { + argument?.let { flattenExpressionTo(it, instance[subnode.name]!!) } + } + +irCall(rootNode.primaryConstructorImpl).apply { + copyTypeArgumentsFrom(expression) + for ((index, leafExpression) in instance.makeFlattenedGetterExpressions(this@flattenExpressionTo).withIndex()) { + putValueArgument(index, leafExpression) + } + } + return + } + } + val transformedExpression = expression.transform(this@JvmMultiFieldValueClassLowering, null) + val addedSettersToFlattened = valueDeclarationsRemapper.handleFlattenedGetterExpressions(this, transformedExpression) { + require(it.size == instance.size) { "Incompatible assignment sizes: ${it.size}, ${instance.size}" } + instance.makeSetterExpressions(this, it) + } + if (addedSettersToFlattened != null) { + +addedSettersToFlattened + return + } + val expressionInstance = rootNode.createInstanceFromBox( + this, transformedExpression, getOptimizedPublicAccess(rootNode.mfvc), ::variablesSaver, + ) + require(expressionInstance.size == instance.size) { "Incompatible assignment sizes: ${expressionInstance.size}, ${instance.size}" } + instance.addSetterStatements(this, expressionInstance.makeFlattenedGetterExpressions(this)) + } + + private fun getOptimizedPublicAccess(parent: IrClass): AccessType = + currentScope?.irElement?.let { getOptimizedPublicAccess(it, parent) } ?: AccessType.AlwaysPublic + + /** + * Removes boxing when the result is not used + */ + fun IrBody.removeAllExtraBoxes() { + // data is whether the expression result is used + accept(object : IrElementVisitor { + override fun visitElement(element: IrElement, data: Boolean) { + element.acceptChildren(this, true) // uses what is inside + } + + override fun visitTypeOperator(expression: IrTypeOperatorCall, data: Boolean) { + expression.acceptChildren(this, data) // type operator calls are transparent + } + + private tailrec fun getFunctionCallOrNull(statement: IrStatement): IrCall? = when (statement) { + is IrTypeOperatorCall -> getFunctionCallOrNull(statement.argument) + is IrCall -> statement + else -> null + } + + // inner functions will be handled separately, no need to do it now + override fun visitFunction(declaration: IrFunction, data: Boolean) = Unit + + // inner classes will be handled separately, no need to do it now + override fun visitClass(declaration: IrClass, data: Boolean) = Unit + + override fun visitContainerExpression(expression: IrContainerExpression, data: Boolean) { + handleStatementContainer(expression, data) + } + + override fun visitWhen(expression: IrWhen, data: Boolean) { + expression.acceptChildren(this, data) // when's are transparent + } + + override fun visitCatch(aCatch: IrCatch, data: Boolean) { + aCatch.acceptChildren(this, data) // catches are transparent + } + + override fun visitTry(aTry: IrTry, data: Boolean) { + aTry.tryResult.accept(this, data) + aTry.catches.forEach { it.accept(this, data) } + aTry.finallyExpression?.accept(this, false) + } + + override fun visitBranch(branch: IrBranch, data: Boolean) { + branch.condition.accept(this, true) + branch.result.accept(this, data) + } + + override fun visitBlockBody(body: IrBlockBody, data: Boolean) { + handleStatementContainer(body, data) + } + + private fun handleStatementContainer(expression: IrStatementContainer, resultIsUsed: Boolean) { + for (statement in expression.statements.dropLast(1)) { + statement.accept(this, false) + } + expression.statements.lastOrNull()?.accept(this, resultIsUsed) + val statementsToRemove = mutableSetOf() + for (statement in expression.statements.dropLast(if (resultIsUsed) 1 else 0)) { + val call = getFunctionCallOrNull(statement) ?: continue + val node = replacements.getRootMfvcNode(call.type.erasedUpperBound) ?: continue + if (node.boxMethod == call.symbol.owner && + List(call.valueArgumentsCount) { call.getValueArgument(it) }.all { it.isRepeatableGetter() } + ) { + statementsToRemove.add(statement) + } + } + expression.statements.removeIf { it in statementsToRemove } + } + }, false) + } +} + +private sealed class BlockOrBody { + data class Body(val body: IrBody) : BlockOrBody() + data class Block(val block: IrBlock) : BlockOrBody() +} + +/** + * Finds the most narrow block or body which contains all usages of each of the given variables + */ +private fun findNearestBlocksForVariables(variables: Set, body: IrBody): Map { + val variableUsages = mutableMapOf>() + val childrenBlocks = mutableMapOf>() + + body.acceptVoid(object : IrElementVisitorVoid { + private val stack = mutableListOf() + override fun visitElement(element: IrElement) { + element.acceptChildren(this, null) + } + + override fun visitBody(body: IrBody) { + currentStackElement()?.let { childrenBlocks.getOrPut(it) { mutableListOf() }.add(BlockOrBody.Body(body)) } + stack.add(BlockOrBody.Body(body)) + super.visitBody(body) + require(stack.removeLast() == BlockOrBody.Body(body)) { "Invalid stack" } + } + + override fun visitBlock(expression: IrBlock) { + childrenBlocks.getOrPut(currentStackElement()!!) { mutableListOf() }.add(Block(expression)) + stack.add(Block(expression)) + super.visitBlock(expression) + require(stack.removeLast() == Block(expression)) { "Invalid stack" } + } + + private fun currentStackElement() = stack.lastOrNull() + + override fun visitValueAccess(expression: IrValueAccessExpression) { + val valueDeclaration = expression.symbol.owner + if (valueDeclaration is IrVariable && valueDeclaration in variables) { + variableUsages.getOrPut(currentStackElement()!!) { mutableSetOf() }.add(valueDeclaration) + } + super.visitValueAccess(expression) + } + }) + + fun dfs(currentBlock: BlockOrBody, variable: IrVariable): BlockOrBody? { + if (variable in (variableUsages[currentBlock] ?: listOf())) return currentBlock + val childrenResult = childrenBlocks[currentBlock]?.mapNotNull { dfs(it, variable) } ?: listOf() + return when (childrenResult.size) { + 0 -> return null + 1 -> return childrenResult.single() + else -> currentBlock + } + } + + return variables.associateWith { dfs(BlockOrBody.Body(body), it) } +} + +private fun IrStatement.containsUsagesOf(variablesSet: Set): Boolean { + var used = false + acceptVoid(object : IrElementVisitorVoid { + override fun visitElement(element: IrElement) { + if (!used) { + element.acceptChildrenVoid(this) + } + } + + override fun visitValueAccess(expression: IrValueAccessExpression) { + if (expression.symbol.owner in variablesSet) { + used = true + } + super.visitValueAccess(expression) + } + }) + return used +} + +/** + * Adds declarations of the variables to the most narrow possible block or body. + * It adds them before the first usage within the block and inlines initialization of them when possible. + */ +fun IrBody.makeBodyWithAddedVariables( + context: JvmBackendContext, + variables: Set, + symbol: IrSymbol +): IrBody { + val nearestBlocks = findNearestBlocksForVariables(variables, this) + val containingVariables: Map> = nearestBlocks.entries + .mapNotNull { (k, v) -> if (v != null) k to v else null } + .groupBy({ (_, v) -> v }, { (k, _) -> k }) + return transform(object : IrElementTransformerVoid() { + private fun getFlattenedStatements(container: IrStatementContainer): Sequence = sequence { + for (statement in container.statements) { + if (statement is IrStatementContainer) { + yieldAll(getFlattenedStatements(statement)) + } else { + yield(statement) + } + } + } + + private fun removeFlattenedStatements(container: IrStatementContainer, toRemove: Int): Int { + var removed = 0 + var removedDirectly = 0 + for (statement in container.statements) { + require(removed <= toRemove) { "Removed: $removed, To remove: $toRemove" } + if (removed == toRemove) break + if (statement is IrStatementContainer) { + val nestedRemoved = removeFlattenedStatements(statement, toRemove - removed) + removed += nestedRemoved + if (statement.statements.isEmpty()) { + removedDirectly++ + } + } else { + removed++ + removedDirectly++ + } + } + require(removed <= toRemove) { "Removed: $removed, To remove: $toRemove" } + if (removedDirectly > 0) container.statements.replaceAll(container.statements.drop(removedDirectly)) + return removed + } + + private fun replaceSetVariableWithInitialization(variables: List, container: IrStatementContainer) { + val variablesSet = variables.toSet() + val statementsWithoutUsages = container.statements.takeWhile { !it.containsUsagesOf(variablesSet) } + container.statements.replaceAll(container.statements.drop(statementsWithoutUsages.size)) + val values = buildList { + for ((variable, statement) in variables.asSequence() zip getFlattenedStatements(container)) { + when { + variable.initializer != null -> break + statement !is IrSetValue -> break + statement.symbol.owner != variable -> break + else -> add(statement.value) + } + } + } + + for ((variable, value) in variables zip values) { + variable.initializer = value + } + removeFlattenedStatements(container, values.size) + container.statements.addAll(0, statementsWithoutUsages + variables) + } + + override fun visitBlock(expression: IrBlock): IrExpression { + containingVariables[Block(expression)]?.let { + expression.transformChildrenVoid() + replaceSetVariableWithInitialization(it, expression) + return expression + } + return super.visitBlock(expression) + } + + override fun visitBlockBody(body: IrBlockBody): IrBody { + containingVariables[BlockOrBody.Body(body)]?.let { + body.transformChildrenVoid() + replaceSetVariableWithInitialization(it, body) + return body + } + return super.visitBlockBody(body) + } + + override fun visitExpressionBody(body: IrExpressionBody): IrBody { + val lowering = this + containingVariables[BlockOrBody.Body(body)]?.takeIf { it.isNotEmpty() }?.let { bodyVars -> + val blockBody = context.createJvmIrBuilder(symbol).irBlockBody { + +irReturn(body.expression.transform(lowering, null)) + } + blockBody.transformChildrenVoid() + replaceSetVariableWithInitialization(bodyVars, blockBody) + return blockBody + } + return super.visitExpressionBody(body) + } + }, null) +} + +private fun MutableList.replaceAll(replacement: List) { + clear() + addAll(replacement) +} diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmPropertiesLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmPropertiesLowering.kt index 71f054ba1ba..04acfabadee 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmPropertiesLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmPropertiesLowering.kt @@ -10,10 +10,10 @@ import org.jetbrains.kotlin.backend.common.IrElementTransformerVoidWithContext import org.jetbrains.kotlin.backend.common.lower.createIrBuilder import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin +import org.jetbrains.kotlin.backend.jvm.getRequiresMangling import org.jetbrains.kotlin.backend.jvm.hasMangledReturnType import org.jetbrains.kotlin.backend.jvm.ir.eraseTypeParameters import org.jetbrains.kotlin.backend.jvm.ir.needsAccessor -import org.jetbrains.kotlin.backend.jvm.requiresMangling import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.DescriptorVisibilities @@ -222,7 +222,7 @@ class JvmPropertiesLowering(private val backendContext: JvmBackendContext) : IrE val getter = property.getter if (getter != null) { val needsMangling = - getter.extensionReceiverParameter?.type?.requiresMangling == true || + getter.extensionReceiverParameter?.type?.getRequiresMangling(includeInline = true, includeMFVC = false) == true || (state.functionsWithInlineClassReturnTypesMangled && getter.hasMangledReturnType) val mangled = if (needsMangling) inlineClassReplacements.getReplacementFunction(getter) else null defaultMethodSignatureMapper.mapFunctionName(mangled ?: getter) diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmValueClassAbstractLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmValueClassAbstractLowering.kt index 9a0453c82ed..7f7e6fb3324 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmValueClassAbstractLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmValueClassAbstractLowering.kt @@ -8,70 +8,32 @@ package org.jetbrains.kotlin.backend.jvm.lower import org.jetbrains.kotlin.backend.common.FileLoweringPass import org.jetbrains.kotlin.backend.common.IrElementTransformerVoidWithContext import org.jetbrains.kotlin.backend.common.lower.createIrBuilder -import org.jetbrains.kotlin.backend.jvm.InlineClassAbi -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext -import org.jetbrains.kotlin.backend.jvm.MemoizedValueClassAbstractReplacements +import org.jetbrains.kotlin.backend.common.pop +import org.jetbrains.kotlin.backend.common.push +import org.jetbrains.kotlin.backend.jvm.* import org.jetbrains.kotlin.ir.IrStatement import org.jetbrains.kotlin.ir.builders.irReturn import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.expressions.* -import org.jetbrains.kotlin.ir.symbols.IrValueSymbol import org.jetbrains.kotlin.ir.transformStatement import org.jetbrains.kotlin.ir.util.* +import org.jetbrains.kotlin.load.java.JvmAbi +import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.utils.addToStdlib.safeAs internal abstract class JvmValueClassAbstractLowering(val context: JvmBackendContext) : FileLoweringPass, IrElementTransformerVoidWithContext() { abstract val replacements: MemoizedValueClassAbstractReplacements - protected val valueMap = mutableMapOf() - - private fun addBindingsFor(original: IrFunction, replacement: IrFunction) { - for ((param, newParam) in original.explicitParameters.zip(replacement.explicitParameters)) { - valueMap[param.symbol] = newParam - } - } - final override fun lower(irFile: IrFile) { irFile.transformChildrenVoid() } abstract fun IrClass.isSpecificLoweringLogicApplicable(): Boolean - abstract fun IrFunction.isSpecificFieldGetter(): Boolean + abstract override fun visitClassNew(declaration: IrClass): IrStatement - final override fun visitClassNew(declaration: IrClass): IrStatement { - // The arguments to the primary constructor are in scope in the initializers of IrFields. - declaration.primaryConstructor?.let { - replacements.getReplacementFunction(it)?.let { replacement -> addBindingsFor(it, replacement) } - } - - declaration.transformDeclarationsFlat { memberDeclaration -> - if (memberDeclaration is IrFunction) { - withinScope(memberDeclaration) { - transformFunctionFlat(memberDeclaration) - } - } else { - memberDeclaration.accept(this, null) - null - } - } - - if (declaration.isSpecificLoweringLogicApplicable()) { - val irConstructor = declaration.primaryConstructor!! - // The field getter is used by reflection and cannot be removed here unless it is internal. - declaration.declarations.removeIf { - it == irConstructor || (it is IrFunction && it.isSpecificFieldGetter() && !it.visibility.isPublicAPI) - } - buildPrimaryValueClassConstructor(declaration, irConstructor) - buildBoxFunction(declaration) - buildUnboxFunctions(declaration) - buildSpecializedEqualsMethod(declaration) - addJvmInlineAnnotation(declaration) - } - - return declaration - } + abstract fun handleSpecificNewClass(declaration: IrClass) protected fun transformFunctionFlat(function: IrFunction): List? { if (function is IrConstructor && function.isPrimary && function.constructedClass.isSpecificLoweringLogicApplicable()) { @@ -79,7 +41,21 @@ internal abstract class JvmValueClassAbstractLowering(val context: JvmBackendCon } val replacement = replacements.getReplacementFunction(function) + + if (keepOldFunctionInsteadOfNew(function)) { + function.transformChildrenVoid() + addBindingsFor(function, replacement!!) + return null + } + if (replacement == null) { + if (function is IrConstructor) { + val constructorReplacement = replacements.getReplacementForRegularClassConstructor(function) + if (constructorReplacement != null) { + addBindingsFor(function, constructorReplacement) + return transformFlattenedConstructor(function, constructorReplacement) + } + } function.transformChildrenVoid() // Non-mangled functions can override mangled functions under some conditions, e.g., a function // `fun f(): Nothing` can override a function `fun f(): UInt`. The former is not mangled, while @@ -106,30 +82,50 @@ internal abstract class JvmValueClassAbstractLowering(val context: JvmBackendCon addBindingsFor(function, replacement) return when (function) { is IrSimpleFunction -> transformSimpleFunctionFlat(function, replacement) - is IrConstructor -> transformConstructorFlat(function, replacement) + is IrConstructor -> transformSecondaryConstructorFlat(function, replacement) else -> throw IllegalStateException() } } + private fun transformFlattenedConstructor(function: IrConstructor, replacement: IrConstructor): List? { + replacement.valueParameters.forEach { + it.transformChildrenVoid() + it.defaultValue?.patchDeclarationParents(replacement) + } + allScopes.push(createScope(function)) + replacement.body = function.body?.transform(this, null)?.patchDeclarationParents(replacement) + allScopes.pop() + return listOf(replacement) + } + private fun IrFunction.hashSuffix(): String? = InlineClassAbi.hashSuffix( this, context.state.functionsWithInlineClassReturnTypesMangled, context.state.useOldManglingSchemeForFunctionsWithInlineClassesInSignatures ) - protected abstract fun transformConstructorFlat(constructor: IrConstructor, replacement: IrSimpleFunction): List + protected abstract fun transformSecondaryConstructorFlat(constructor: IrConstructor, replacement: IrSimpleFunction): List - protected abstract fun transformSimpleFunctionFlat(function: IrSimpleFunction, replacement: IrSimpleFunction): List + private fun transformSimpleFunctionFlat(function: IrSimpleFunction, replacement: IrSimpleFunction): List { + replacement.valueParameters.forEach { + it.transformChildrenVoid() + it.defaultValue?.patchDeclarationParents(replacement) + } + allScopes.push(createScope(replacement)) + replacement.body = function.body?.transform(this, null)?.patchDeclarationParents(replacement) + allScopes.pop() + replacement.copyAttributes(function) - protected abstract fun buildPrimaryValueClassConstructor(valueClass: IrClass, irConstructor: IrConstructor) + // Don't create a wrapper for functions which are only used in an unboxed context + if (function.overriddenSymbols.isEmpty() || replacement.dispatchReceiverParameter != null) + return listOf(replacement) - protected abstract fun buildBoxFunction(valueClass: IrClass) + val bridgeFunction = createBridgeFunction(function, replacement) - protected abstract fun buildUnboxFunctions(valueClass: IrClass) + return listOf(replacement, bridgeFunction) + } - protected abstract fun buildSpecializedEqualsMethod(valueClass: IrClass) // todo hashCode - - protected abstract fun addJvmInlineAnnotation(valueClass: IrClass) + abstract fun keepOldFunctionInsteadOfNew(function: IrFunction): Boolean final override fun visitReturn(expression: IrReturn): IrExpression { expression.returnTargetSymbol.owner.safeAs()?.let { target -> @@ -137,7 +133,10 @@ internal abstract class JvmValueClassAbstractLowering(val context: JvmBackendCon if (suffix != null && target.name.asString().endsWith(suffix)) return super.visitReturn(expression) - replacements.getReplacementFunction(target)?.let { + replacements.run { + if (keepOldFunctionInsteadOfNew(target)) return@run null + getReplacementFunction(target) ?: if (target is IrConstructor) getReplacementForRegularClassConstructor(target) else null + }?.let { return context.createIrBuilder(it.symbol, expression.startOffset, expression.endOffset).irReturn( expression.value.transform(this, null) ) @@ -172,4 +171,65 @@ internal abstract class JvmValueClassAbstractLowering(val context: JvmBackendCon else super.visitAnonymousInitializerNew(declaration) + protected abstract fun addBindingsFor(original: IrFunction, replacement: IrFunction) + + protected enum class SpecificMangle { Inline, MultiField } + + protected abstract val specificMangle: SpecificMangle + private fun createBridgeFunction( + function: IrSimpleFunction, + replacement: IrSimpleFunction + ): IrSimpleFunction { + val bridgeFunction = createBridgeDeclaration( + function, + replacement, + when { + // If the original function has signature which need mangling we still need to replace it with a mangled version. + (!function.isFakeOverride || function.findInterfaceImplementation(context.state.jvmDefaultMode) != null) && when (specificMangle) { + SpecificMangle.Inline -> function.signatureRequiresMangling(includeInline = true, includeMFVC = false) + SpecificMangle.MultiField -> function.signatureRequiresMangling(includeInline = false, includeMFVC = true) + } -> replacement.name + // Since we remove the corresponding property symbol from the bridge we need to resolve getter/setter + // names at this point. + replacement.isGetter -> + Name.identifier(JvmAbi.getterName(replacement.correspondingPropertySymbol!!.owner.name.asString())) + + replacement.isSetter -> + Name.identifier(JvmAbi.setterName(replacement.correspondingPropertySymbol!!.owner.name.asString())) + + else -> + function.name + } + ) + + // Update the overridden symbols to point to their inline class replacements + bridgeFunction.overriddenSymbols = replacement.overriddenSymbols + + // Replace the function body with a wrapper + if (bridgeFunction.isFakeOverride && bridgeFunction.parentAsClass.isSpecificLoweringLogicApplicable()) { + // Fake overrides redirect from the replacement to the original function, which is in turn replaced during interfacePhase. + createBridgeBody(replacement, bridgeFunction, function, true) + } else { + createBridgeBody(bridgeFunction, replacement, function, false) + } + return bridgeFunction + } + + private fun IrSimpleFunction.signatureRequiresMangling(includeInline: Boolean = true, includeMFVC: Boolean = true) = + fullValueParameterList.any { it.type.getRequiresMangling(includeInline, includeMFVC) } || + context.state.functionsWithInlineClassReturnTypesMangled && + returnType.getRequiresMangling(includeInline = includeInline, includeMFVC = false) + + protected fun typedArgumentList(function: IrFunction, expression: IrMemberAccessExpression<*>) = listOfNotNull( + function.dispatchReceiverParameter?.let { it to expression.dispatchReceiver }, + function.extensionReceiverParameter?.let { it to expression.extensionReceiver } + ) + function.valueParameters.map { it to expression.getValueArgument(it.index) } + + + // We may need to add a bridge method for inline class methods with static replacements. Ideally, we'd do this in BridgeLowering, + // but unfortunately this is a special case in the old backend. The bridge method is not marked as such and does not follow the normal + // visibility rules for bridge methods. + abstract fun createBridgeDeclaration(source: IrSimpleFunction, replacement: IrSimpleFunction, mangledName: Name): IrSimpleFunction + + protected abstract fun createBridgeBody(source: IrSimpleFunction, target: IrSimpleFunction, original: IrFunction, inverted: Boolean) } \ No newline at end of file diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt index 95fb7ccdf76..b3f5ae9776d 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt @@ -370,7 +370,7 @@ private class SyntheticAccessorTransformer( val constructedClass = constructedClass - if (!DescriptorVisibilities.isPrivate(visibility) && !constructedClass.isSingleFieldValueClass && hasMangledParameters && + if (!DescriptorVisibilities.isPrivate(visibility) && !constructedClass.isValue && hasMangledParameters() && !constructedClass.isAnonymousObject ) return true diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/InlineClassAbi.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/InlineClassAbi.kt index 3f4c48ab267..72ecec9d46a 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/InlineClassAbi.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/InlineClassAbi.kt @@ -60,14 +60,14 @@ object InlineClassAbi { fun mangledNameFor(irFunction: IrFunction, mangleReturnTypes: Boolean, useOldMangleRules: Boolean): Name { if (irFunction is IrConstructor) { // Note that we might drop this convention and use standard mangling for constructors too, see KT-37186. - assert(irFunction.constructedClass.isSingleFieldValueClass) { + assert(irFunction.constructedClass.isValue) { "Should not mangle names of non-inline class constructors: ${irFunction.render()}" } return Name.identifier("constructor-impl") } val suffix = hashSuffix(irFunction, mangleReturnTypes, useOldMangleRules) - if (suffix == null && ((irFunction.parent as? IrClass)?.isSingleFieldValueClass != true || irFunction.origin == IrDeclarationOrigin.IR_BUILTINS_STUB)) { + if (suffix == null && ((irFunction.parent as? IrClass)?.isValue != true || irFunction.origin == IrDeclarationOrigin.IR_BUILTINS_STUB)) { return irFunction.name } @@ -101,7 +101,7 @@ object InlineClassAbi { ): String? = collectFunctionSignatureForManglingSuffix( useOldMangleRules, - valueParameters.any { it.requiresMangling }, + valueParameters.any { it.getRequiresMangling() }, // The JVM backend computes mangled names after creating suspend function views, but before default argument // stub insertion. It would be nice if this part of the continuation lowering happened earlier in the pipeline. // TODO: Move suspend function view creation before JvmInlineClassLowering. @@ -124,19 +124,28 @@ object InlineClassAbi { get() = (this as IrSimpleFunction).correspondingPropertySymbol!!.owner.name } -val IrType.requiresMangling: Boolean - get() { - val irClass = erasedUpperBound - return irClass.isSingleFieldValueClass && irClass.fqNameWhenAvailable != StandardNames.RESULT_FQ_NAME +fun IrType.getRequiresMangling(includeInline: Boolean = true, includeMFVC: Boolean = true): Boolean { + val irClass = erasedUpperBound + return irClass.fqNameWhenAvailable != StandardNames.RESULT_FQ_NAME && when { + irClass.isSingleFieldValueClass -> includeInline + irClass.isMultiFieldValueClass -> includeMFVC + else -> false } +} val IrFunction.fullValueParameterList: List get() = listOfNotNull(extensionReceiverParameter) + valueParameters -val IrFunction.hasMangledParameters: Boolean - get() = dispatchReceiverParameter != null && parentAsClass.isSingleFieldValueClass || - fullValueParameterList.any { it.type.requiresMangling } || - (this is IrConstructor && constructedClass.isSingleFieldValueClass) +fun IrFunction.hasMangledParameters(includeInline: Boolean = true, includeMFVC: Boolean = true): Boolean = + (dispatchReceiverParameter != null && when { + parentAsClass.isSingleFieldValueClass -> includeInline + parentAsClass.isMultiFieldValueClass -> includeMFVC + else -> false + }) || fullValueParameterList.any { it.type.getRequiresMangling(includeInline, includeMFVC) } || (this is IrConstructor && when { + constructedClass.isSingleFieldValueClass -> includeInline + constructedClass.isMultiFieldValueClass -> includeMFVC + else -> false + }) val IrFunction.hasMangledReturnType: Boolean get() = returnType.isInlineClassType() && parentClassOrNull?.isFileClass != true @@ -146,10 +155,12 @@ val IrClass.inlineClassFieldName: Name val IrFunction.isInlineClassFieldGetter: Boolean get() = (parent as? IrClass)?.isSingleFieldValueClass == true && this is IrSimpleFunction && extensionReceiverParameter == null && + contextReceiverParametersCount == 0 && !isStatic && correspondingPropertySymbol?.let { it.owner.getter == this && it.owner.name == parentAsClass.inlineClassFieldName } == true val IrFunction.isMultiFieldValueClassFieldGetter: Boolean get() = (parent as? IrClass)?.isMultiFieldValueClass == true && this is IrSimpleFunction && extensionReceiverParameter == null && + contextReceiverParametersCount == 0 && !isStatic && correspondingPropertySymbol?.let { val multiFieldValueClassRepresentation = parentAsClass.multiFieldValueClassRepresentation ?: error("Multi-field value class must have multiFieldValueClassRepresentation: ${parentAsClass.render()}") diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt index fa58f3b88f9..cf56f48a706 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt @@ -143,7 +143,8 @@ class JvmBackendContext( val inlineClassReplacements = MemoizedInlineClassReplacements(state.functionsWithInlineClassReturnTypesMangled, irFactory, this) - val multiFieldValueClassReplacements = MemoizedMultiFieldValueClassReplacements(irFactory, this) + val multiFieldValueClassReplacements = + MemoizedMultiFieldValueClassReplacements(irFactory, this) val continuationClassesVarsCountByType: MutableMap> = hashMapOf() @@ -197,6 +198,20 @@ class JvmBackendContext( multifileFacade.setValue(newPartClasses.toMutableList()) } + for ((staticReplacement, original) in multiFieldValueClassReplacements.originalFunctionForStaticReplacement) { + if (staticReplacement !is IrSimpleFunction) continue + val newOriginal = functionSymbolMap[original.symbol]?.owner ?: continue + val newStaticReplacement = multiFieldValueClassReplacements.getReplacementFunction(newOriginal) ?: continue + functionSymbolMap[staticReplacement.symbol] = newStaticReplacement.symbol + } + + for ((methodReplacement, original) in multiFieldValueClassReplacements.originalFunctionForMethodReplacement) { + if (methodReplacement !is IrSimpleFunction) continue + val newOriginal = functionSymbolMap[original.symbol]?.owner ?: continue + val newMethodReplacement = multiFieldValueClassReplacements.getReplacementFunction(newOriginal) ?: continue + functionSymbolMap[methodReplacement.symbol] = newMethodReplacement.symbol + } + for ((staticReplacement, original) in inlineClassReplacements.originalFunctionForStaticReplacement) { if (staticReplacement !is IrSimpleFunction) continue val newOriginal = functionSymbolMap[original.symbol]?.owner ?: continue diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmCachedDeclarations.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmCachedDeclarations.kt index 0ee749810f4..b3f88dae703 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmCachedDeclarations.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmCachedDeclarations.kt @@ -251,7 +251,8 @@ class JvmCachedDeclarations( defaultImplsRedirections.getOrPut(fakeOverride) { assert(fakeOverride.isFakeOverride) val irClass = fakeOverride.parentAsClass - context.irFactory.buildFun { + val mfvcReplacementStructure = context.multiFieldValueClassReplacements.bindingNewFunctionToParameterTemplateStructure + val redirectFunction = context.irFactory.buildFun { origin = JvmLoweredDeclarationOrigin.SUPER_INTERFACE_METHOD_BRIDGE name = fakeOverride.name visibility = fakeOverride.visibility @@ -275,6 +276,8 @@ class JvmCachedDeclarations( annotations = fakeOverride.annotations copyCorrespondingPropertyFrom(fakeOverride) } + mfvcReplacementStructure[fakeOverride]?.let { mfvcReplacementStructure[redirectFunction] = it } + redirectFunction } fun getRepeatedAnnotationSyntheticContainer(annotationClass: IrClass): IrClass = diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLoweredDeclarationOrigin.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLoweredDeclarationOrigin.kt index fa74ad9706a..42a27c6a9ed 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLoweredDeclarationOrigin.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLoweredDeclarationOrigin.kt @@ -29,9 +29,14 @@ interface JvmLoweredDeclarationOrigin : IrDeclarationOrigin { object ENUM_MAPPINGS_FOR_WHEN : IrDeclarationOriginImpl("ENUM_MAPPINGS_FOR_WHEN", isSynthetic = true) object ENUM_MAPPINGS_FOR_ENTRIES : IrDeclarationOriginImpl("ENUM_MAPPINGS_FOR_ENTRIES", isSynthetic = true) object SYNTHETIC_INLINE_CLASS_MEMBER : IrDeclarationOriginImpl("SYNTHETIC_INLINE_CLASS_MEMBER", isSynthetic = true) + object SYNTHETIC_MULTI_FIELD_VALUE_CLASS_MEMBER : + IrDeclarationOriginImpl("SYNTHETIC_MULTI_FIELD_VALUE_CLASS_MEMBER", isSynthetic = true) object INLINE_CLASS_GENERATED_IMPL_METHOD : IrDeclarationOriginImpl("INLINE_CLASS_GENERATED_IMPL_METHOD") + object MULTI_FIELD_VALUE_CLASS_GENERATED_IMPL_METHOD : IrDeclarationOriginImpl("MULTI_FIELD_VALUE_CLASS_GENERATED_IMPL_METHOD") object STATIC_INLINE_CLASS_REPLACEMENT : IrDeclarationOriginImpl("STATIC_INLINE_CLASS_REPLACEMENT") + object STATIC_MULTI_FIELD_VALUE_CLASS_REPLACEMENT : IrDeclarationOriginImpl("STATIC_MULTI_FIELD_VALUE_CLASS_REPLACEMENT") object STATIC_INLINE_CLASS_CONSTRUCTOR : IrDeclarationOriginImpl("STATIC_INLINE_CLASS_CONSTRUCTOR") + object STATIC_MULTI_FIELD_VALUE_CLASS_CONSTRUCTOR : IrDeclarationOriginImpl("STATIC_MULTI_FIELD_VALUE_CLASS_CONSTRUCTOR") object GENERATED_ASSERTION_ENABLED_FIELD : IrDeclarationOriginImpl("GENERATED_ASSERTION_ENABLED_FIELD", isSynthetic = true) object GENERATED_EXTENDED_MAIN : IrDeclarationOriginImpl("GENERATED_EXTENDED_MAIN", isSynthetic = true) object SUSPEND_IMPL_STATIC_FUNCTION : IrDeclarationOriginImpl("SUSPEND_IMPL_STATIC_FUNCTION", isSynthetic = true) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedInlineClassReplacements.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedInlineClassReplacements.kt index 1060c6c1cac..0e5d339bbd9 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedInlineClassReplacements.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedInlineClassReplacements.kt @@ -5,25 +5,26 @@ package org.jetbrains.kotlin.backend.jvm -import org.jetbrains.kotlin.backend.jvm.ir.* +import org.jetbrains.kotlin.backend.jvm.ir.classFileContainsMethod +import org.jetbrains.kotlin.backend.jvm.ir.extensionReceiverName +import org.jetbrains.kotlin.backend.jvm.ir.isStaticValueClassReplacement +import org.jetbrains.kotlin.backend.jvm.ir.parentClassId import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper import org.jetbrains.kotlin.descriptors.DescriptorVisibilities import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.ir.IrBuiltIns import org.jetbrains.kotlin.ir.builders.declarations.addValueParameter import org.jetbrains.kotlin.ir.builders.declarations.buildFun -import org.jetbrains.kotlin.ir.builders.declarations.buildProperty import org.jetbrains.kotlin.ir.declarations.* -import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl import org.jetbrains.kotlin.ir.types.impl.IrStarProjectionImpl -import org.jetbrains.kotlin.ir.types.isInt import org.jetbrains.kotlin.ir.util.* import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.InlineClassDescriptorResolver import org.jetbrains.kotlin.storage.LockBasedStorageManager import org.jetbrains.kotlin.utils.addToStdlib.safeAs +import org.jetbrains.kotlin.utils.alwaysNull import java.util.concurrent.ConcurrentHashMap /** @@ -35,10 +36,9 @@ class MemoizedInlineClassReplacements( context: JvmBackendContext ) : MemoizedValueClassAbstractReplacements(irFactory, context) { private val storageManager = LockBasedStorageManager("inline-class-replacements") - private val propertyMap = ConcurrentHashMap() - override val originalFunctionForStaticReplacement: MutableMap = ConcurrentHashMap() - internal val originalFunctionForMethodReplacement: MutableMap = ConcurrentHashMap() + val originalFunctionForStaticReplacement: MutableMap = ConcurrentHashMap() + val originalFunctionForMethodReplacement: MutableMap = ConcurrentHashMap() /** * Get a replacement for a function or a constructor. @@ -49,7 +49,9 @@ class MemoizedInlineClassReplacements( // Don't mangle anonymous or synthetic functions, except for generated SAM wrapper methods (it.isLocal && it is IrSimpleFunction && it.overriddenSymbols.isEmpty()) || (it.origin == IrDeclarationOrigin.DELEGATED_PROPERTY_ACCESSOR && it.visibility == DescriptorVisibilities.LOCAL) || - it.isStaticInlineClassReplacement || + it.isStaticValueClassReplacement || + it in context.multiFieldValueClassReplacements.bindingNewFunctionToParameterTemplateStructure || + it.origin == JvmLoweredDeclarationOrigin.MULTI_FIELD_VALUE_CLASS_GENERATED_IMPL_METHOD || it.origin.isSynthetic && it.origin != IrDeclarationOrigin.SYNTHETIC_GENERATED_SAM_IMPLEMENTATION -> null @@ -64,7 +66,7 @@ class MemoizedInlineClassReplacements( when { it.isRemoveAtSpecialBuiltinStub() -> null - it.isInlineClassMemberFakeOverriddenFromJvmDefaultInterfaceMethod() || + it.isValueClassMemberFakeOverriddenFromJvmDefaultInterfaceMethod() || it.origin == IrDeclarationOrigin.IR_BUILTINS_STUB -> createMethodReplacement(it) else -> @@ -72,7 +74,8 @@ class MemoizedInlineClassReplacements( } // Otherwise, mangle functions with mangled parameters, ignoring constructors - it is IrSimpleFunction && !it.isFromJava() && (it.hasMangledParameters || mangleReturnTypes && it.hasMangledReturnType) -> + it is IrSimpleFunction && !it.isFromJava() && + (it.hasMangledParameters(includeMFVC = false) || mangleReturnTypes && it.hasMangledReturnType) -> createMethodReplacement(it) else -> @@ -80,29 +83,6 @@ class MemoizedInlineClassReplacements( } } - private fun IrFunction.isRemoveAtSpecialBuiltinStub() = - origin == IrDeclarationOrigin.IR_BUILTINS_STUB && - name.asString() == "remove" && - valueParameters.size == 1 && - valueParameters[0].type.isInt() - - private fun IrFunction.isInlineClassMemberFakeOverriddenFromJvmDefaultInterfaceMethod(): Boolean { - if (this !is IrSimpleFunction) return false - if (!this.isFakeOverride) return false - val parentClass = parentClassOrNull ?: return false - if (!parentClass.isSingleFieldValueClass) return false - - val overridden = resolveFakeOverride() ?: return false - if (!overridden.parentAsClass.isJvmInterface) return false - if (overridden.modality == Modality.ABSTRACT) return false - - // We have a non-abstract interface member. - // It is a JVM default interface method if one of the following conditions are true: - // - it is a Java method, - // - it is a Kotlin function compiled to JVM default interface method. - return overridden.isFromJava() || overridden.isCompiledToJvmDefault(context.state.jvmDefaultMode) - } - /** * Get the box function for an inline class. Concretely, this is a synthetic * static function named "box-impl" which takes an unboxed value and returns @@ -148,7 +128,7 @@ class MemoizedInlineClassReplacements( return specializedEqualsCache.computeIfAbsent(irClass) { irFactory.buildFun { name = InlineClassDescriptorResolver.SPECIALIZED_EQUALS_NAME - // TODO: Revisit this once we allow user defined equals methods in inline classes. + // TODO: Revisit this once we allow user defined equals methods in inline/multi-field value classes. origin = JvmLoweredDeclarationOrigin.INLINE_CLASS_GENERATED_IMPL_METHOD returnType = irBuiltIns.booleanType }.apply { @@ -168,7 +148,7 @@ class MemoizedInlineClassReplacements( } } - private fun createMethodReplacement(function: IrFunction): IrSimpleFunction = + override fun createMethodReplacement(function: IrFunction): IrSimpleFunction = buildReplacement(function, function.origin) { originalFunctionForMethodReplacement[this] = function dispatchReceiverParameter = function.dispatchReceiverParameter?.copyTo(this, index = -1) @@ -184,9 +164,14 @@ class MemoizedInlineClassReplacements( it.defaultValue = parameter.defaultValue?.patchDeclarationParents(this) } } + context.multiFieldValueClassReplacements.run { + bindingNewFunctionToParameterTemplateStructure[function]?.also { + bindingNewFunctionToParameterTemplateStructure[this@buildReplacement] = it + } + } } - private fun createStaticReplacement(function: IrFunction): IrSimpleFunction = + override fun createStaticReplacement(function: IrFunction): IrSimpleFunction = buildReplacement(function, JvmLoweredDeclarationOrigin.STATIC_INLINE_CLASS_REPLACEMENT, noFakeOverride = true) { originalFunctionForStaticReplacement[this] = function @@ -219,6 +204,11 @@ class MemoizedInlineClassReplacements( } } valueParameters = newValueParameters + context.multiFieldValueClassReplacements.run { + bindingNewFunctionToParameterTemplateStructure[function]?.also { + bindingNewFunctionToParameterTemplateStructure[this@buildReplacement] = it + } + } } private fun buildReplacement( @@ -246,8 +236,7 @@ class MemoizedInlineClassReplacements( noFakeOverride: Boolean, useOldManglingScheme: Boolean, body: IrFunction.() -> Unit, - ): IrSimpleFunction = irFactory.buildFun { - updateFrom(function) + ): IrSimpleFunction = commonBuildReplacementInner(function, noFakeOverride, body) { if (function is IrConstructor) { // The [updateFrom] call will set the modality to FINAL for constructors, while the JVM backend would use OPEN here. modality = Modality.OPEN @@ -260,62 +249,15 @@ class MemoizedInlineClassReplacements( else -> replacementOrigin } - if (noFakeOverride) { - isFakeOverride = false - } name = InlineClassAbi.mangledNameFor(function, mangleReturnTypes, useOldManglingScheme) - returnType = function.returnType - }.apply { - parent = function.parent - annotations = function.annotations - copyTypeParameters(function.allTypeParameters) - if (function.metadata != null) { - metadata = function.metadata - function.metadata = null - } - copyAttributes(function as? IrAttributeContainer) - - if (function is IrSimpleFunction) { - val propertySymbol = function.correspondingPropertySymbol - if (propertySymbol != null) { - val property = propertyMap.getOrPut(propertySymbol) { - irFactory.buildProperty { - name = propertySymbol.owner.name - updateFrom(propertySymbol.owner) - }.apply { - parent = propertySymbol.owner.parent - copyAttributes(propertySymbol.owner) - annotations = propertySymbol.owner.annotations - // 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 unlowered. - backingField = context.cachedDeclarations.getStaticBackingField(propertySymbol.owner) - ?: propertySymbol.owner.backingField - } - } - correspondingPropertySymbol = property.symbol - when (function) { - propertySymbol.owner.getter -> property.getter = this - propertySymbol.owner.setter -> property.setter = this - else -> error("Orphaned property getter/setter: ${function.render()}") - } - } - - overriddenSymbols = replaceOverriddenSymbols(function) - } - - body() } + override val getReplacementForRegularClassConstructor: (IrConstructor) -> IrConstructor? = alwaysNull() + override val replaceOverriddenSymbols: (IrSimpleFunction) -> List = storageManager.createMemoizedFunction { irSimpleFunction -> irSimpleFunction.overriddenSymbols.map { computeOverrideReplacement(it.owner).symbol } } - - private fun computeOverrideReplacement(function: IrSimpleFunction): IrSimpleFunction = - getReplacementFunction(function) ?: function.also { - function.overriddenSymbols = replaceOverriddenSymbols(function) - } } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedMultiFieldValueClassReplacements.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedMultiFieldValueClassReplacements.kt index bac2f39420b..08950704183 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedMultiFieldValueClassReplacements.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedMultiFieldValueClassReplacements.kt @@ -5,11 +5,24 @@ package org.jetbrains.kotlin.backend.jvm -import org.jetbrains.kotlin.ir.declarations.IrFactory -import org.jetbrains.kotlin.ir.declarations.IrFunction -import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction +import org.jetbrains.kotlin.backend.jvm.MemoizedMultiFieldValueClassReplacements.RemappedParameter.MultiFieldValueClassMapping +import org.jetbrains.kotlin.backend.jvm.ir.erasedUpperBound +import org.jetbrains.kotlin.backend.jvm.ir.extensionReceiverName +import org.jetbrains.kotlin.backend.jvm.ir.findSuperDeclaration +import org.jetbrains.kotlin.backend.jvm.ir.isStaticValueClassReplacement +import org.jetbrains.kotlin.descriptors.DescriptorVisibilities +import org.jetbrains.kotlin.ir.builders.declarations.addValueParameter +import org.jetbrains.kotlin.ir.builders.declarations.buildConstructor +import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol +import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol +import org.jetbrains.kotlin.ir.types.IrSimpleType +import org.jetbrains.kotlin.ir.types.IrType +import org.jetbrains.kotlin.ir.types.defaultType +import org.jetbrains.kotlin.ir.util.* +import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.storage.LockBasedStorageManager +import org.jetbrains.kotlin.utils.addToStdlib.safeAs import java.util.concurrent.ConcurrentHashMap /** @@ -21,17 +34,281 @@ class MemoizedMultiFieldValueClassReplacements( ) : MemoizedValueClassAbstractReplacements(irFactory, context) { private val storageManager = LockBasedStorageManager("multi-field-value-class-replacements") - override val originalFunctionForStaticReplacement: MutableMap = ConcurrentHashMap() - internal val originalFunctionForMethodReplacement: MutableMap = ConcurrentHashMap() + val originalFunctionForStaticReplacement: MutableMap = ConcurrentHashMap() + val originalFunctionForMethodReplacement: MutableMap = ConcurrentHashMap() + private val originalConstructorForConstructorReplacement: MutableMap = ConcurrentHashMap() + + private fun IrValueParameter.grouped( + name: String?, + substitutionMap: Map, + targetFunction: IrFunction, + originWhenFlattened: IrDeclarationOrigin, + ): RemappedParameter { + if (!type.needsMfvcFlattening()) return RemappedParameter.RegularMapping( + targetFunction.addValueParameter { + updateFrom(this@grouped) + this.name = this@grouped.name + index = targetFunction.valueParameters.size + }.apply { + copyAnnotationsFrom(this@grouped) + } + ) + val rootMfvcNode = this@MemoizedMultiFieldValueClassReplacements.getRootMfvcNode(type.erasedUpperBound)!! + require(!hasDefaultValue()) { "Default parameters values are not supported for multi-field value classes" } + val newType = type.substitute(substitutionMap) as IrSimpleType + val localSubstitutionMap = makeTypeArgumentsFromType(newType) + val valueParameters = rootMfvcNode.mapLeaves { leaf -> + targetFunction.addValueParameter { + updateFrom(this@grouped) + this.name = Name.identifier("${name ?: this@grouped.name}-${leaf.fullFieldName}") + type = leaf.type.substitute(localSubstitutionMap) + origin = originWhenFlattened + index = targetFunction.valueParameters.size + }.apply { + defaultValue = null + copyAnnotationsFrom(this@grouped) + } + } + return MultiFieldValueClassMapping(rootMfvcNode, newType, valueParameters) + } + + private fun List.grouped( + name: String?, + substitutionMap: Map, + targetFunction: IrFunction, + originWhenFlattened: IrDeclarationOrigin, + ): List = map { it.grouped(name, substitutionMap, targetFunction, originWhenFlattened) } + + private fun buildReplacement( + function: IrFunction, + replacementOrigin: IrDeclarationOrigin, + noFakeOverride: Boolean = false, + body: IrFunction.() -> Unit, + ): IrSimpleFunction = commonBuildReplacementInner(function, noFakeOverride, body) { + origin = when { + function.origin == IrDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_MEMBER -> + JvmLoweredDeclarationOrigin.MULTI_FIELD_VALUE_CLASS_GENERATED_IMPL_METHOD + + function is IrConstructor && function.constructedClass.isMultiFieldValueClass -> + JvmLoweredDeclarationOrigin.STATIC_MULTI_FIELD_VALUE_CLASS_CONSTRUCTOR + + else -> replacementOrigin + } + name = InlineClassAbi.mangledNameFor(function, mangleReturnTypes = false, useOldMangleRules = false) + } + + private fun makeAndAddGroupedValueParametersFrom( + sourceFunction: IrFunction, + includeDispatcherReceiver: Boolean, + substitutionMap: Map, + targetFunction: IrFunction, + ): List { + val newFlattenedParameters = mutableListOf() + if (sourceFunction.dispatchReceiverParameter != null && includeDispatcherReceiver) { + newFlattenedParameters.add( + sourceFunction.parentAsClass.thisReceiver!!.grouped( + "\$dispatchReceiver", + substitutionMap, + targetFunction, + IrDeclarationOrigin.MOVED_DISPATCH_RECEIVER, + ) + ) + } + val contextReceivers = sourceFunction.valueParameters.take(sourceFunction.contextReceiverParametersCount) + .mapIndexed { index: Int, valueParameter: IrValueParameter -> + valueParameter.grouped( + "contextReceiver$index", + substitutionMap, + targetFunction, + IrDeclarationOrigin.MOVED_CONTEXT_RECEIVER, + ) + } + newFlattenedParameters.addAll(contextReceivers) + sourceFunction.extensionReceiverParameter?.let { + val newParameters = it.grouped( + sourceFunction.extensionReceiverName(context.state), + substitutionMap, + targetFunction, + IrDeclarationOrigin.MOVED_EXTENSION_RECEIVER, + ) + newFlattenedParameters.add(newParameters) + } + newFlattenedParameters += sourceFunction.valueParameters.drop(sourceFunction.contextReceiverParametersCount) + .grouped(name = null, substitutionMap, targetFunction, IrDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_PARAMETER) + return newFlattenedParameters + } + + sealed class RemappedParameter { + + abstract val valueParameters: List + + data class RegularMapping(val valueParameter: IrValueParameter) : RemappedParameter() { + override val valueParameters: List = listOf(valueParameter) + } + + data class MultiFieldValueClassMapping( + val rootMfvcNode: RootMfvcNode, + val typeArguments: TypeArguments, + override val valueParameters: List, + ) : RemappedParameter() { + init { + require(valueParameters.size > 1) { "MFVC must have > 1 fields" } + } + + constructor(rootMfvcNode: RootMfvcNode, type: IrSimpleType, valueParameters: List) : + this(rootMfvcNode, makeTypeArgumentsFromType(type), valueParameters) + + val boxedType: IrSimpleType = rootMfvcNode.type.substitute(typeArguments) as IrSimpleType + } + } + + val bindingOldFunctionToParameterTemplateStructure: MutableMap> = ConcurrentHashMap() + val bindingNewFunctionToParameterTemplateStructure: MutableMap> = + object : ConcurrentHashMap>() { + override fun put(key: IrFunction, value: List): List? { + require(key.explicitParametersCount == value.sumOf { it.valueParameters.size }) { + "Illegal structure $value for function ${key.dump()}" + } + return super.put(key, value) + } + } + + override fun createStaticReplacement(function: IrFunction): IrSimpleFunction = + buildReplacement(function, JvmLoweredDeclarationOrigin.STATIC_MULTI_FIELD_VALUE_CLASS_REPLACEMENT, noFakeOverride = true) { + originalFunctionForStaticReplacement[this] = function + typeParameters = listOf() + copyTypeParametersFrom(function.parentAsClass) + val substitutionMap = function.parentAsClass.typeParameters.map { it.symbol }.zip(typeParameters.map { it.defaultType }).toMap() + copyTypeParametersFrom(function, parameterMap = (function.parentAsClass.typeParameters zip typeParameters).toMap()) + val newFlattenedParameters = + makeAndAddGroupedValueParametersFrom(function, includeDispatcherReceiver = true, substitutionMap, this) + bindingOldFunctionToParameterTemplateStructure[function] = newFlattenedParameters + bindingNewFunctionToParameterTemplateStructure[this] = newFlattenedParameters + } + + override fun createMethodReplacement(function: IrFunction): IrSimpleFunction = buildReplacement(function, function.origin) { + originalFunctionForMethodReplacement[this] = function + dispatchReceiverParameter = function.dispatchReceiverParameter?.copyTo(this, index = -1) + val newFlattenedParameters = makeAndAddGroupedValueParametersFrom(function, includeDispatcherReceiver = false, mapOf(), this) + val receiver = dispatchReceiverParameter + val remappedParameters = + if (receiver != null) listOf(RemappedParameter.RegularMapping(receiver)) + newFlattenedParameters else newFlattenedParameters + bindingOldFunctionToParameterTemplateStructure[function] = remappedParameters + bindingNewFunctionToParameterTemplateStructure[this] = remappedParameters + } + + private fun createConstructorReplacement(constructor: IrConstructor): IrConstructor { + val newConstructor = irFactory.buildConstructor { + updateFrom(constructor) + returnType = constructor.returnType + }.apply { + val newFlattenedParameters = makeAndAddGroupedValueParametersFrom(constructor, includeDispatcherReceiver = false, mapOf(), this) + bindingOldFunctionToParameterTemplateStructure[constructor] = newFlattenedParameters + parent = constructor.parent + copyTypeParametersFrom(constructor) + annotations = constructor.annotations + originalConstructorForConstructorReplacement[this] = constructor + bindingNewFunctionToParameterTemplateStructure[this] = newFlattenedParameters + } + return newConstructor + } /** - * Get a replacement for a function or a constructor. + * Get a function replacement for a function or a constructor. */ - override val getReplacementFunction: (IrFunction) -> IrSimpleFunction? = storageManager.createMemoizedFunctionWithNullableValues { - TODO() + override val getReplacementFunction: (IrFunction) -> IrSimpleFunction? = + storageManager.createMemoizedFunctionWithNullableValues { function -> + when { + (function.isLocal && function is IrSimpleFunction && function.overriddenSymbols.isEmpty()) || + (function.origin == IrDeclarationOrigin.DELEGATED_PROPERTY_ACCESSOR && function.visibility == DescriptorVisibilities.LOCAL) || + function.isStaticValueClassReplacement || + function.origin == IrDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_MEMBER && function.isAccessor || + function.origin == JvmLoweredDeclarationOrigin.MULTI_FIELD_VALUE_CLASS_GENERATED_IMPL_METHOD || + function.origin.isSynthetic && function.origin != IrDeclarationOrigin.SYNTHETIC_GENERATED_SAM_IMPLEMENTATION -> null + + // Do not check for overridden symbols because it makes previously overriding function not overriding would break a code. + function.isMultiFieldValueClassFieldGetter -> makeMultiFieldValueClassFieldGetterReplacement(function) + function.parent.safeAs()?.isMultiFieldValueClass == true -> when { + function.isRemoveAtSpecialBuiltinStub() -> + null + + function.isValueClassMemberFakeOverriddenFromJvmDefaultInterfaceMethod() || + function.origin == IrDeclarationOrigin.IR_BUILTINS_STUB -> + createMethodReplacement(function) + + else -> + createStaticReplacement(function) + } + + function is IrSimpleFunction && !function.isFromJava() && + function.fullValueParameterList.any { it.type.needsMfvcFlattening() } && + (!function.isFakeOverride || + findSuperDeclaration(function, false, context.state.jvmDefaultMode) + in bindingOldFunctionToParameterTemplateStructure) -> + createMethodReplacement(function) + + else -> null + } + } + + private fun makeMultiFieldValueClassFieldGetterReplacement(function: IrFunction): IrSimpleFunction { + require(function is IrSimpleFunction && function.isMultiFieldValueClassFieldGetter) { "Illegal function:\n${function.dump()}" } + val replacement = getMfvcPropertyNode(function.correspondingPropertySymbol!!.owner)!!.unboxMethod + originalFunctionForMethodReplacement[replacement] = function + val templateParameters = listOf(RemappedParameter.RegularMapping(replacement.dispatchReceiverParameter!!)) + bindingNewFunctionToParameterTemplateStructure[replacement] = templateParameters + bindingOldFunctionToParameterTemplateStructure[function] = templateParameters + return replacement } - override val replaceOverriddenSymbols: (IrSimpleFunction) -> List = storageManager.createMemoizedFunction { - TODO() + override val getReplacementForRegularClassConstructor: (IrConstructor) -> IrConstructor? = + storageManager.createMemoizedFunctionWithNullableValues { constructor -> + when { + constructor.constructedClass.isMultiFieldValueClass -> null + constructor.isFromJava() -> null + constructor.fullValueParameterList.any { it.type.needsMfvcFlattening() } -> + createConstructorReplacement(constructor) + + else -> null + } + } + + + override val replaceOverriddenSymbols: (IrSimpleFunction) -> List = + storageManager.createMemoizedFunction { irSimpleFunction -> + irSimpleFunction.overriddenSymbols.map { + computeOverrideReplacement(it.owner).symbol + } + } + + val getRootMfvcNode: (IrClass) -> RootMfvcNode? = storageManager.createMemoizedFunctionWithNullableValues { + if (it.defaultType.needsMfvcFlattening()) getRootNode(context, it) else null } + + val getRegularClassMfvcPropertyNode: (IrProperty) -> IntermediateMfvcNode? = + storageManager.createMemoizedFunctionWithNullableValues { property: IrProperty -> + val parent = property.parent + when { + parent !is IrClass -> null + property.isFakeOverride -> null + property.getter.let { it != null && (it.contextReceiverParametersCount > 0 || it.extensionReceiverParameter != null) } -> null + useRootNode(parent, property) -> null + property.run { backingField?.type ?: getter?.returnType }?.needsMfvcFlattening() != true -> null + else -> createIntermediateNodeForMfvcPropertyOfRegularClass(parent, context, property) + } + } + + fun getMfvcPropertyNode(property: IrProperty): NameableMfvcNode? { + val parent = property.parent + return when { + parent !is IrClass -> null + useRootNode(parent, property) -> getRootMfvcNode(parent)!![property.name] + else -> getRegularClassMfvcPropertyNode(property) + } + } + + private fun useRootNode( + parent: IrClass, + property: IrProperty + ) = parent.isMultiFieldValueClass && (property.getter?.isStatic ?: property.backingField?.isStatic) == false } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedValueClassAbstractReplacements.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedValueClassAbstractReplacements.kt index e94c6cd2088..1c7536e77cf 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedValueClassAbstractReplacements.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedValueClassAbstractReplacements.kt @@ -5,18 +5,113 @@ package org.jetbrains.kotlin.backend.jvm -import org.jetbrains.kotlin.ir.declarations.IrFactory -import org.jetbrains.kotlin.ir.declarations.IrFunction -import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction +import org.jetbrains.kotlin.backend.jvm.ir.isCompiledToJvmDefault +import org.jetbrains.kotlin.backend.jvm.ir.isJvmInterface +import org.jetbrains.kotlin.descriptors.Modality +import org.jetbrains.kotlin.ir.builders.declarations.IrFunctionBuilder +import org.jetbrains.kotlin.ir.builders.declarations.buildFun +import org.jetbrains.kotlin.ir.builders.declarations.buildProperty +import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol +import org.jetbrains.kotlin.ir.types.isInt +import org.jetbrains.kotlin.ir.util.* +import java.util.concurrent.ConcurrentHashMap abstract class MemoizedValueClassAbstractReplacements(protected val irFactory: IrFactory, protected val context: JvmBackendContext) { + private val propertyMap = ConcurrentHashMap() + /** * Get a replacement for a function or a constructor. */ abstract val getReplacementFunction: (IrFunction) -> IrSimpleFunction? - abstract val originalFunctionForStaticReplacement: MutableMap + protected fun IrFunction.isRemoveAtSpecialBuiltinStub() = + origin == IrDeclarationOrigin.IR_BUILTINS_STUB && + name.asString() == "remove" && + valueParameters.size == 1 && + valueParameters[0].type.isInt() + + protected fun IrFunction.isValueClassMemberFakeOverriddenFromJvmDefaultInterfaceMethod(): Boolean { + if (this !is IrSimpleFunction) return false + if (!this.isFakeOverride) return false + val parentClass = parentClassOrNull ?: return false + require(parentClass.isValue) + + val overridden = resolveFakeOverride() ?: return false + if (!overridden.parentAsClass.isJvmInterface) return false + if (overridden.modality == Modality.ABSTRACT) return false + + // We have a non-abstract interface member. + // It is a JVM default interface method if one of the following conditions are true: + // - it is a Java method, + // - it is a Kotlin function compiled to JVM default interface method. + return overridden.isFromJava() || overridden.isCompiledToJvmDefault(context.state.jvmDefaultMode) + } + + protected abstract fun createStaticReplacement(function: IrFunction): IrSimpleFunction + protected abstract fun createMethodReplacement(function: IrFunction): IrSimpleFunction + + protected fun commonBuildReplacementInner( + function: IrFunction, + noFakeOverride: Boolean, + body: IrFunction.() -> Unit, + builderBody: IrFunctionBuilder.() -> Unit, + ): IrSimpleFunction = irFactory.buildFun { + updateFrom(function) + builderBody() + if (noFakeOverride) { + isFakeOverride = false + } + returnType = function.returnType + }.apply { + parent = function.parent + annotations = function.annotations + copyTypeParameters(function.allTypeParameters) + if (function.metadata != null) { + metadata = function.metadata + function.metadata = null + } + copyAttributes(function as? IrAttributeContainer) + + if (function is IrSimpleFunction) { + val propertySymbol = function.correspondingPropertySymbol + if (propertySymbol != null) { + val property = propertyMap.getOrPut(propertySymbol) { + irFactory.buildProperty { + name = propertySymbol.owner.name + updateFrom(propertySymbol.owner) + }.apply { + parent = propertySymbol.owner.parent + copyAttributes(propertySymbol.owner) + annotations = propertySymbol.owner.annotations + // 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 unlowered. + backingField = context.cachedDeclarations.getStaticBackingField(propertySymbol.owner) + ?: propertySymbol.owner.backingField + } + } + correspondingPropertySymbol = property.symbol + when (function) { + propertySymbol.owner.getter -> property.getter = this + propertySymbol.owner.setter -> property.setter = this + else -> error("Orphaned property getter/setter: ${function.render()}") + } + } + + overriddenSymbols = replaceOverriddenSymbols(function) + } + + body() + } abstract val replaceOverriddenSymbols: (IrSimpleFunction) -> List + + abstract val getReplacementForRegularClassConstructor: (IrConstructor) -> IrConstructor? + + protected fun computeOverrideReplacement(function: IrSimpleFunction): IrSimpleFunction = + getReplacementFunction(function) ?: function.also { + function.overriddenSymbols = replaceOverriddenSymbols(function) + } } \ No newline at end of file diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNode.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNode.kt new file mode 100644 index 00000000000..2af2d73dff2 --- /dev/null +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNode.kt @@ -0,0 +1,457 @@ +/* + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.backend.jvm + +import org.jetbrains.kotlin.backend.jvm.ir.erasedUpperBound +import org.jetbrains.kotlin.backend.jvm.ir.isMultiFieldValueClassType +import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper +import org.jetbrains.kotlin.ir.builders.IrBlockBuilder +import org.jetbrains.kotlin.ir.builders.IrBuilderWithScope +import org.jetbrains.kotlin.ir.builders.irCall +import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.expressions.IrExpression +import org.jetbrains.kotlin.ir.expressions.IrGetField +import org.jetbrains.kotlin.ir.expressions.IrReturn +import org.jetbrains.kotlin.ir.symbols.IrClassSymbol +import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol +import org.jetbrains.kotlin.ir.types.* +import org.jetbrains.kotlin.ir.util.* +import org.jetbrains.kotlin.load.java.JvmAbi +import org.jetbrains.kotlin.name.Name + +typealias TypeArguments = Map + +sealed interface MfvcNode { + val type: IrType + val leavesCount: Int + + fun createInstanceFromBox( + scope: IrBlockBuilder, + typeArguments: TypeArguments, + receiver: IrExpression?, + accessType: AccessType, + saveVariable: (IrVariable) -> Unit, + ): ReceiverBasedMfvcNodeInstance +} + +fun MfvcNode.createInstanceFromBox( + scope: IrBlockBuilder, + receiver: IrExpression, + accessType: AccessType, + saveVariable: (IrVariable) -> Unit +) = + createInstanceFromBox(scope, makeTypeArgumentsFromType(receiver.type as IrSimpleType), receiver, accessType, saveVariable) + +fun MfvcNode.createInstanceFromValueDeclarationsAndBoxType( + scope: IrBuilderWithScope, type: IrSimpleType, name: Name, saveVariable: (IrVariable) -> Unit, +): ValueDeclarationMfvcNodeInstance = createInstanceFromValueDeclarations(scope, makeTypeArgumentsFromType(type), name, saveVariable) + +fun MfvcNode.createInstanceFromValueDeclarations( + scope: IrBuilderWithScope, typeArguments: TypeArguments, name: Name, saveVariable: (IrVariable) -> Unit, +): ValueDeclarationMfvcNodeInstance { + val valueDeclarations = mapLeaves { + scope.savableStandaloneVariable( + type = it.type, + name = listOf(name, it.fullFieldName).joinToString("-"), + origin = IrDeclarationOrigin.MULTI_FIELD_VALUE_CLASS_REPRESENTATION_VARIABLE, + saveVariable = saveVariable + ) + } + return ValueDeclarationMfvcNodeInstance(this, typeArguments, valueDeclarations) +} + +fun MfvcNode.createInstanceFromValueDeclarationsAndBoxType( + type: IrSimpleType, fieldValues: List +): ValueDeclarationMfvcNodeInstance = + ValueDeclarationMfvcNodeInstance(this, makeTypeArgumentsFromType(type), fieldValues) + +fun makeTypeArgumentsFromType(type: IrSimpleType): TypeArguments { + if (type.classifierOrNull !is IrClassSymbol) return mapOf() + val parameters = type.erasedUpperBound.typeParameters + val arguments = type.arguments + require(parameters.size == arguments.size) { + "Number of type parameters (${parameters.joinToString { it.render() }}) is not equal to number of type arguments (${arguments.joinToString { it.render() }})." + } + return parameters.zip(arguments) { parameter, argument -> parameter.symbol to (argument.typeOrNull ?: parameter.defaultType) }.toMap() + +} + +sealed interface NameableMfvcNode : MfvcNode { + val namedNodeImpl: NameableMfvcNodeImpl +} + +val NameableMfvcNode.nameParts: List + get() = namedNodeImpl.nameParts +val NameableMfvcNode.name: Name + get() = nameParts.last().name +val NameableMfvcNode.index: Int + get() = nameParts.last().index +val NameableMfvcNode.unboxMethod: IrSimpleFunction + get() = namedNodeImpl.unboxMethod +val NameableMfvcNode.fullMethodName: Name + get() = namedNodeImpl.fullMethodName +val NameableMfvcNode.fullFieldName: Name + get() = namedNodeImpl.fullFieldName +val NameableMfvcNode.hasPureUnboxMethod: Boolean + get() = namedNodeImpl.hasPureUnboxMethod + + +data class IndexedNamePart(val index: Int, val name: Name) + +class NameableMfvcNodeImpl( + rootPropertyName: String?, + val nameParts: List, + val unboxMethod: IrSimpleFunction, + val hasPureUnboxMethod: Boolean, +) { + val fullMethodName = makeFullMethodName(rootPropertyName, nameParts) + val fullFieldName = makeFullFieldName(rootPropertyName, nameParts) + + companion object { + @JvmStatic + fun makeFullMethodName(rootPropertyName: String?, nameParts: List): Name = if (rootPropertyName == null) { + val restJoined = nameParts.joinToString("-") { it.index.toString() } + Name.identifier("${KotlinTypeMapper.UNBOX_JVM_METHOD_NAME}-$restJoined") + } else { + val wholeName = (listOf(JvmAbi.getterName(rootPropertyName)) + nameParts.map { it.index.toString() }).joinToString("-") + Name.identifier(wholeName) + } + + @JvmStatic + fun makeFullFieldName(rootPropertyName: String?, nameParts: List): Name { + val joined = (listOf(rootPropertyName ?: "field") + nameParts.map { it.index.toString() }).joinToString("-") + return Name.identifier(joined) + } + } +} + +fun MfvcNode.getSubnodeAndIndices(name: Name): Pair? { + val node = (this as? MfvcNodeWithSubnodes)?.get(name) ?: return null + val indices = subnodeIndices[node] ?: error("existing node without indices") + return node to indices +} + +sealed interface MfvcNodeWithSubnodes : MfvcNode { + abstract override val type: IrSimpleType + val boxMethod: IrSimpleFunction + val leavesUnboxMethods: List? + val subnodesImpl: MfvcNodeWithSubnodesImpl +} + +fun MfvcNodeWithSubnodes.makeBoxedExpression( + scope: IrBuilderWithScope, typeArguments: TypeArguments, valueArguments: List +): IrExpression = scope.irCall(boxMethod).apply { + val resultType = type.substitute(typeArguments) as IrSimpleType + require(resultType.erasedUpperBound == type.erasedUpperBound) { "Substitution of $type led to $resultType" } + for ((index, typeArgument) in resultType.arguments.withIndex()) { + putTypeArgument(index, typeArgument.typeOrNull ?: resultType.erasedUpperBound.typeParameters[index].defaultType) + } + for ((index, valueArgument) in valueArguments.withIndex()) { + putValueArgument(index, valueArgument) + } +} + +operator fun MfvcNodeWithSubnodes.get(names: List): MfvcNode? { + var cur: MfvcNode = this + for (name in names) { + cur = (cur as? MfvcNodeWithSubnodes)?.get(name) ?: return null + } + return cur +} + +private fun List.allEqual() = all { it == first() } + +class MfvcNodeWithSubnodesImpl(val subnodes: List, unboxMethod: IrSimpleFunction?) { + init { + require(subnodes.isNotEmpty()) + require(subnodes.map { it.nameParts.dropLast(1) }.allEqual()) + require(subnodes.map { it.index } == subnodes.indices.toList()) + } + + private val mapping = subnodes.associateBy { it.name }.also { mapping -> + require(mapping.size == subnodes.size) { + subnodes + .groupBy { it.name } + .filterValues { it.size > 1 } + .entries.joinToString(prefix = "Repeating node names found: ") { (name, nodes) -> "${nodes.size} nodes with name '$name'" } + } + } + + operator fun get(name: Name): NameableMfvcNode? = mapping[name] + val leaves: List = mapLeaves { it } + val fields: List? = mapLeaves { it.field }.run { + @Suppress("UNCHECKED_CAST") + when { + all { it == null } -> null + all { it != null } -> this as List + else -> error("IrFields can either exist all or none for MFVC property") + } + } + + val allInnerUnboxMethods: List = subnodes.flatMap { subnode -> + when (subnode) { + is MfvcNodeWithSubnodes -> subnode.allUnboxMethods + is LeafMfvcNode -> listOf(subnode.unboxMethod) + } + } + + val allUnboxMethods = allInnerUnboxMethods + listOfNotNull(unboxMethod) + + val indices: IntRange = leaves.indices + + val subnodeIndices: Map = buildMap { + var offset = 0 + for (node in subnodes) { + when (node) { + is IntermediateMfvcNode -> { + val nodeSize = node.leavesCount + put(node, offset until offset + nodeSize) + putAll(node.subnodeIndices.mapValues { (_, v) -> (v.first + offset)..(v.last + offset) }) + offset += nodeSize + } + + is LeafMfvcNode -> { + put(node, offset..offset) + offset++ + } + } + } + } +} + +val MfvcNodeWithSubnodes.subnodes: List + get() = subnodesImpl.subnodes + +operator fun MfvcNodeWithSubnodes.get(name: Name): NameableMfvcNode? = subnodesImpl[name] +val MfvcNodeWithSubnodes.leaves: List + get() = subnodesImpl.leaves +val MfvcNodeWithSubnodes.fields: List? + get() = subnodesImpl.fields +val RootMfvcNode.fields: List + get() = subnodesImpl.fields!! +val MfvcNodeWithSubnodes.indices: IntRange + get() = subnodesImpl.indices +val MfvcNodeWithSubnodes.subnodeIndices: Map + get() = subnodesImpl.subnodeIndices +val MfvcNodeWithSubnodes.allUnboxMethods: List + get() = subnodesImpl.allUnboxMethods +val MfvcNodeWithSubnodes.allInnerUnboxMethods: List + get() = subnodesImpl.allInnerUnboxMethods + +inline fun MfvcNode.mapLeaves(crossinline f: (LeafMfvcNode) -> R): List = flatMapLeaves { listOf(f(it)) } + +fun MfvcNode.flatMapLeaves(f: (LeafMfvcNode) -> List): List = when (this) { + is MfvcNodeWithSubnodes -> subnodes.flatMap { it.flatMapLeaves(f) } + is LeafMfvcNode -> f(this) +} + +inline fun MfvcNodeWithSubnodesImpl.mapLeaves(crossinline f: (LeafMfvcNode) -> R): List = subnodes.flatMap { it.mapLeaves(f) } + + +private fun requireSameClasses(vararg classes: IrClass?) { + val notNulls = classes.filterNotNull() + require(notNulls.zipWithNext { a, b -> a == b }.all { it }) { + "Found different classes: ${notNulls.joinToString("\n") { it.render() }}" + } +} + +private fun requireSameSizes(vararg sizes: Int) { + require(sizes.asList().zipWithNext { a, b -> a == b }.all { it }) { + "Found different sizes: ${sizes.joinToString()}" + } +} + +private fun validateGettingAccessorParameters(function: IrSimpleFunction) { + require(function.valueParameters.isEmpty()) { "Value parameters are not expected for ${function.render()}" } + require(function.extensionReceiverParameter == null) { "Extension receiver is not expected for ${function.render()}" } + require(function.contextReceiverParametersCount == 0) { "Context receivers is not expected for ${function.render()}" } + require(function.typeParameters.isEmpty()) { "Type parameters are not expected for ${function.render()}" } +} + +class LeafMfvcNode( + override val type: IrType, + rootPropertyName: String?, + nameParts: List, + val field: IrField?, + unboxMethod: IrSimpleFunction, + hasPureUnboxMethod: Boolean, +) : NameableMfvcNode { + override val namedNodeImpl: NameableMfvcNodeImpl = NameableMfvcNodeImpl(rootPropertyName, nameParts, unboxMethod, hasPureUnboxMethod) + + override val leavesCount: Int + get() = 1 + + init { + requireSameClasses( + field?.parentAsClass?.takeUnless { unboxMethod.parentAsClass.isCompanion }, + unboxMethod.parentAsClass, + (unboxMethod.dispatchReceiverParameter?.type as? IrSimpleType)?.erasedUpperBound, + ) + validateGettingAccessorParameters(unboxMethod) + } + + override fun createInstanceFromBox( + scope: IrBlockBuilder, + typeArguments: TypeArguments, + receiver: IrExpression?, + accessType: AccessType, + saveVariable: (IrVariable) -> Unit, + ) = ReceiverBasedMfvcNodeInstance( + scope, this, typeArguments, receiver, field?.let(::listOf), unboxMethod, accessType, saveVariable + ) + + override fun toString(): String = "$fullFieldName: ${type.render()}" +} + +val MfvcNode.fields + get() = when (this) { + is MfvcNodeWithSubnodes -> this.fields + is LeafMfvcNode -> field?.let(::listOf) + } + +class IntermediateMfvcNode( + override val type: IrSimpleType, + rootPropertyName: String?, + nameParts: List, + subnodes: List, + unboxMethod: IrSimpleFunction, + hasPureUnboxMethod: Boolean, + val rootNode: RootMfvcNode, // root node corresponding type of the node +) : NameableMfvcNode, MfvcNodeWithSubnodes { + override val namedNodeImpl: NameableMfvcNodeImpl = NameableMfvcNodeImpl(rootPropertyName, nameParts, unboxMethod, hasPureUnboxMethod) + override val subnodesImpl: MfvcNodeWithSubnodesImpl = MfvcNodeWithSubnodesImpl(subnodes, unboxMethod) + override val leavesCount + get() = leaves.size + + init { + require(type.needsMfvcFlattening()) { "MFVC type expected but got% ${type.render()}" } + require(type.erasedUpperBound == rootNode.mfvc) { + "Root node must point at the RootNode of class ${type.erasedUpperBound.render()} but points at ${rootNode.mfvc.render()}" + } + requireSameClasses( + unboxMethod.parentAsClass, + (unboxMethod.dispatchReceiverParameter?.type as IrSimpleType?)?.erasedUpperBound, + ) + validateGettingAccessorParameters(unboxMethod) + } + + override val boxMethod: IrSimpleFunction + get() = rootNode.boxMethod + + override val leavesUnboxMethods: List = collectLeavesUnboxMethods() + + override fun createInstanceFromBox( + scope: IrBlockBuilder, + typeArguments: TypeArguments, + receiver: IrExpression?, + accessType: AccessType, + saveVariable: (IrVariable) -> Unit, + ) = ReceiverBasedMfvcNodeInstance( + scope, this, typeArguments, receiver, fields, unboxMethod, accessType, saveVariable + ) + + override fun toString(): String = + "$fullFieldName: ${type.render()}\n${subnodes.joinToString("\n").prependIndent(" ")}" +} + +private fun MfvcNodeWithSubnodes.collectLeavesUnboxMethods() = mapLeaves { it.unboxMethod } + +fun IrSimpleFunction.isDefaultGetter(expectedField: IrField? = null): Boolean { + if (!isGetter) return false + if (expectedField != null && correspondingPropertySymbol?.owner?.backingField != expectedField) return false + val statement = (body?.statements?.singleOrNull() as? IrReturn)?.value as? IrGetField ?: return false + val actualField = statement.symbol.owner + return expectedField == null || actualField == expectedField || parentAsClass.isCompanion && actualField.correspondingPropertySymbol == correspondingPropertySymbol +} + +fun IrSimpleFunction.getGetterField(): IrField? { + if (!isGetter) return null + val statement = (body?.statements?.singleOrNull() as? IrReturn)?.value as? IrGetField ?: return null + return statement.symbol.owner +} + +class RootMfvcNode internal constructor( + val mfvc: IrClass, + subnodes: List, + val oldPrimaryConstructor: IrConstructor, + val newPrimaryConstructor: IrConstructor, + val primaryConstructorImpl: IrSimpleFunction, + override val boxMethod: IrSimpleFunction, + val specializedEqualsMethod: IrSimpleFunction, +) : MfvcNodeWithSubnodes { + override val subnodesImpl: MfvcNodeWithSubnodesImpl = MfvcNodeWithSubnodesImpl(subnodes, null) + override val type: IrSimpleType = mfvc.defaultType + + override val leavesCount: Int + get() = leaves.size + + override val leavesUnboxMethods: List = collectLeavesUnboxMethods() + + init { + 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()}" } + } + requireSameClasses( + mfvc, + oldPrimaryConstructor.parentAsClass, + newPrimaryConstructor.parentAsClass, + primaryConstructorImpl.parentAsClass, + boxMethod.parentAsClass, + specializedEqualsMethod.parentAsClass, + oldPrimaryConstructor.constructedClass, + newPrimaryConstructor.constructedClass, + boxMethod.returnType.erasedUpperBound, + ) + require(primaryConstructorImpl.returnType.isUnit()) { + "Constructor-impl must return Unit but returns ${primaryConstructorImpl.returnType.render()}" + } + require(specializedEqualsMethod.returnType.isBoolean()) { + "Specialized equals method must return Boolean but returns ${primaryConstructorImpl.returnType.render()}" + } + require(oldPrimaryConstructor.typeParameters.isEmpty() && newPrimaryConstructor.typeParameters.isEmpty()) { + "Constructors do not support type parameters yet" + } + requireSameSizes( + mfvc.typeParameters.size, + boxMethod.typeParameters.size, + primaryConstructorImpl.typeParameters.size, + ) + require(specializedEqualsMethod.typeParameters.size == 2 * mfvc.typeParameters.size) { + "Specialized equals method must contain twice more type parameters than corresponding MFVC ${mfvc.typeParameters.map { it.defaultType.render() }} but has ${specializedEqualsMethod.typeParameters.map { it.defaultType.render() }}" + } + requireSameSizes(oldPrimaryConstructor.valueParameters.size, subnodes.size) + requireSameSizes( + leavesCount, + newPrimaryConstructor.valueParameters.size, + primaryConstructorImpl.valueParameters.size, + boxMethod.valueParameters.size, + ) + require(specializedEqualsMethod.valueParameters.size == 2 * leavesCount) { + "Specialized equals method must contain twice more value parameters than corresponding primary constructor of the MFVC ${mfvc.typeParameters.map { it.defaultType.render() }} but has ${specializedEqualsMethod.typeParameters.map { it.defaultType.render() }}" + } + for (function in listOf(oldPrimaryConstructor, newPrimaryConstructor, primaryConstructorImpl, boxMethod, specializedEqualsMethod)) { + require(function.extensionReceiverParameter == null) { "Extension receiver is not expected for ${function.render()}" } + require(function.contextReceiverParametersCount == 0) { "Context receivers are not expected for ${function.render()}" } + } + } + + override fun createInstanceFromBox( + scope: IrBlockBuilder, + typeArguments: TypeArguments, + receiver: IrExpression?, + accessType: AccessType, + saveVariable: (IrVariable) -> Unit, + ) = ReceiverBasedMfvcNodeInstance(scope, this, typeArguments, receiver, fields, null, accessType, saveVariable) + + override fun toString(): String = + "${type.render()}\n${subnodes.joinToString("\n").prependIndent(" ")}" +} + +fun IrType.needsMfvcFlattening(): Boolean = isMultiFieldValueClassType() && !isNullable() || + classifierOrNull.let { classifier -> + classifier is IrTypeParameterSymbol && classifier.owner.superTypes.any { it.needsMfvcFlattening() } + } // add not is annotated as @UseBox etc diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNodeFactory.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNodeFactory.kt new file mode 100644 index 00000000000..c4de0207f1b --- /dev/null +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNodeFactory.kt @@ -0,0 +1,487 @@ +/* + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +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.ir.createJvmIrBuilder +import org.jetbrains.kotlin.backend.jvm.ir.erasedUpperBound +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 +import org.jetbrains.kotlin.ir.builders.declarations.buildField +import org.jetbrains.kotlin.ir.builders.declarations.buildFun +import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.deepCopyWithVariables +import org.jetbrains.kotlin.ir.expressions.IrConstructorCall +import org.jetbrains.kotlin.ir.expressions.IrExpression +import org.jetbrains.kotlin.ir.types.IrSimpleType +import org.jetbrains.kotlin.ir.types.IrType +import org.jetbrains.kotlin.ir.types.defaultType +import org.jetbrains.kotlin.ir.util.* +import org.jetbrains.kotlin.load.java.JvmAbi +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.resolve.InlineClassDescriptorResolver + +fun createLeafMfvcNode( + parent: IrDeclarationContainer, + context: JvmBackendContext, + type: IrType, + rootPropertyName: String?, + nameParts: List, + fieldAnnotations: List, + static: Boolean, + overriddenNode: LeafMfvcNode?, + defaultMethodsImplementationSourceNode: Pair?, // used if the getter was custom and need to call it. + oldGetter: IrSimpleFunction?, + modality: Modality, + oldPropertyBackingField: IrField?, +): LeafMfvcNode { + require(!type.needsMfvcFlattening()) { "${type.render()} requires flattening" } + + val fullMethodName = NameableMfvcNodeImpl.makeFullMethodName(rootPropertyName, nameParts) + val fullFieldName = NameableMfvcNodeImpl.makeFullFieldName(rootPropertyName, nameParts) + + val field = oldPropertyBackingField?.let { oldBackingField -> + context.irFactory.buildField { + updateFrom(oldBackingField) + this.name = fullFieldName + this.type = type + this.visibility = DescriptorVisibilities.PRIVATE + this.metadata = null + }.apply { + this.parent = oldBackingField.parent + this.annotations = fieldAnnotations.map { it.deepCopyWithVariables() } + } + } + + val unboxMethod = makeUnboxMethod( + context, + fullMethodName, + type, + parent, + overriddenNode, + static, + defaultMethodsImplementationSourceNode, + oldGetter, + modality, + ) { receiver -> irGetField(if (field!!.isStatic) null else irGet(receiver!!), field) } + + return LeafMfvcNode(type, rootPropertyName, nameParts, field, unboxMethod, defaultMethodsImplementationSourceNode.isPure()) +} + +private fun Pair?.isPure(): Boolean { + val (outer, inner) = this ?: return true + return outer == null && inner.hasPureUnboxMethod +} + +private fun makeUnboxMethod( + context: JvmBackendContext, + fullMethodName: Name, + type: IrType, + parent: IrDeclarationParent, + overriddenNode: NameableMfvcNode?, + static: Boolean, + defaultMethodsImplementationSourceNode: Pair?, + oldGetter: IrSimpleFunction?, + modality: Modality, + makeOptimizedExpression: IrBuilderWithScope.(receiver: IrValueDeclaration?) -> IrExpression, +): IrSimpleFunction { + val res = oldGetter ?: context.irFactory.buildFun { + this.name = fullMethodName + this.origin = JvmLoweredDeclarationOrigin.SYNTHETIC_MULTI_FIELD_VALUE_CLASS_MEMBER + this.returnType = type + this.modality = modality + }.apply { + this.parent = parent + overriddenSymbols = overriddenNode?.let { it.unboxMethod.overriddenSymbols + it.unboxMethod.symbol } ?: listOf() + if (!static) { + createDispatchReceiverParameter() + } + } + + return res.apply { + body = with(context.createJvmIrBuilder(this.symbol)) { + val receiver = dispatchReceiverParameter + if (defaultMethodsImplementationSourceNode == null) { + irExprBody(makeOptimizedExpression(receiver)) + } else { + val (outer, inner) = defaultMethodsImplementationSourceNode + val receiverExpression = receiver?.let { irGet(it) } + val outerCall = if (outer == null) receiverExpression else irCall(outer).apply { dispatchReceiver = receiverExpression } + val innerCall = irCall(inner.unboxMethod).apply { dispatchReceiver = outerCall } + irExprBody(innerCall) + } + } + } +} + +fun createNameableMfvcNodes( + parent: IrDeclarationContainer, + context: JvmBackendContext, + type: IrSimpleType, + typeArguments: TypeArguments, + rootPropertyName: String?, + nameParts: List, + fieldAnnotations: List, + static: Boolean, + overriddenNode: NameableMfvcNode?, + defaultMethodsImplementationSourceNode: Pair?, // used if the getter was custom and need to call it. + oldGetter: IrSimpleFunction?, + modality: Modality, + oldPropertyBackingField: IrField?, +): NameableMfvcNode = if (type.needsMfvcFlattening()) createIntermediateMfvcNode( + parent, + context, + type, + typeArguments, + rootPropertyName, + nameParts, + fieldAnnotations, + static, + overriddenNode as IntermediateMfvcNode?, + defaultMethodsImplementationSourceNode?.let { (outer, inner) -> outer to (inner as IntermediateMfvcNode) }, + oldGetter, + modality, + oldPropertyBackingField, +) else createLeafMfvcNode( + parent, + context, + type, + rootPropertyName, + nameParts, + fieldAnnotations, + static, + overriddenNode as LeafMfvcNode?, + defaultMethodsImplementationSourceNode?.let { (outer, inner) -> outer to (inner as LeafMfvcNode) }, + oldGetter, + modality, + oldPropertyBackingField +) + +fun createIntermediateMfvcNode( + parent: IrDeclarationContainer, + context: JvmBackendContext, + type: IrSimpleType, + typeArguments: TypeArguments, + rootPropertyName: String?, + nameParts: List, + fieldAnnotations: List, + static: Boolean, + overriddenNode: IntermediateMfvcNode?, + defaultMethodsImplementationSourceNode: Pair?, // used if the getter was custom and need to call it. + oldGetter: IrSimpleFunction?, + modality: Modality, + oldPropertyBackingField: IrField?, +): IntermediateMfvcNode { + require(type.needsMfvcFlattening()) { "${type.render()} does not require flattening" } + val valueClass = type.erasedUpperBound + val representation = valueClass.multiFieldValueClassRepresentation!! + + val replacements = context.multiFieldValueClassReplacements + val rootNode = replacements.getRootMfvcNode(valueClass)!! + + val oldField = oldGetter?.correspondingPropertySymbol?.owner?.backingField + + val shadowBackingFieldProperty = if (oldField == null) oldGetter?.getGetterField()?.correspondingPropertySymbol?.owner else null + val useOldGetter = oldGetter != null && (oldField == null || !oldGetter.isDefaultGetter(oldField)) + + val subnodes = representation.underlyingPropertyNamesToTypes.mapIndexed { index, (name, type) -> + val newType = type.substitute(typeArguments) as IrSimpleType + val newTypeArguments = typeArguments.toMutableMap().apply { putAll(makeTypeArgumentsFromType(newType)) } + val newDefaultMethodsImplementationSourceNode = when { + defaultMethodsImplementationSourceNode != null -> { + val (outer, inner) = defaultMethodsImplementationSourceNode + require(!useOldGetter) { "Multiple non-default getters:\n\n${outer?.dump()}\n\n${oldGetter?.dump()}" } + outer to inner[name]!! + } + + shadowBackingFieldProperty != null -> null to replacements.getMfvcPropertyNode(shadowBackingFieldProperty)!! + useOldGetter -> oldGetter!! to rootNode[name]!! + else -> null + } + createNameableMfvcNodes( + parent, + context, + newType, + newTypeArguments, + rootPropertyName, + nameParts + IndexedNamePart(index, name), + fieldAnnotations, + static, + overriddenNode?.let { it[name]!! }, + newDefaultMethodsImplementationSourceNode, + null, + modality, + oldPropertyBackingField, + ) + } + + val fullMethodName = NameableMfvcNodeImpl.makeFullMethodName(rootPropertyName, nameParts) + + val unboxMethod = if (useOldGetter) oldGetter!! else makeUnboxMethod( + context, fullMethodName, type, parent, overriddenNode, static, defaultMethodsImplementationSourceNode, 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) + } + + val hasPureUnboxMethod = defaultMethodsImplementationSourceNode.isPure() && subnodes.all { it.hasPureUnboxMethod } + return IntermediateMfvcNode( + type, rootPropertyName, nameParts, subnodes, unboxMethod, hasPureUnboxMethod, rootNode + ) +} + +fun collectPropertiesAfterLowering(irClass: IrClass) = LinkedHashSet().apply { + for (element in irClass.declarations) { + if (element is IrField) { + element.correspondingPropertySymbol?.owner?.let { add(it) } + } else if (element is IrSimpleFunction && element.extensionReceiverParameter == null && element.contextReceiverParametersCount == 0) { + element.correspondingPropertySymbol?.owner?.let { add(it) } + } + } +} + +private fun IrProperty.isStatic(currentContainer: IrDeclarationContainer) = + getterIfDeclared(currentContainer)?.isStatic ?: backingField?.isStatic ?: error("Property without both getter and backing field") + +fun getRootNode(context: JvmBackendContext, mfvc: IrClass): RootMfvcNode { + require(mfvc.isMultiFieldValueClass) { "${mfvc.defaultType.render()} does not require flattening" } + val oldPrimaryConstructor = mfvc.primaryConstructor!! + val representation = mfvc.multiFieldValueClassRepresentation!! + val properties = collectPropertiesAfterLowering(mfvc).associateBy { it.isStatic(mfvc) to it.name } + + val subnodes = makeRootMfvcNodeSubnodes(representation, properties, context, mfvc) + + val mfvcNodeWithSubnodesImpl = MfvcNodeWithSubnodesImpl(subnodes, null) + val leaves = mfvcNodeWithSubnodesImpl.leaves + val fields = mfvcNodeWithSubnodesImpl.fields!! + + val newPrimaryConstructor = makeMfvcPrimaryConstructor(context, oldPrimaryConstructor, mfvc, leaves, fields) + val primaryConstructorImpl = makePrimaryConstructorImpl(context, oldPrimaryConstructor, mfvc, leaves) + val boxMethod = makeBoxMethod(context, mfvc, leaves, newPrimaryConstructor) + val specializedEqualsMethod = makeSpecializedEqualsMethod(context, mfvc, leaves) + + return RootMfvcNode( + mfvc, subnodes, oldPrimaryConstructor, newPrimaryConstructor, primaryConstructorImpl, boxMethod, specializedEqualsMethod + ) +} + +private fun makeSpecializedEqualsMethod( + context: JvmBackendContext, + mfvc: IrClass, + leaves: List +) = context.irFactory.buildFun { + name = InlineClassDescriptorResolver.SPECIALIZED_EQUALS_NAME + // TODO: Revisit this once we allow user defined equals methods in value classes. + origin = JvmLoweredDeclarationOrigin.MULTI_FIELD_VALUE_CLASS_GENERATED_IMPL_METHOD + returnType = context.irBuiltIns.booleanType +}.apply { + parent = mfvc + copyTypeParametersFrom(mfvc) + val typeParametersHalf1 = typeParameters.apply { + for (it in this) { + it.name = Name.guessByFirstCharacter("${it.name.asString()}1") + } + } + + copyTypeParametersFrom(mfvc) + val typeParametersHalf2 = typeParameters.drop(typeParametersHalf1.size).apply { + for (it in this) { + it.name = Name.guessByFirstCharacter("${it.name.asString()}2") + } + } + + val valueParametersHalf1 = leaves.map { leaf -> + addValueParameter { + this.name = Name.guessByFirstCharacter( + "${InlineClassDescriptorResolver.SPECIALIZED_EQUALS_FIRST_PARAMETER_NAME}$${leaf.fullFieldName}" + ) + this.type = leaf.type.substitute(mfvc.typeParameters, typeParametersHalf1.map { it.defaultType }) + } + } + + val valueParametersHalf2 = leaves.map { leaf -> + addValueParameter { + this.name = Name.guessByFirstCharacter( + "${InlineClassDescriptorResolver.SPECIALIZED_EQUALS_SECOND_PARAMETER_NAME}$${leaf.fullFieldName}" + ) + this.type = leaf.type.substitute(mfvc.typeParameters, typeParametersHalf2.map { it.defaultType }) + } + } + + body = with(context.createJvmIrBuilder(this.symbol)) { + val conjunctions = valueParametersHalf1.zip(valueParametersHalf2) { f1, f2 -> irEquals(irGet(f1), irGet(f2)) } + irExprBody(conjunctions.reduce { acc, current -> + irCall(context.irBuiltIns.andandSymbol).apply { + putValueArgument(0, acc) + putValueArgument(1, current) + } + }) + } +} + +private fun makeBoxMethod( + context: JvmBackendContext, + mfvc: IrClass, + leaves: List, + newPrimaryConstructor: IrConstructor +) = context.irFactory.buildFun { + name = Name.identifier(KotlinTypeMapper.BOX_JVM_METHOD_NAME) + origin = JvmLoweredDeclarationOrigin.SYNTHETIC_MULTI_FIELD_VALUE_CLASS_MEMBER + returnType = mfvc.defaultType +}.apply { + parent = mfvc + copyTypeParametersFrom(mfvc) + val mapping = mfvc.typeParameters.zip(typeParameters) { classTypeParameter, functionTypeParameter -> + classTypeParameter.symbol to functionTypeParameter.defaultType + }.toMap() + returnType = returnType.substitute(mapping) + val parameters = leaves.map { leaf -> addValueParameter(leaf.fullFieldName, leaf.type.substitute(mapping)) } + body = with(context.createJvmIrBuilder(this.symbol)) { + irExprBody(irCall(newPrimaryConstructor).apply { + for ((index, parameter) in parameters.withIndex()) { + putValueArgument(index, irGet(parameter)) + } + }) + } +} + +private fun makePrimaryConstructorImpl( + context: JvmBackendContext, + oldPrimaryConstructor: IrConstructor, + mfvc: IrClass, + leaves: List +) = context.irFactory.buildFun { + name = InlineClassAbi.mangledNameFor(oldPrimaryConstructor, false, false) + visibility = oldPrimaryConstructor.visibility + origin = JvmLoweredDeclarationOrigin.STATIC_MULTI_FIELD_VALUE_CLASS_CONSTRUCTOR + returnType = context.irBuiltIns.unitType + modality = Modality.FINAL +}.apply { + parent = mfvc + copyTypeParametersFrom(mfvc) + for (leaf in leaves) { + addValueParameter(leaf.fullFieldName, leaf.type.substitute(mfvc.typeParameters, typeParameters.map { it.defaultType })) + } + // body is added in the Lowering file as it needs to be lowered +} + +private fun makeMfvcPrimaryConstructor( + context: JvmBackendContext, + oldPrimaryConstructor: IrConstructor, + mfvc: IrClass, + leaves: List, + fields: List +) = context.irFactory.buildConstructor { + updateFrom(oldPrimaryConstructor) + visibility = DescriptorVisibilities.PRIVATE + origin = JvmLoweredDeclarationOrigin.SYNTHETIC_MULTI_FIELD_VALUE_CLASS_MEMBER + returnType = oldPrimaryConstructor.returnType +}.apply { + require(oldPrimaryConstructor.typeParameters.isEmpty()) { "Constructors do not support type parameters yet" } + this.parent = mfvc + val parameters = leaves.map { addValueParameter(it.fullFieldName, it.type) } + val irConstructor = this@apply + body = context.createIrBuilder(irConstructor.symbol).irBlockBody(irConstructor) { + +irDelegatingConstructorCall(context.irBuiltIns.anyClass.owner.constructors.single()) + for ((field, parameter) in fields zip parameters) { + +irSetField(irGet(mfvc.thisReceiver!!), field, irGet(parameter)) + } + } +} + +private fun makeRootMfvcNodeSubnodes( + representation: MultiFieldValueClassRepresentation, + properties: Map, IrProperty>, + context: JvmBackendContext, + mfvc: IrClass +) = representation.underlyingPropertyNamesToTypes.mapIndexed { index, (name, type) -> + val typeArguments = makeTypeArgumentsFromType(type) + val oldProperty = properties[false to name]!! + val oldBackingField = oldProperty.backingField + val oldGetter = oldProperty.getterIfDeclared(mfvc) + val overriddenNode = oldGetter?.let { getOverriddenNode(context.multiFieldValueClassReplacements, it) as IntermediateMfvcNode? } + val static = oldProperty.isStatic(mfvc) + createNameableMfvcNodes( + mfvc, + context, + type, + typeArguments, + null, + listOf(IndexedNamePart(index, name)), + oldBackingField?.annotations ?: listOf(), + static, + overriddenNode, + null, + oldGetter.takeIf { static }, + Modality.FINAL, + oldBackingField, + ).also { + updateAnnotationsAndPropertyFromOldProperty(oldProperty) + it.unboxMethod.overriddenSymbols = listOf() // the getter is saved so it overrides itself + } +} + +private fun updateAnnotationsAndPropertyFromOldProperty( + oldProperty: IrProperty +) { + oldProperty.setter?.apply { + name = Name.identifier(JvmAbi.setterName(oldProperty.name.asString())) + correspondingPropertySymbol = null + origin = IrDeclarationOrigin.DEFINED + } + oldProperty.setter = null + oldProperty.backingField = null +} + +fun createIntermediateNodeForMfvcPropertyOfRegularClass( + parent: IrDeclarationContainer, + context: JvmBackendContext, + oldProperty: IrProperty, +): IntermediateMfvcNode { + val oldGetter = oldProperty.getterIfDeclared(parent) + val oldField = oldProperty.backingField + val type = oldProperty.getter?.returnType ?: oldField?.type ?: error("Either getter or field must exist") + require(type is IrSimpleType && type.needsMfvcFlattening()) { "Expected MFVC but got ${type.render()}" } + val fieldAnnotations = oldField?.annotations ?: listOf() + 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 + return createIntermediateMfvcNode( + parent, context, type, makeTypeArgumentsFromType(type), oldProperty.name.asString(), listOf(), + fieldAnnotations, static, overriddenNode, null, oldGetter, modality, oldField + ).also { + updateAnnotationsAndPropertyFromOldProperty(oldProperty) + } +} + +private fun getOverriddenNode(replacements: MemoizedMultiFieldValueClassReplacements, getter: IrSimpleFunction): NameableMfvcNode? = + getter.overriddenSymbols + .firstOrNull { !it.owner.isFakeOverride } + ?.let { replacements.getMfvcPropertyNode(it.owner.correspondingPropertySymbol!!.owner) } + +fun getOptimizedPublicAccess(currentElement: IrElement?, parent: IrClass): AccessType { + val declaration = currentElement as? IrDeclaration ?: return AccessType.AlwaysPublic + for (cur in declaration.parents.filterIsInstance()) { + 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 } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNodeInstance.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNodeInstance.kt new file mode 100644 index 00000000000..9ec29027a12 --- /dev/null +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNodeInstance.kt @@ -0,0 +1,279 @@ +/* + * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ +package org.jetbrains.kotlin.backend.jvm + +import org.jetbrains.kotlin.backend.jvm.ir.erasedUpperBound +import org.jetbrains.kotlin.ir.IrElement +import org.jetbrains.kotlin.ir.IrStatement +import org.jetbrains.kotlin.ir.builders.* +import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl +import org.jetbrains.kotlin.ir.expressions.* +import org.jetbrains.kotlin.ir.expressions.impl.IrTypeOperatorCallImpl +import org.jetbrains.kotlin.ir.symbols.impl.IrVariableSymbolImpl +import org.jetbrains.kotlin.ir.types.IrSimpleType +import org.jetbrains.kotlin.ir.types.IrType +import org.jetbrains.kotlin.ir.util.deepCopyWithSymbols +import org.jetbrains.kotlin.ir.util.dump +import org.jetbrains.kotlin.ir.util.render +import org.jetbrains.kotlin.ir.util.substitute +import org.jetbrains.kotlin.name.Name + +interface MfvcNodeInstance { + val node: MfvcNode + val typeArguments: TypeArguments + val type: IrSimpleType + + fun makeFlattenedGetterExpressions(scope: IrBlockBuilder): List + fun makeGetterExpression(scope: IrBuilderWithScope): IrExpression + operator fun get(name: Name): MfvcNodeInstance? + fun makeStatements(scope: IrBuilderWithScope, values: List): List +} + +private fun makeTypeFromMfvcNodeAndTypeArguments(node: MfvcNode, typeArguments: TypeArguments) = + node.type.substitute(typeArguments) as IrSimpleType + +fun MfvcNodeInstance.addSetterStatements(scope: IrBlockBuilder, values: List) = with(scope) { + for (statement in makeStatements(this, values)) { + +statement + } +} + +fun MfvcNodeInstance.makeSetterExpressions(scope: IrBuilderWithScope, values: List): IrExpression = scope.irBlock { + addSetterStatements(this, values) +} + +private fun MfvcNodeInstance.checkValuesCount(values: List) { + require(values.size == node.leavesCount) { "Node $node requires ${node.leavesCount} values but got ${values.map { it.render() }}" } +} + +class ValueDeclarationMfvcNodeInstance( + override val node: MfvcNode, + override val typeArguments: TypeArguments, + val valueDeclarations: List, +) : MfvcNodeInstance { + init { + require(valueDeclarations.size == size) { "Expected value declarations list of size $size but got of size ${valueDeclarations.size}" } + } + + override val type: IrSimpleType = makeTypeFromMfvcNodeAndTypeArguments(node, typeArguments) + + override fun makeFlattenedGetterExpressions(scope: IrBlockBuilder): List = + makeFlattenedGetterExpressions(scope as IrBuilderWithScope) + private fun makeFlattenedGetterExpressions(scope: IrBuilderWithScope): List = valueDeclarations.map { scope.irGet(it) } + + override fun makeGetterExpression(scope: IrBuilderWithScope): IrExpression = when (node) { + is LeafMfvcNode -> makeFlattenedGetterExpressions(scope).single() + is MfvcNodeWithSubnodes -> node.makeBoxedExpression(scope, typeArguments, makeFlattenedGetterExpressions(scope)) + } + + override fun get(name: Name): ValueDeclarationMfvcNodeInstance? { + val (newNode, indices) = node.getSubnodeAndIndices(name) ?: return null + return ValueDeclarationMfvcNodeInstance(newNode, typeArguments, valueDeclarations.slice(indices)) + } + + override fun makeStatements(scope: IrBuilderWithScope, values: List): List { + checkValuesCount(values) + return valueDeclarations.zip(values) { declaration, value -> scope.irSet(declaration, value) } + } +} + +internal class ExpressionCopierImpl( + expression: IrExpression?, + private val scope: IrBlockBuilder, + private val saveVariable: (IrVariable) -> Unit, +) { + private sealed interface CopyableExpression { + fun makeExpression(scope: IrBuilderWithScope): IrExpression + } + + private class SavedToVariable(val variable: IrVariable) : CopyableExpression { + override fun makeExpression(scope: IrBuilderWithScope): IrExpression = scope.irGet(variable) + } + + private class PureExpression(val expression: IrExpression) : CopyableExpression { + override fun makeExpression(scope: IrBuilderWithScope): IrExpression = expression.deepCopyWithSymbols() + } + + private fun IrExpression.orSavedToVariable(): CopyableExpression = + if (isRepeatableGetter()) { + PureExpression(this) + } else SavedToVariable( + scope.savableStandaloneVariableWithSetter( + this@orSavedToVariable, + origin = IrDeclarationOrigin.TEMPORARY_MULTI_FIELD_VALUE_CLASS_VARIABLE, + saveVariable = saveVariable, + isTemporary = true, + ) + ) + + private val copyableExpression = expression?.orSavedToVariable() + + fun makeCopy() = copyableExpression?.makeExpression(scope) +} + +fun IrExpression?.isRepeatableGetter(): Boolean = when (this) { + null -> true + is IrConst<*> -> true + is IrGetValue -> true + is IrGetField -> receiver.isRepeatableGetter() + is IrTypeOperatorCallImpl -> this.argument.isRepeatableGetter() + is IrContainerExpression -> statements.all { it is IrExpression && it.isRepeatableGetter() || it is IrVariable } + else -> false +} + +fun IrExpression?.isRepeatableSetter(): Boolean = when (this) { + null -> true + is IrConst<*> -> true + is IrSetValue -> value.isRepeatableGetter() + is IrSetField -> receiver.isRepeatableGetter() && value.isRepeatableGetter() + is IrTypeOperatorCallImpl -> this.argument.isRepeatableSetter() + is IrContainerExpression -> statements.dropLast(1).all { it is IrExpression && it.isRepeatableGetter() || it is IrVariable } && + statements.lastOrNull().let { it is IrExpression? && it.isRepeatableSetter() } + + else -> false +} + +fun IrExpression?.isRepeatableAccessor(): Boolean = isRepeatableGetter() || isRepeatableSetter() + +enum class AccessType { AlwaysPublic, PrivateWhenNoBox, AlwaysPrivate } + +class ReceiverBasedMfvcNodeInstance( + private val scope: IrBlockBuilder, + override val node: MfvcNode, + override val typeArguments: TypeArguments, + receiver: IrExpression?, + val fields: List?, + val unboxMethod: IrSimpleFunction?, + val accessType: AccessType, + private val saveVariable: (IrVariable) -> Unit, +) : MfvcNodeInstance { + override val type: IrSimpleType = makeTypeFromMfvcNodeAndTypeArguments(node, typeArguments) + + private val receiverCopier = ExpressionCopierImpl(receiver, scope, saveVariable) + + private fun makeReceiverCopy() = receiverCopier.makeCopy() + + init { + require(fields == null || fields.isNotEmpty()) { "Empty list of fields" } + require(node is RootMfvcNode == (unboxMethod == null)) { "Only root node has node getter" } + } + + override fun makeFlattenedGetterExpressions(scope: IrBlockBuilder): List = when (node) { + is LeafMfvcNode -> listOf(makeGetterExpression(scope)) + is MfvcNodeWithSubnodes -> when { + node is IntermediateMfvcNode && canUsePrivateAccessFor(node) && fields != null -> + fields.map { scope.irGetField(makeReceiverCopy(), it) } + + node is IntermediateMfvcNode && !node.hasPureUnboxMethod -> { + val value = makeGetterExpression(scope) + val asVariable = scope.savableStandaloneVariableWithSetter( + value, + origin = IrDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_PARAMETER, + saveVariable = saveVariable, + isTemporary = true, + ) + val root = node.rootNode + val variableInstance = + root.createInstanceFromBox(scope, typeArguments, scope.irGet(asVariable), accessType, saveVariable) + variableInstance.makeFlattenedGetterExpressions(scope) + } + + else -> node.subnodes.flatMap { get(it.name)!!.makeFlattenedGetterExpressions(scope) } + } + } + + override fun makeGetterExpression(scope: IrBuilderWithScope): IrExpression = with(scope) { + when { + node is LeafMfvcNode && canUsePrivateAccessFor(node) && fields != null -> irGetField(makeReceiverCopy(), fields.single()) + node is IntermediateMfvcNode && accessType == AccessType.AlwaysPrivate && fields != null -> + node.makeBoxedExpression(this, typeArguments, fields.map { irGetField(makeReceiverCopy(), it) }) + + unboxMethod != null -> irCall(unboxMethod).apply { + val dispatchReceiverParameter = unboxMethod.dispatchReceiverParameter + if (dispatchReceiverParameter != null) { + dispatchReceiver = makeReceiverCopy() ?: run { + val erasedUpperBound = dispatchReceiverParameter.type.erasedUpperBound + require(erasedUpperBound.isCompanion) { "Expected a dispatch receiver for:\n${unboxMethod.dump()}" } + irGetObject(erasedUpperBound.symbol) + } + } + } + + node is RootMfvcNode -> makeReceiverCopy()!! + else -> error("Unbox method must exist for $node") + } + } + + private fun canUsePrivateAccessFor(node: NameableMfvcNode) = + node.hasPureUnboxMethod && accessType == AccessType.PrivateWhenNoBox || accessType == AccessType.AlwaysPrivate + + override fun get(name: Name): ReceiverBasedMfvcNodeInstance? { + val (newNode, _) = node.getSubnodeAndIndices(name) ?: return null + return newNode.createInstanceFromBox(scope, typeArguments, makeReceiverCopy(), accessType, saveVariable) + } + + override fun makeStatements(scope: IrBuilderWithScope, values: List): List { + checkValuesCount(values) + require(fields != null) { "$node is immutable as it has custom getter and so no backing fields" } + return fields.zip(values) { field, expr -> scope.irSetField(makeReceiverCopy(), field, expr) } + } +} + +val MfvcNodeInstance.size: Int + get() = node.leavesCount + +fun IrContainerExpression.unwrapBlock(): IrExpression = statements.singleOrNull() as? IrExpression ?: this + +/** + * Creates a variable and doesn't add it to a container. It saves the variable with given saveVariable. + * + * It may be used when the variable will be used outside the current container so the declaration is added later when all usages are known. + */ +fun IrBuilderWithScope.savableStandaloneVariable( + type: IrType, + name: String? = null, + isMutable: Boolean = false, + origin: IrDeclarationOrigin, + isTemporary: Boolean = origin == IrDeclarationOrigin.IR_TEMPORARY_VARIABLE, + saveVariable: (IrVariable) -> Unit, +): IrVariable { + val variable = if (isTemporary || name == null) scope.createTemporaryVariableDeclaration( + type, name, isMutable, + startOffset = startOffset, + endOffset = endOffset, + origin = origin, + ) else IrVariableImpl( + startOffset = startOffset, + endOffset = endOffset, + origin = origin, + symbol = IrVariableSymbolImpl(), + name = Name.identifier(name), + type = type, + isVar = isMutable, + isConst = false, + isLateinit = false + ).apply { + parent = this@savableStandaloneVariable.scope.getLocalDeclarationParent() + } + saveVariable(variable) + return variable +} + +/** + * Creates a variable and doesn't add it to a container. It saves the variable with given saveVariable. It adds irSet-based initialization. + * + * It may be used when the variable will be used outside the current container so the declaration is added later when all usages are known. + */ +fun IrStatementsBuilder.savableStandaloneVariableWithSetter( + expression: IrExpression, + name: String? = null, + isMutable: Boolean = false, + origin: IrDeclarationOrigin, + isTemporary: Boolean = origin == IrDeclarationOrigin.IR_TEMPORARY_VARIABLE, + saveVariable: (IrVariable) -> Unit, +) = savableStandaloneVariable(expression.type, name, isMutable, origin, isTemporary, saveVariable).also { + +irSet(it, expression) +} diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrTypeUtils.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrTypeUtils.kt index 900520f5633..3aa08ae8b7a 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrTypeUtils.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrTypeUtils.kt @@ -117,8 +117,11 @@ fun IrType.defaultValue(startOffset: Int, endOffset: Int, context: JvmBackendCon } } -fun IrType.isInlineClassType(): Boolean = - erasedUpperBound.isSingleFieldValueClass +fun IrType.isInlineClassType(): Boolean = erasedUpperBound.isSingleFieldValueClass + +fun IrType.isMultiFieldValueClassType(): Boolean = erasedUpperBound.isMultiFieldValueClass + +fun IrType.isValueClassType(): Boolean = erasedUpperBound.isValue val IrType.upperBound: IrType get() = erasedUpperBound.symbol.starProjectedType diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrUtils.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrUtils.kt index 1dbbb512852..a4a995f224f 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrUtils.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrUtils.kt @@ -8,10 +8,7 @@ package org.jetbrains.kotlin.backend.jvm.ir import com.intellij.psi.PsiElement import org.jetbrains.kotlin.backend.common.lower.at import org.jetbrains.kotlin.backend.common.lower.irNot -import org.jetbrains.kotlin.backend.jvm.CachedFieldsForObjectInstances -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext -import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin -import org.jetbrains.kotlin.backend.jvm.JvmSymbols +import org.jetbrains.kotlin.backend.jvm.* import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.codegen.ASSERTIONS_DISABLED_FIELD_NAME import org.jetbrains.kotlin.codegen.AsmUtil @@ -246,6 +243,9 @@ fun IrSimpleFunction.copyCorrespondingPropertyFrom(source: IrSimpleFunction) { fun IrProperty.needsAccessor(accessor: IrSimpleFunction): Boolean = when { // Properties in annotation classes become abstract methods named after the property. (parent as? IrClass)?.kind == ClassKind.ANNOTATION_CLASS -> true + // Multi-field value class getters must always be added. Getters for properties of MFVC itself follow general rules. + accessor.isGetter && accessor.contextReceiverParametersCount == 0 && accessor.extensionReceiverParameter == null && + !accessor.parent.let { it is IrClass && it.isMultiFieldValueClass } && accessor.returnType.needsMfvcFlattening() -> true // @JvmField properties have no getters/setters resolveFakeOverride()?.backingField?.hasAnnotation(JvmAbi.JVM_FIELD_ANNOTATION_FQ_NAME) == true -> false // We do not produce default accessors for private fields @@ -256,6 +256,13 @@ val IrDeclaration.isStaticInlineClassReplacement: Boolean get() = origin == JvmLoweredDeclarationOrigin.STATIC_INLINE_CLASS_REPLACEMENT || origin == JvmLoweredDeclarationOrigin.STATIC_INLINE_CLASS_CONSTRUCTOR +val IrDeclaration.isStaticMultiFieldValueClassReplacement: Boolean + get() = origin == JvmLoweredDeclarationOrigin.STATIC_MULTI_FIELD_VALUE_CLASS_REPLACEMENT + || origin == JvmLoweredDeclarationOrigin.STATIC_MULTI_FIELD_VALUE_CLASS_CONSTRUCTOR + +val IrDeclaration.isStaticValueClassReplacement: Boolean + get() = isStaticMultiFieldValueClassReplacement || isStaticInlineClassReplacement + // On the IR backend we represent raw types as star projected types with a special synthetic annotation. // See `TypeTranslator.translateTypeAnnotations`. private fun JvmBackendContext.makeRawTypeAnnotation() = @@ -305,7 +312,7 @@ val IrClass.isSyntheticSingleton: Boolean fun IrSimpleFunction.suspendFunctionOriginal(): IrSimpleFunction = if (isSuspend && - !isStaticInlineClassReplacement && + !isStaticValueClassReplacement && !isOrOverridesDefaultParameterStub() && parentAsClass.origin != JvmLoweredDeclarationOrigin.DEFAULT_IMPLS ) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/MethodSignatureMapper.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/MethodSignatureMapper.kt index 71cad44385f..ce08efd6bbc 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/MethodSignatureMapper.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/MethodSignatureMapper.kt @@ -422,7 +422,7 @@ class MethodSignatureMapper(private val context: JvmBackendContext, private val // TODO: get rid of this (probably via some special lowering) private fun mapOverriddenSpecialBuiltinIfNeeded(callee: IrFunction, superCall: Boolean): JvmMethodSignature? { // Do not remap calls to static replacements of inline class methods, since they have completely different signatures. - if (callee.isStaticInlineClassReplacement) return null + if (callee.isStaticValueClassReplacement) return null val overriddenSpecialBuiltinFunction = (callee.toIrBasedDescriptor().getOverriddenBuiltinReflectingJvmDescriptor() as IrBasedSimpleFunctionDescriptor?)?.owner if (overriddenSpecialBuiltinFunction != null && !superCall) { diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt index f3f13fb9785..297b57d41d9 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt @@ -53,11 +53,13 @@ fun IrStatementsBuilder.irTemporary( nameHint: String? = null, irType: IrType = value?.type!!, // either value or irType should be supplied at callsite isMutable: Boolean = false, + origin: IrDeclarationOrigin = IrDeclarationOrigin.IR_TEMPORARY_VARIABLE, ): IrVariable { val temporary = scope.createTemporaryVariableDeclaration( irType, nameHint, isMutable, startOffset = startOffset, - endOffset = endOffset + endOffset = endOffset, + origin = origin, ) value?.let { temporary.initializer = it } +temporary diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt index cd00046c221..91d5b647d0c 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt @@ -43,6 +43,9 @@ interface IrDeclarationOrigin { object GENERATED_DATA_CLASS_MEMBER : IrDeclarationOriginImpl("GENERATED_DATA_CLASS_MEMBER") object GENERATED_SINGLE_FIELD_VALUE_CLASS_MEMBER : IrDeclarationOriginImpl("GENERATED_SINGLE_FIELD_VALUE_CLASS_MEMBER") object GENERATED_MULTI_FIELD_VALUE_CLASS_MEMBER : IrDeclarationOriginImpl("GENERATED_MULTI_FIELD_VALUE_CLASS_MEMBER") + object GENERATED_MULTI_FIELD_VALUE_CLASS_PARAMETER : IrDeclarationOriginImpl("GENERATED_MULTI_FIELD_VALUE_CLASS_PARAMETER") + object TEMPORARY_MULTI_FIELD_VALUE_CLASS_VARIABLE : IrDeclarationOriginImpl("TEMPORARY_MULTI_FIELD_VALUE_CLASS_VARIABLE") + object MULTI_FIELD_VALUE_CLASS_REPRESENTATION_VARIABLE : IrDeclarationOriginImpl("MULTI_FIELD_VALUE_CLASS_REPRESENTATION_VARIABLE") object LOCAL_FUNCTION : IrDeclarationOriginImpl("LOCAL_FUNCTION") object LOCAL_FUNCTION_FOR_LAMBDA : IrDeclarationOriginImpl("LOCAL_FUNCTION_FOR_LAMBDA") object CATCH_PARAMETER : IrDeclarationOriginImpl("CATCH_PARAMETER") diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DataClassMembersGenerator.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DataClassMembersGenerator.kt index c071eb2180d..9b5714b54bf 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DataClassMembersGenerator.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DataClassMembersGenerator.kt @@ -128,7 +128,7 @@ abstract class DataClassMembersGenerator( fun generateEqualsMethodBody(properties: List) { val irType = irClass.defaultType - if (!irClass.isSingleFieldValueClass) { + if (!irClass.isValue) { +irIfThenReturnTrue(irEqeqeq(irThis(), irOther())) } +irIfThenReturnFalse(irNotIs(irOther(), irType)) diff --git a/compiler/testData/codegen/box/valueClasses/classFlattening.kt b/compiler/testData/codegen/box/valueClasses/classFlattening.kt index 46d2026ed44..4d7a6aa0d15 100644 --- a/compiler/testData/codegen/box/valueClasses/classFlattening.kt +++ b/compiler/testData/codegen/box/valueClasses/classFlattening.kt @@ -1,7 +1,9 @@ +// IGNORE_BACKEND_FIR: JVM_IR // WITH_STDLIB // TARGET_BACKEND: JVM_IR // WORKS_WHEN_VALUE_CLASS -// LANGUAGE: +ValueClasses +// LANGUAGE: +ValueClasses +ContextReceivers +// CHECK_BYTECODE_LISTING @JvmInline value class IC(val x: UInt) @@ -9,13 +11,148 @@ value class IC(val x: UInt) fun ic(x: IC) = x.x @JvmInline -value class SimpleMFVC(val x: UInt, val y: IC, val z: String) +value class SimpleMfvc(val x: UInt, val y: IC, val z: String) { + companion object { + val SimpleMfvc.a1: SimpleMfvc + get() = this -fun smfvc(ic: IC, x: SimpleMFVC, ic1: UInt) = ic(ic) + x.x + ic(x.y) + ic1 + @JvmStatic + val SimpleMfvc.b1: SimpleMfvc + get() = this + + context(b@SimpleMfvc) + val a2: SimpleMfvc + get() = this@b + + context(b@SimpleMfvc) + @JvmStatic + val b2: SimpleMfvc + get() = this@b + + + private val SimpleMfvc.private1: SimpleMfvc + get() = this + + @JvmStatic + private val SimpleMfvc.private2: SimpleMfvc + get() = this + + context(b@SimpleMfvc) + private val private3: SimpleMfvc + get() = this@b + + context(b@SimpleMfvc) + @JvmStatic + private val private4: SimpleMfvc + get() = this@b + } + + val SimpleMfvc.a3: SimpleMfvc + get() = this + + context(SimpleMfvc) + val b3: SimpleMfvc + get() = this@SimpleMfvc + + + private val SimpleMfvc.private1: SimpleMfvc + get() = this@SimpleMfvc + context(SimpleMfvc) + private val private2: SimpleMfvc + get() = this@SimpleMfvc +} + +fun smfvc(ic: IC, x: SimpleMfvc, ic1: UInt) = ic(ic) + x.x + ic(x.y) + ic1 @JvmInline -value class GreaterMFVC(val x: SimpleMFVC, val y: IC, val z: SimpleMFVC) +value class GreaterMfvc(val x: SimpleMfvc, val y: IC, val z: SimpleMfvc) -fun gmfvc(ic: IC, x: GreaterMFVC, ic1: UInt) = smfvc(ic, x.x, 0U) + ic(x.y) + smfvc(IC(0U), x.z, ic1) +fun gmfvc(ic: IC, x: GreaterMfvc, ic1: UInt) = smfvc(ic, x.x, 0U) + ic(x.y) + smfvc(IC(0U), x.z, ic1) -fun box() = "OK" // todo real test \ No newline at end of file +class Extensions { + val SimpleMfvc.x1: SimpleMfvc + get() = this + private val SimpleMfvc.private_: SimpleMfvc + get() = this + + companion object { + val SimpleMfvc.y1: SimpleMfvc + get() = this + + @JvmStatic + val SimpleMfvc.z1: SimpleMfvc + get() = this + + private val SimpleMfvc.private1: SimpleMfvc + get() = this + + @JvmStatic + private val SimpleMfvc.private2: SimpleMfvc + get() = this + } +} + +class Contexts { + context(b@SimpleMfvc) + val x1: SimpleMfvc + get() = this@b + context(b@SimpleMfvc) + private val private_: SimpleMfvc + get() = this@b + + companion object { + context(b@SimpleMfvc) + val y1: SimpleMfvc + get() = this@b + + context(b@SimpleMfvc) + @JvmStatic + val z1: SimpleMfvc + get() = this@b + + context(b@SimpleMfvc) + private val private1: SimpleMfvc + get() = this@b + + context(b@SimpleMfvc) + @JvmStatic + private val private2: SimpleMfvc + get() = this@b + } +} + +fun idUnboxed(x: SimpleMfvc) = x +fun idBoxed(x: SimpleMfvc?) = x!! + +fun box(): String { + val o1 = IC(2U) + require(ic(o1) == 2U) + val o2 = SimpleMfvc(1U, o1, "3") + val o2_ = SimpleMfvc(1U, o1, "-3") + require(smfvc(IC(4U), o2, 5U) == 12U) + val o3 = GreaterMfvc(o2, IC(6U), SimpleMfvc(7U, IC(8U), "9")) + require(gmfvc(IC(10U), o3, 11U) == 45U) + with(Extensions()) { + require(o2.x1 == o2) + } + with(Extensions.Companion) { + require(o2.y1 == o2) + require(o2.z1 == o2) + } + with(o2) { + require(Contexts().x1 == o2) + require(Contexts.y1 == o2) + require(Contexts.z1 == o2) + require(o2_.a3 == o2_) + require(o2_.b3 == o2_) + require(SimpleMfvc.a2 == o2) + require(SimpleMfvc.b2 == o2) + } + with(SimpleMfvc.Companion) { + require(o2_.a1 == o2_) + require(o2_.b1 == o2_) + } + + require(idUnboxed(idBoxed(idUnboxed(o2) /*boxing*/) /*unbox*/) == o2) + return "OK" +} diff --git a/compiler/testData/codegen/box/valueClasses/classFlattening.txt b/compiler/testData/codegen/box/valueClasses/classFlattening.txt new file mode 100644 index 00000000000..1c2e57cb34f --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/classFlattening.txt @@ -0,0 +1,175 @@ +@kotlin.Metadata +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 ic-K5cTq2M(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 method smfvc-Ket90g4(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 +} + +@kotlin.Metadata +public final class Contexts$Companion { + // source: 'classFlattening.kt' + private method (): void + public synthetic method (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 + private final method getPrivate1-sUp7gFk(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 + public final @org.jetbrains.annotations.NotNull method getY1-sUp7gFk(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 inner class Contexts$Companion +} + +@kotlin.Metadata +public final class Contexts { + // source: 'classFlattening.kt' + public final static @org.jetbrains.annotations.NotNull field Companion: Contexts$Companion + static method (): void + public method (): void + private final static method getPrivate2-sUp7gFk(p0: int, p1: int, p2: java.lang.String): SimpleMfvc + private final method getPrivate_-sUp7gFk(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 static @org.jetbrains.annotations.NotNull method getZ1-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc + public final inner class Contexts$Companion +} + +@kotlin.Metadata +public final class Extensions$Companion { + // source: 'classFlattening.kt' + private method (): void + public synthetic method (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 + private final method getPrivate1-sUp7gFk(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 + public final @org.jetbrains.annotations.NotNull method getY1-sUp7gFk(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 inner class Extensions$Companion +} + +@kotlin.Metadata +public final class Extensions { + // source: 'classFlattening.kt' + public final static @org.jetbrains.annotations.NotNull field Companion: Extensions$Companion + static method (): void + public method (): void + private final static method getPrivate2-sUp7gFk(p0: int, p1: int, p2: java.lang.String): SimpleMfvc + private final method getPrivate_-sUp7gFk(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 static @org.jetbrains.annotations.NotNull method getZ1-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): SimpleMfvc + public final inner class Extensions$Companion +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class GreaterMfvc { + // source: 'classFlattening.kt' + private final field field-0-0: int + private final field field-0-1: int + private final @org.jetbrains.annotations.NotNull field field-0-2: java.lang.String + private final field field-1: int + private final field field-2-0: int + private final field field-2-1: int + private final @org.jetbrains.annotations.NotNull field field-2-2: java.lang.String + private synthetic method (p0: int, p1: int, p2: java.lang.String, p3: int, p4: int, p5: int, p6: java.lang.String): void + public synthetic final static method box-impl(p0: int, p1: int, p2: java.lang.String, p3: int, p4: int, p5: int, p6: java.lang.String): GreaterMfvc + public final static method constructor-impl(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String, p3: int, p4: int, p5: int, @org.jetbrains.annotations.NotNull p6: 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: int, p4: int, p5: int, p6: java.lang.String, p7: java.lang.Object): boolean + public final static method equals-impl0(p0: int, p1: int, p2: java.lang.String, 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: java.lang.String): boolean + public method hashCode(): int + public static method hashCode-impl(p0: int, p1: int, p2: java.lang.String, p3: int, p4: int, p5: int, p6: 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, p3: int, p4: int, p5: int, p6: java.lang.String): java.lang.String + public synthetic final method unbox-impl-0(): SimpleMfvc + public synthetic final method unbox-impl-0-0(): int + public synthetic final method unbox-impl-0-1(): int + public synthetic final method unbox-impl-0-2(): java.lang.String + public synthetic final method unbox-impl-1(): int + public synthetic final method unbox-impl-2(): SimpleMfvc + public synthetic final method unbox-impl-2-0(): int + public synthetic final method unbox-impl-2-1(): int + public synthetic final method unbox-impl-2-2(): java.lang.String +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class IC { + // source: 'classFlattening.kt' + private final field x: int + private synthetic method (p0: int): void + public synthetic final static method box-impl(p0: int): IC + 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.Metadata +public final class SimpleMfvc$Companion { + // source: 'classFlattening.kt' + private method (): void + public synthetic method (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$getPrivate4-sUp7gFk(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 getA2-sUp7gFk(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 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 + private final method getPrivate1-sUp7gFk(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 getPrivate3-sUp7gFk(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 + public final inner class SimpleMfvc$Companion +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class SimpleMfvc { + // source: 'classFlattening.kt' + public final static @org.jetbrains.annotations.NotNull field Companion: SimpleMfvc$Companion + private final field field-0: int + private final field field-1: int + private final @org.jetbrains.annotations.NotNull field field-2: java.lang.String + static method (): void + private synthetic method (p0: int, p1: int, p2: java.lang.String): void + public synthetic final static method box-impl(p0: int, p1: int, p2: java.lang.String): SimpleMfvc + 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 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 getB1-sUp7gFk(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 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 + 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 getPrivate2-sUp7gFk(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 getPrivate4-sUp7gFk(p0: int, p1: int, p2: java.lang.String): 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-0(): int + public synthetic final method unbox-impl-1(): int + public synthetic final method unbox-impl-2(): java.lang.String + public final inner class SimpleMfvc$Companion +} diff --git a/compiler/testData/codegen/box/valueClasses/complex.kt b/compiler/testData/codegen/box/valueClasses/complex.kt new file mode 100644 index 00000000000..aeee82468a7 --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/complex.kt @@ -0,0 +1,304 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// https://youtrack.jetbrains.com/issue/KT-52236/Different-modality-in-psi-and-fir +// CHECK_BYTECODE_LISTING +// WITH_STDLIB +// TARGET_BACKEND: JVM_IR +// IGNORE_BACKEND: ANDROID, ANDROID_IR +// WORKS_WHEN_VALUE_CLASS +// LANGUAGE: +ValueClasses + +@JvmInline +value class A(val x: List) + +@JvmInline +value class B(val x: UInt) + +@JvmInline +value class C(val x: Int, val y: B, val z: String = "3") + +@JvmInline +value class D(val x: C) { + constructor(x: Int, y: UInt, z: Int) : this(C(x, B(y), z.toString())) + + init { + supply(x.x) + } +} + +inline fun inlined(x: Int, y: UInt, z: Int): D { + return D(C(x, B(y), z.toString())) +} + +fun notInlined(x: Int, y: UInt, z: Int) = D(C(x, B(y), z.toString())) + +@JvmInline +value class E(val x: D) { + var withNonTrivialSetters: D + get() = TODO() + set(_) = TODO() +} + +interface Base3 { + val z: E +} + +@JvmInline +value class R(val x: Int, val y: UInt, override val z: E, val t: A) : Base1, Base3 + +fun > f(r: R) { + supply(r) + supply(r.x) + supply(r.y) + supply(r.z) + supply(r.t) + supply(r.t.x) + supply(r.z.x) + supply(r.z.x.x) + supply(r.z.x.x.x) + supply(r.z.x.x.y) + supply(r.z.x.x.z) + supply(r.z.x.x.y.x) +} + +fun g(e: E) { + supply(e) +} + +fun > h(r: R) { + g(r.z) + f(r) + r + C(2, B(3U), "") + D(C(2, B(3U), "")) + val x = D(C(2, B(3U), "")) + var y = D(C(4, B(5U), "1")) + supply(y) + y = D(C(6, B(7U), "2")) + y = D(6, 7U, 2) + y = inlined(6, 7U, 2) + y = notInlined(6, 7U, 2) + supply(y) +} + +fun h1() { + var y = inlined(1, 2U, 3) // todo fix box + supply(y) + y = inlined(4, 5U, 6) + supply(y) +} + +interface Base1 { + val fakeOverrideMFVC: R> + get() = TODO() + val fakeOverrideRegular: Int + get() = TODO() +} + +interface Base2 { + var l: R> +} + +interface Base4 { + var l: T +} + +class NotInlined(override var l: R>, var y: Int) : Base1, Base2, Base4>> { + override fun toString(): String = l.toString() + l.z.x.x.z + + init { + l = l + } + + fun trySetter() { + l = l + } + + var withNonTrivialSetters: R> + get() = TODO() + set(_) = TODO() + + var withNonTrivialSettersWithBF: R> = l + get() { + supply("1") + field + field.t + field == field + return field + } + set(value) { + supply("3") + field = value + field = field + supply("4") + } + + val withNonTrivialGettersWithBF: R> = l + get() { + supply("1") + field + field.t + field == field + return field + } +} + +fun testVars(x: NotInlined) { + x.l.toString() + var y = x.l + y.toString() + y = x.l + supply(y) + x.l = x.l + x.l = R>(x.l.x, x.l.y, x.l.z, x.l.t) +} + +fun reuseBoxed(list: MutableList>>) { + list.add(list.last()) +} + +val lines = mutableListOf() + +fun supply(x: Any) { + lines.add(x.toString()) +} + +fun equalsChecks1(x: A>) {} +fun equalsChecks(left: R>, right: R>) { + supply(left == right) + supply(left as Any == right) + supply(left == right as Any) + supply(left as Any == right as Any) + supply(null == right) + supply(left == null) + supply(null as Any? == right) + supply(null as R>? == right) + supply(left == null as Any?) + supply(left == null as R>?) + supply(left as R>? == right) + supply(left == right as R>?) +} + +// todo add default parameters + +fun box(): String { + supply("#1") + require(inlined(1, 2U, 3) == D(C(1, B(2U), "3"))) + supply("#2") + require(notInlined(1, 2U, 3) == D(C(1, B(2U), "3"))) + supply("#3") + val e = E(D(3, 4U, 5)) + supply("#4") + val r = R(1, 2U, e, A(listOf(listOf(6)))) + supply("#5") + f(r) + supply("#6") + g(e) + supply("#7") + h(r) + supply("#8") + h1() + supply("#9") + val ni = NotInlined(r, 7) + supply("#10") + ni.withNonTrivialGettersWithBF + supply("#11") + ni.withNonTrivialSettersWithBF = ni.withNonTrivialSettersWithBF + supply("#12") + supply(ni.toString()) + supply("#13") + testVars(ni) + supply("#14") + reuseBoxed(mutableListOf(r)) + supply("#15") + equalsChecks(r, r) + supply("#16") + equalsChecks1(A(listOf(listOf()))) + supply("#17") + + val log = lines.joinToString("\n") + val expectedLog = + """ + #1 + 1 + 1 + #2 + 1 + 1 + #3 + 3 + #4 + #5 + R(x=1, y=2, z=E(x=D(x=C(x=3, y=B(x=4), z=5))), t=A(x=[[6]])) + 1 + 2 + E(x=D(x=C(x=3, y=B(x=4), z=5))) + A(x=[[6]]) + [[6]] + D(x=C(x=3, y=B(x=4), z=5)) + C(x=3, y=B(x=4), z=5) + 3 + B(x=4) + 5 + 4 + #6 + E(x=D(x=C(x=3, y=B(x=4), z=5))) + #7 + E(x=D(x=C(x=3, y=B(x=4), z=5))) + R(x=1, y=2, z=E(x=D(x=C(x=3, y=B(x=4), z=5))), t=A(x=[[6]])) + 1 + 2 + E(x=D(x=C(x=3, y=B(x=4), z=5))) + A(x=[[6]]) + [[6]] + D(x=C(x=3, y=B(x=4), z=5)) + C(x=3, y=B(x=4), z=5) + 3 + B(x=4) + 5 + 4 + 2 + 2 + 4 + D(x=C(x=4, y=B(x=5), z=1)) + 6 + 6 + 6 + 6 + D(x=C(x=6, y=B(x=7), z=2)) + #8 + 1 + D(x=C(x=1, y=B(x=2), z=3)) + 4 + D(x=C(x=4, y=B(x=5), z=6)) + #9 + #10 + 1 + #11 + 1 + 3 + 4 + #12 + R(x=1, y=2, z=E(x=D(x=C(x=3, y=B(x=4), z=5))), t=A(x=[[6]]))5 + #13 + R(x=1, y=2, z=E(x=D(x=C(x=3, y=B(x=4), z=5))), t=A(x=[[6]])) + #14 + #15 + true + true + true + true + false + false + false + false + false + false + true + true + #16 + #17 + """.trimIndent() + require(log == expectedLog) { log } + + return "OK" +} diff --git a/compiler/testData/codegen/box/valueClasses/complex.txt b/compiler/testData/codegen/box/valueClasses/complex.txt new file mode 100644 index 00000000000..0d7ed9bc934 --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/complex.txt @@ -0,0 +1,317 @@ +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class A { + // source: 'complex.kt' + private final @org.jetbrains.annotations.NotNull field x: java.util.List + private synthetic method (p0: java.util.List): void + public synthetic final static method box-impl(p0: java.util.List): A + public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.util.List): java.util.List + public method equals(p0: java.lang.Object): boolean + public static method equals-impl(p0: java.util.List, p1: java.lang.Object): boolean + public final static method equals-impl0(p0: java.util.List, p1: java.util.List): boolean + public final @org.jetbrains.annotations.NotNull method getX(): java.util.List + public method hashCode(): int + public static method hashCode-impl(p0: java.util.List): int + public method toString(): java.lang.String + public static method toString-impl(p0: java.util.List): java.lang.String + public synthetic final method unbox-impl(): java.util.List +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class B { + // source: 'complex.kt' + private final field x: int + private synthetic method (p0: int): void + public synthetic final static method box-impl(p0: int): B + 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.Metadata +public final class Base1$DefaultImpls { + // source: 'complex.kt' + public static @org.jetbrains.annotations.NotNull method getFakeOverrideMFVC(@org.jetbrains.annotations.NotNull p0: Base1): R + public synthetic static method getFakeOverrideMFVC-0(p0: Base1): int + public synthetic static method getFakeOverrideMFVC-1(p0: Base1): int + public synthetic static method getFakeOverrideMFVC-2(p0: Base1): E + public synthetic static method getFakeOverrideMFVC-2-0(p0: Base1): D + public synthetic static method getFakeOverrideMFVC-2-0-0(p0: Base1): C + public synthetic static method getFakeOverrideMFVC-2-0-0-0(p0: Base1): int + public synthetic static method getFakeOverrideMFVC-2-0-0-1(p0: Base1): int + public synthetic static method getFakeOverrideMFVC-2-0-0-2(p0: Base1): java.lang.String + public synthetic static method getFakeOverrideMFVC-3(p0: Base1): java.util.List + public static method getFakeOverrideRegular(@org.jetbrains.annotations.NotNull p0: Base1): int + public final inner class Base1$DefaultImpls +} + +@kotlin.Metadata +public interface Base1 { + // source: 'complex.kt' + public abstract @org.jetbrains.annotations.NotNull method getFakeOverrideMFVC(): R + public synthetic abstract method getFakeOverrideMFVC-0(): int + public synthetic abstract method getFakeOverrideMFVC-1(): int + public synthetic abstract method getFakeOverrideMFVC-2(): E + public synthetic abstract method getFakeOverrideMFVC-2-0(): D + public synthetic abstract method getFakeOverrideMFVC-2-0-0(): C + public synthetic abstract method getFakeOverrideMFVC-2-0-0-0(): int + public synthetic abstract method getFakeOverrideMFVC-2-0-0-1(): int + public synthetic abstract method getFakeOverrideMFVC-2-0-0-2(): java.lang.String + public synthetic abstract method getFakeOverrideMFVC-3(): java.util.List + public abstract method getFakeOverrideRegular(): int + public final inner class Base1$DefaultImpls +} + +@kotlin.Metadata +public interface Base2 { + // source: 'complex.kt' + public abstract @org.jetbrains.annotations.NotNull method getL(): R + public synthetic abstract method getL-0(): int + public synthetic abstract method getL-1(): int + public synthetic abstract method getL-2(): E + public synthetic abstract method getL-2-0(): D + public synthetic abstract method getL-2-0-0(): C + public synthetic abstract method getL-2-0-0-0(): int + public synthetic abstract method getL-2-0-0-1(): int + public synthetic abstract method getL-2-0-0-2(): java.lang.String + public synthetic abstract method getL-3(): java.util.List + 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 +} + +@kotlin.Metadata +public interface Base3 { + // source: 'complex.kt' + public abstract @org.jetbrains.annotations.NotNull method getZ(): E + public synthetic abstract method getZ-0(): D + public synthetic abstract method getZ-0-0(): C + public synthetic abstract method getZ-0-0-0(): int + public synthetic abstract method getZ-0-0-1(): int + public synthetic abstract method getZ-0-0-2(): java.lang.String +} + +@kotlin.Metadata +public interface Base4 { + // source: 'complex.kt' + public abstract method getL(): java.lang.Object + public abstract method setL(p0: java.lang.Object): void +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class C { + // source: 'complex.kt' + private final field field-0: int + private final field field-1: int + private final @org.jetbrains.annotations.NotNull field field-2: java.lang.String + private synthetic method (p0: int, p1: int, p2: java.lang.String): void + public synthetic final static method box-impl(p0: int, p1: int, p2: java.lang.String): C + 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 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-0(): int + public synthetic final method unbox-impl-1(): int + public synthetic final method unbox-impl-2(): java.lang.String +} + +@kotlin.Metadata +public final class ComplexKt { + // source: 'complex.kt' + private final static @org.jetbrains.annotations.NotNull field lines: java.util.List + static method (): 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 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 g-sUp7gFk(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): void + 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 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 supply(@org.jetbrains.annotations.NotNull p0: java.lang.Object): void + public final static method testVars(@org.jetbrains.annotations.NotNull p0: NotInlined): void +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class D { + // source: 'complex.kt' + private final field field-0-0: int + private final field field-0-1: int + private final @org.jetbrains.annotations.NotNull field field-0-2: java.lang.String + private synthetic method (p0: int, p1: int, p2: java.lang.String): void + public synthetic final static method box-impl(p0: int, p1: int, p2: java.lang.String): D + public final static method constructor-impl(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): void + public final static @org.jetbrains.annotations.NotNull method constructor-impl(p0: int, p1: int, p2: int): D + 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 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-0(): C + public synthetic final method unbox-impl-0-0(): int + public synthetic final method unbox-impl-0-1(): int + public synthetic final method unbox-impl-0-2(): java.lang.String +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class E { + // source: 'complex.kt' + private final field field-0-0-0: int + private final field field-0-0-1: int + private final @org.jetbrains.annotations.NotNull field field-0-0-2: java.lang.String + private synthetic method (p0: int, p1: int, p2: java.lang.String): void + public synthetic final static method box-impl(p0: int, p1: int, p2: java.lang.String): E + 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 static @org.jetbrains.annotations.NotNull method getWithNonTrivialSetters-impl(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): 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 @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-0(): D + public synthetic final method unbox-impl-0-0(): C + public synthetic final method unbox-impl-0-0-0(): int + public synthetic final method unbox-impl-0-0-1(): int + public synthetic final method unbox-impl-0-0-2(): java.lang.String +} + +@kotlin.Metadata +public final class NotInlined { + // source: 'complex.kt' + private field l-0: int + private field l-1: int + private field l-2-0-0-0: int + private field l-2-0-0-1: int + private @org.jetbrains.annotations.NotNull field l-2-0-0-2: java.lang.String + private @org.jetbrains.annotations.NotNull field l-3: java.util.List + private final field withNonTrivialGettersWithBF-0: int + private final field withNonTrivialGettersWithBF-1: int + private final field withNonTrivialGettersWithBF-2-0-0-0: int + private final field withNonTrivialGettersWithBF-2-0-0-1: int + private final @org.jetbrains.annotations.NotNull field withNonTrivialGettersWithBF-2-0-0-2: java.lang.String + private final @org.jetbrains.annotations.NotNull field withNonTrivialGettersWithBF-3: java.util.List + private field withNonTrivialSettersWithBF-0: int + private field withNonTrivialSettersWithBF-1: int + private field withNonTrivialSettersWithBF-2-0-0-0: int + private field withNonTrivialSettersWithBF-2-0-0-1: int + private @org.jetbrains.annotations.NotNull field withNonTrivialSettersWithBF-2-0-0-2: java.lang.String + private @org.jetbrains.annotations.NotNull field withNonTrivialSettersWithBF-3: java.util.List + private field y: int + private method (p0: int, p1: int, p2: int, p3: int, p4: java.lang.String, p5: java.util.List, p6: int): void + public synthetic method (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 @org.jetbrains.annotations.NotNull method getL(): R + public synthetic bridge method getL(): java.lang.Object + public synthetic method getL-0(): int + public synthetic method getL-1(): int + public synthetic method getL-2(): E + public synthetic method getL-2-0(): D + public synthetic method getL-2-0-0(): C + public synthetic method getL-2-0-0-0(): int + public synthetic method getL-2-0-0-1(): int + public synthetic method getL-2-0-0-2(): java.lang.String + public synthetic method getL-3(): java.util.List + public final @org.jetbrains.annotations.NotNull method getWithNonTrivialGettersWithBF(): R + public synthetic final method getWithNonTrivialGettersWithBF-0(): int + public synthetic final method getWithNonTrivialGettersWithBF-1(): int + public synthetic final method getWithNonTrivialGettersWithBF-2(): E + public synthetic final method getWithNonTrivialGettersWithBF-2-0(): D + public synthetic final method getWithNonTrivialGettersWithBF-2-0-0(): C + public synthetic final method getWithNonTrivialGettersWithBF-2-0-0-0(): int + public synthetic final method getWithNonTrivialGettersWithBF-2-0-0-1(): int + public synthetic final method getWithNonTrivialGettersWithBF-2-0-0-2(): java.lang.String + public synthetic final method getWithNonTrivialGettersWithBF-3(): java.util.List + public final @org.jetbrains.annotations.NotNull method getWithNonTrivialSetters(): R + public synthetic final method getWithNonTrivialSetters-0(): int + public synthetic final method getWithNonTrivialSetters-1(): int + public synthetic final method getWithNonTrivialSetters-2(): E + public synthetic final method getWithNonTrivialSetters-2-0(): D + public synthetic final method getWithNonTrivialSetters-2-0-0(): C + public synthetic final method getWithNonTrivialSetters-2-0-0-0(): int + public synthetic final method getWithNonTrivialSetters-2-0-0-1(): int + public synthetic final method getWithNonTrivialSetters-2-0-0-2(): java.lang.String + public synthetic final method getWithNonTrivialSetters-3(): java.util.List + public final @org.jetbrains.annotations.NotNull method getWithNonTrivialSettersWithBF(): R + public synthetic final method getWithNonTrivialSettersWithBF-0(): int + public synthetic final method getWithNonTrivialSettersWithBF-1(): int + public synthetic final method getWithNonTrivialSettersWithBF-2(): E + public synthetic final method getWithNonTrivialSettersWithBF-2-0(): D + public synthetic final method getWithNonTrivialSettersWithBF-2-0-0(): C + public synthetic final method getWithNonTrivialSettersWithBF-2-0-0-0(): int + public synthetic final method getWithNonTrivialSettersWithBF-2-0-0-1(): int + public synthetic final method getWithNonTrivialSettersWithBF-2-0-0-2(): java.lang.String + public synthetic final method getWithNonTrivialSettersWithBF-3(): java.util.List + 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 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 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 setY(p0: int): void + public @org.jetbrains.annotations.NotNull method toString(): java.lang.String + public final method trySetter(): void + public final inner class Base1$DefaultImpls +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class R { + // source: 'complex.kt' + private final field field-0: int + private final field field-1: int + private final field field-2-0-0-0: int + private final field field-2-0-0-1: int + private final @org.jetbrains.annotations.NotNull field field-2-0-0-2: java.lang.String + private final @org.jetbrains.annotations.NotNull field field-3: java.util.List + private synthetic method (p0: int, p1: int, p2: int, p3: int, p4: java.lang.String, p5: java.util.List): void + public synthetic final static method box-impl(p0: int, p1: int, p2: int, p3: int, p4: java.lang.String, p5: java.util.List): R + public final static method constructor-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): 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: java.lang.String, p5: java.util.List, p6: java.lang.Object): boolean + public final static method equals-impl0(p0: int, p1: int, p2: int, p3: int, p4: java.lang.String, p5: java.util.List, p6: int, p7: int, p8: int, p9: int, p10: java.lang.String, p11: java.util.List): boolean + public @org.jetbrains.annotations.NotNull method getFakeOverrideMFVC(): 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 @org.jetbrains.annotations.NotNull method getZ(): E + public synthetic bridge method getZ-0(): D + public synthetic bridge method getZ-0-0(): C + public synthetic bridge method getZ-0-0-0(): int + public synthetic bridge method getZ-0-0-1(): int + public synthetic bridge method getZ-0-0-2(): java.lang.String + public method hashCode(): int + public static method hashCode-impl(p0: int, p1: int, p2: int, p3: int, p4: java.lang.String, p5: java.util.List): 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: java.lang.String, p5: java.util.List): java.lang.String + public synthetic final method unbox-impl-0(): int + public synthetic final method unbox-impl-1(): int + public synthetic final method unbox-impl-2(): E + public synthetic final method unbox-impl-2-0(): D + public synthetic final method unbox-impl-2-0-0(): C + public synthetic final method unbox-impl-2-0-0-0(): int + public synthetic final method unbox-impl-2-0-0-1(): int + public synthetic final method unbox-impl-2-0-0-2(): java.lang.String + public synthetic final method unbox-impl-3(): java.util.List + public final inner class Base1$DefaultImpls +} diff --git a/compiler/testData/codegen/box/valueClasses/conditionalExpressions.kt b/compiler/testData/codegen/box/valueClasses/conditionalExpressions.kt new file mode 100644 index 00000000000..23a8dda02bf --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/conditionalExpressions.kt @@ -0,0 +1,53 @@ +// CHECK_BYTECODE_LISTING +// WITH_STDLIB +// TARGET_BACKEND: JVM_IR +// WORKS_WHEN_VALUE_CLASS +// LANGUAGE: +ValueClasses + +@JvmInline +value class DPoint(val x: Double, val y: Double) { + init { + counter++ + } + companion object { + @JvmStatic + var counter: Int = 0 + } +} + +fun ifExpr() = if (DPoint(0.0, 1.0).x > 0.0) DPoint(2.0, 3.0) else DPoint(4.0, 5.0) + +fun whenExpr() = when { + DPoint(6.0, 7.0).x > 0.0 -> DPoint(8.0, 9.0) + DPoint(10.0, 11.0).x > 0.0 -> DPoint(12.0, 13.0) + else -> DPoint(14.0, 15.0) +} + +fun ifBody() { + if (DPoint(0.0, 1.0).x > 0.0) DPoint(2.0, 3.0) else DPoint(4.0, 5.0) + val x = if (DPoint(0.0, 1.0).x > 0.0) DPoint(2.0, 3.0) else DPoint(4.0, 5.0) + require(x == DPoint(4.0, 5.0)) +} + +fun whenBody() { + when { + DPoint(6.0, 7.0).x > 0.0 -> DPoint(8.0, 9.0) + DPoint(10.0, 11.0).x > 0.0 -> DPoint(12.0, 13.0) + else -> DPoint(14.0, 15.0) + } + val x = when { + DPoint(6.0, 7.0).x > 0.0 -> DPoint(8.0, 9.0) + DPoint(10.0, 11.0).x > 0.0 -> DPoint(12.0, 13.0) + else -> DPoint(14.0, 15.0) + } + require(x == DPoint(8.0, 9.0)) +} + +fun box(): String { + ifBody() + whenBody() + require(ifExpr() == DPoint(4.0, 5.0)) + require(whenExpr() == DPoint(8.0, 9.0)) + require(DPoint.counter == 5 + 5 + 2 + 1 + 2 + 1) + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/valueClasses/conditionalExpressions.txt b/compiler/testData/codegen/box/valueClasses/conditionalExpressions.txt new file mode 100644 index 00000000000..9fc5090a38b --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/conditionalExpressions.txt @@ -0,0 +1,49 @@ +@kotlin.Metadata +public final class ConditionalExpressionsKt { + // source: 'conditionalExpressions.kt' + public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String + public final static method ifBody(): void + public final static @org.jetbrains.annotations.NotNull method ifExpr(): DPoint + public final static method whenBody(): void + public final static @org.jetbrains.annotations.NotNull method whenExpr(): DPoint + public final inner class DPoint$Companion +} + +@kotlin.Metadata +public final class DPoint$Companion { + // source: 'conditionalExpressions.kt' + private method (): void + public synthetic method (p0: kotlin.jvm.internal.DefaultConstructorMarker): void + public synthetic deprecated static @kotlin.jvm.JvmStatic method getCounter$annotations(): void + public final method getCounter(): int + public final method setCounter(p0: int): void + public final inner class DPoint$Companion +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class DPoint { + // source: 'conditionalExpressions.kt' + public final static @org.jetbrains.annotations.NotNull field Companion: DPoint$Companion + private static field counter: int + private final field field-0: double + private final field field-1: double + static method (): void + private synthetic method (p0: double, p1: double): void + public synthetic final static method access$getCounter$cp(): int + public synthetic final static method access$setCounter$cp(p0: int): 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 static method getCounter(): int + public method hashCode(): int + public static method hashCode-impl(p0: double, p1: double): int + public final static method setCounter(p0: int): 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-0(): double + public synthetic final method unbox-impl-1(): double + public final inner class DPoint$Companion +} diff --git a/compiler/testData/codegen/box/valueClasses/equality.kt b/compiler/testData/codegen/box/valueClasses/equality.kt index 39353481dc2..220a66ec0e1 100644 --- a/compiler/testData/codegen/box/valueClasses/equality.kt +++ b/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) diff --git a/compiler/testData/codegen/box/valueClasses/equality.txt b/compiler/testData/codegen/box/valueClasses/equality.txt new file mode 100644 index 00000000000..9cab488617f --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/equality.txt @@ -0,0 +1,217 @@ +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class A { + // source: 'equality.kt' + private final field field-0: int + private final field field-1: int + private final field field-2-0: int + private final field field-2-1: int + private final field field-3: int + private final field field-4: int + private final @org.jetbrains.annotations.NotNull field field-5: java.lang.String + private final field field-6: int + private final field field-7: int + private final @org.jetbrains.annotations.NotNull field field-8: java.lang.String + private synthetic method (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 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-impl-0(): int + public synthetic final method unbox-impl-1(): int + public synthetic final method unbox-impl-2(): F3 + public synthetic final method unbox-impl-2-0(): int + public synthetic final method unbox-impl-2-1(): int + public synthetic final method unbox-impl-3(): int + public synthetic final method unbox-impl-4(): int + public synthetic final method unbox-impl-5(): java.lang.String + public synthetic final method unbox-impl-6(): int + public synthetic final method unbox-impl-7(): int + public synthetic final method unbox-impl-8(): java.lang.String +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class B { + // source: 'equality.kt' + private final field field-0-0: int + private final field field-0-1: int + private final field field-0-2-0: int + private final field field-0-2-1: int + private final field field-0-3: int + private final field field-0-4: int + private final @org.jetbrains.annotations.NotNull field field-0-5: java.lang.String + private final field field-0-6: int + private final field field-0-7: int + private final @org.jetbrains.annotations.NotNull field field-0-8: java.lang.String + private final field field-1-0: int + private final field field-1-1: int + private final field field-1-2-0: int + private final field field-1-2-1: int + private final field field-1-3: int + private final field field-1-4: int + private final @org.jetbrains.annotations.NotNull field field-1-5: java.lang.String + private final field field-1-6: int + private final field field-1-7: int + private final @org.jetbrains.annotations.NotNull field field-1-8: java.lang.String + private synthetic method (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 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-impl-0(): A + public synthetic final method unbox-impl-0-0(): int + public synthetic final method unbox-impl-0-1(): int + public synthetic final method unbox-impl-0-2(): F3 + public synthetic final method unbox-impl-0-2-0(): int + public synthetic final method unbox-impl-0-2-1(): int + public synthetic final method unbox-impl-0-3(): int + public synthetic final method unbox-impl-0-4(): int + public synthetic final method unbox-impl-0-5(): java.lang.String + public synthetic final method unbox-impl-0-6(): int + public synthetic final method unbox-impl-0-7(): int + public synthetic final method unbox-impl-0-8(): java.lang.String + public synthetic final method unbox-impl-1(): A + public synthetic final method unbox-impl-1-0(): int + public synthetic final method unbox-impl-1-1(): int + public synthetic final method unbox-impl-1-2(): F3 + public synthetic final method unbox-impl-1-2-0(): int + public synthetic final method unbox-impl-1-2-1(): int + public synthetic final method unbox-impl-1-3(): int + public synthetic final method unbox-impl-1-4(): int + public synthetic final method unbox-impl-1-5(): java.lang.String + public synthetic final method unbox-impl-1-6(): int + public synthetic final method unbox-impl-1-7(): int + public synthetic final method unbox-impl-1-8(): 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 (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 (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 final field field-0: int + private final field field-1: int + private synthetic method (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 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-impl-0(): int + public synthetic final method unbox-impl-1(): int +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class F4 { + // source: 'equality.kt' + private final field x: int + private synthetic method (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 (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 (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 +} diff --git a/compiler/testData/codegen/box/valueClasses/forStatement.kt b/compiler/testData/codegen/box/valueClasses/forStatement.kt new file mode 100644 index 00000000000..3c0b96b410e --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/forStatement.kt @@ -0,0 +1,16 @@ +// WITH_STDLIB +// TARGET_BACKEND: JVM_IR +// WORKS_WHEN_VALUE_CLASS +// LANGUAGE: +ValueClasses + +@JvmInline +value class DPoint(val x: Double, val y: Double) + +fun box(): String { + var res = 0.0 + for (x in listOf(DPoint(1.0, 2.0), DPoint(3.0, 4.0))) { + res += x.x + x.y + } + require(res == 10.0) + return "OK" +} diff --git a/compiler/testData/codegen/box/valueClasses/mfvcFieldInitializationOrder.kt b/compiler/testData/codegen/box/valueClasses/mfvcFieldInitializationOrder.kt new file mode 100644 index 00000000000..21a92ef38ea --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/mfvcFieldInitializationOrder.kt @@ -0,0 +1,27 @@ +// WITH_STDLIB +// TARGET_BACKEND: JVM_IR +// WORKS_WHEN_VALUE_CLASS +// LANGUAGE: +ValueClasses +// CHECK_BYTECODE_LISTING + +@JvmInline +value class DPoint(val x: Double, val y: Double) + +class A(var x: DPoint) { + init { x = DPoint(2.0, 3.0) } +} + +class B() { + var a = DPoint(4.0, 5.0) + val b = a + init { a = DPoint(6.0, 7.0) } + val c = a +} + +fun box(): String { + require(A(DPoint(0.0, 1.0)).x == DPoint(2.0, 3.0)) { "No init used" } + require(B().a == DPoint(6.0, 7.0)) { "No init used" } + require(B().b == DPoint(4.0, 5.0)) { "Wrong init order used" } + require(B().c == DPoint(6.0, 7.0)) { "Wrong init order used" } + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/valueClasses/mfvcFieldInitializationOrder.txt b/compiler/testData/codegen/box/valueClasses/mfvcFieldInitializationOrder.txt new file mode 100644 index 00000000000..fe8f71ee204 --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/mfvcFieldInitializationOrder.txt @@ -0,0 +1,59 @@ +@kotlin.Metadata +public final class A { + // source: 'mfvcFieldInitializationOrder.kt' + private field x-0: double + private field x-1: double + public method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method getX(): DPoint + public synthetic final method getX-0(): double + public synthetic final method getX-1(): double + public final method setX-sUp7gFk(p0: double, p1: double): void +} + +@kotlin.Metadata +public final class B { + // source: 'mfvcFieldInitializationOrder.kt' + private field a-0: double + private field a-1: double + private final field b-0: double + private final field b-1: double + private final field c-0: double + private final field c-1: double + public method (): void + public final @org.jetbrains.annotations.NotNull method getA(): DPoint + public synthetic final method getA-0(): double + public synthetic final method getA-1(): double + public final @org.jetbrains.annotations.NotNull method getB(): DPoint + public synthetic final method getB-0(): double + public synthetic final method getB-1(): double + public final @org.jetbrains.annotations.NotNull method getC(): DPoint + public synthetic final method getC-0(): double + public synthetic final method getC-1(): double + public final method setA-sUp7gFk(p0: double, p1: double): void +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class DPoint { + // source: 'mfvcFieldInitializationOrder.kt' + private final field field-0: double + private final field field-1: double + private synthetic method (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 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-0(): double + public synthetic final method unbox-impl-1(): double +} + +@kotlin.Metadata +public final class MfvcFieldInitializationOrderKt { + // source: 'mfvcFieldInitializationOrder.kt' + public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String +} diff --git a/compiler/testData/codegen/box/valueClasses/overrides.kt b/compiler/testData/codegen/box/valueClasses/overrides.kt new file mode 100644 index 00000000000..828a385921d --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/overrides.kt @@ -0,0 +1,311 @@ +// 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 { + val x: T + val y: T +} + +@JvmInline +value class DPoint(override val x: Double, override val y: Double): AbstractPoint + +interface GenericMFVCHolder { + var p: T + var p1: T +} + +interface GenericMFVCHolderWithMFVCUpperBound { + var p: T + var p1: T +} + +interface ReifiedMFVCHolder { + var p: DPoint + var p1: DPoint +} + +data class DataClassException(val value: Any?): Exception() + +interface GenericMFVCHolderWithImpls { + 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 { + 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, ReifiedMFVCHolder, GenericMFVCHolderWithMFVCUpperBound { + override var p1: DPoint + get() = throw DataClassException(13) + set(value) = throw DataClassException(14 to value) +} + +class GenericFakeOverride : GenericMFVCHolderWithImpls +class ReifiedFakeOverride : ReifiedMFVCHolderWithImpls +class GenericFakeOverrideWithMFVCUpperBound : GenericMFVCHolderWithMFVCUpperBoundWithImpls + + +@JvmInline +value class GenericFakeOverrideMFVC(val field1: Double, val field2: Double) : GenericMFVCHolderWithImpls +@JvmInline +value class ReifiedFakeOverrideMFVC(val field1: Double, val field2: Double) : ReifiedMFVCHolderWithImpls +@JvmInline +value class GenericFakeOverrideMFVCWithMFVCUpperBound(val field1: Double, val field2: Double) : GenericMFVCHolderWithMFVCUpperBoundWithImpls + + +interface SomePointInterface { + var somethingRegular: Int + + var somethingGeneric: T + + var somethingMFVC: DPoint +} + +interface SomePointInterfaceWithMFVCBound { + var somethingRegular: Int + + var somethingGeneric: T + + var somethingMFVC: DPoint +} + +@JvmInline +value class DPointWithInterface(val x: Double, val y: Double) : SomePointInterface, SomePointInterfaceWithMFVCBound { + 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 { + val p1: T + val p2: T +} + +@JvmInline +value class DSegment(override val p1: DPoint, override val p2: DPoint): AbstractSegment + +fun 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, 2.0) + + val lam1: () -> DPoint = { throw DataClassException(1) } + val lam2: () -> Unit = { throw DataClassException(2 to dPoint) } + val lam3: () -> DPoint = { throw DataClassException(3) } + val lam4: () -> Unit = { throw DataClassException(4 to dPoint) } + val lam5: () -> DPoint = { throw DataClassException(5) } + val lam6: () -> Unit = { throw DataClassException(6 to dPoint) } + val lam7: () -> DPoint = { throw DataClassException(7) } + val lam8: () -> Unit = { throw DataClassException(8 to dPoint) } + val lam9: () -> DPoint = { throw DataClassException(9) } + val lam10: () -> Unit = { throw DataClassException(10 to dPoint) } + val lam11: () -> DPoint = { throw DataClassException(11) } + val lam12: () -> Unit = { throw DataClassException(12 to dPoint) } + val lam13: () -> DPoint = { throw DataClassException(13) } + val lam14: () -> Unit = { throw DataClassException(14 to dPoint) } + val lam15: () -> DPoint = { throw DataClassException(15) } + val lam16: () -> Unit = { throw DataClassException(16 to dPoint) } + val lam17: () -> DPoint = { throw DataClassException(17) } + val lam18: () -> Unit = { throw DataClassException(18 to dPoint) } + val lam19: () -> Int = { throw DataClassException(19) } + val lam20: () -> Unit = { throw DataClassException(20 to 1) } + val emptyLam = {} + val dPointLam = { dPoint } + val otherDPoint = DPoint(3.0, 4.0) + val otherDPointLam = { otherDPoint } + equal({ "DPoint(x=1.0, y=2.0)" }, { dPoint.toString() }) + equal({ "DPoint(x=1.0, y=2.0)" }, { (dPoint as Any).toString() }) + + equal({ true }, { dPoint.equals(dPoint) }) + equal({ true }, { dPoint.equals(dPoint as Any) }) + equal({ true }, { (dPoint as Any).equals(dPoint) }) + equal({ true }, { (dPoint as Any).equals(dPoint as Any) }) + + equal({ false }, { dPoint.equals(otherDPoint) }) + equal({ false }, { dPoint.equals(otherDPoint as Any) }) + equal({ false }, { (dPoint as Any).equals(otherDPoint) }) + equal({ false }, { (dPoint as Any).equals(otherDPoint as Any) }) + + equal({ dPoint.hashCode() }, { (dPoint as Any).hashCode() }) + + equal({ 1.0 }, { dPoint.x }) + equal({ 1.0 }, { (dPoint as AbstractPoint).x }) + equal({ 2.0 }, { dPoint.y }) + equal({ 2.0 }, { (dPoint as AbstractPoint).y }) + + + val realOverride = RealOverride(dPoint) + + equal(dPointLam, { realOverride.p }) + equal(dPointLam, { (realOverride as GenericMFVCHolder).p }) + equal(lam13, { realOverride.p1 }) + equal(lam13, { (realOverride as GenericMFVCHolder).p1 }) + equal(dPointLam, { (realOverride as ReifiedMFVCHolder).p }) + equal(lam13, { realOverride.p1 }) + equal(lam13, { (realOverride as ReifiedMFVCHolder).p1 }) + equal(dPointLam, { (realOverride as GenericMFVCHolderWithMFVCUpperBound).p }) + equal(lam13, { (realOverride as GenericMFVCHolderWithMFVCUpperBound).p1 }) + + + equal(emptyLam, { realOverride.p = dPoint }) + equal(emptyLam, { (realOverride as GenericMFVCHolder).p = dPoint }) + equal(lam14, { realOverride.p1 = dPoint }) + equal(lam14, { (realOverride as GenericMFVCHolder).p1 = dPoint }) + equal(emptyLam, { (realOverride as ReifiedMFVCHolder).p = dPoint }) + equal(lam14, { (realOverride as ReifiedMFVCHolder).p1 = dPoint }) + equal(emptyLam, { (realOverride as GenericMFVCHolderWithMFVCUpperBound).p = dPoint }) + equal(lam14, { (realOverride as GenericMFVCHolderWithMFVCUpperBound).p1 = dPoint }) + + + val genericFakeOverride = GenericFakeOverride() + + equal(lam1, { genericFakeOverride.p }) + equal(lam1, { (genericFakeOverride as GenericMFVCHolderWithImpls).p }) + equal(lam3, { genericFakeOverride.p1 }) + equal(lam3, { (genericFakeOverride as GenericMFVCHolderWithImpls).p1 }) + val reifiedFakeOverride = ReifiedFakeOverride() + equal(lam9, { reifiedFakeOverride.p }) + equal(lam9, { (reifiedFakeOverride as ReifiedMFVCHolderWithImpls).p }) + equal(lam11, { reifiedFakeOverride.p1 }) + equal(lam11, { (reifiedFakeOverride as ReifiedMFVCHolderWithImpls).p1 }) + val genericFakeOverrideWithMFVCUpperBound = GenericFakeOverrideWithMFVCUpperBound() + equal(lam5, { genericFakeOverrideWithMFVCUpperBound.p }) + equal(lam5, { (genericFakeOverrideWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls).p }) + equal(lam7, { genericFakeOverrideWithMFVCUpperBound.p1 }) + equal(lam7, { (genericFakeOverrideWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls).p1 }) + + equal(lam2, { genericFakeOverride.p = dPoint }) + equal(lam2, { (genericFakeOverride as GenericMFVCHolderWithImpls).p = dPoint }) + equal(lam4, { genericFakeOverride.p1 = dPoint }) + equal(lam4, { (genericFakeOverride as GenericMFVCHolderWithImpls).p1 = dPoint }) + equal(lam10, { reifiedFakeOverride.p = dPoint }) + equal(lam10, { (reifiedFakeOverride as ReifiedMFVCHolderWithImpls).p = dPoint }) + equal(lam12, { reifiedFakeOverride.p1 = dPoint }) + equal(lam12, { (reifiedFakeOverride as ReifiedMFVCHolderWithImpls).p1 = dPoint }) + equal(lam6, { genericFakeOverrideWithMFVCUpperBound.p = dPoint }) + equal(lam6, { (genericFakeOverrideWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls).p = dPoint }) + equal(lam8, { genericFakeOverrideWithMFVCUpperBound.p1 = dPoint }) + equal(lam8, { (genericFakeOverrideWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls).p1 = dPoint }) + + + val genericFakeOverrideMFVC = GenericFakeOverrideMFVC(1.0, 2.0) + + equal(lam1, { genericFakeOverrideMFVC.p }) + equal(lam1, { (genericFakeOverrideMFVC as GenericMFVCHolderWithImpls).p }) + equal(lam3, { genericFakeOverrideMFVC.p1 }) + equal(lam3, { (genericFakeOverrideMFVC as GenericMFVCHolderWithImpls).p1 }) + + val reifiedFakeOverrideMFVC = ReifiedFakeOverrideMFVC(1.0, 2.0) + equal(lam9, { reifiedFakeOverrideMFVC.p }) + equal(lam9, { (reifiedFakeOverrideMFVC as ReifiedMFVCHolderWithImpls).p }) + equal(lam11, { reifiedFakeOverrideMFVC.p1 }) + equal(lam11, { (reifiedFakeOverrideMFVC as ReifiedMFVCHolderWithImpls).p1 }) + + val genericFakeOverrideMFVCWithMFVCUpperBound = GenericFakeOverrideMFVCWithMFVCUpperBound(1.0, 2.0) + equal(lam5, { genericFakeOverrideMFVCWithMFVCUpperBound.p }) + equal(lam5, { (genericFakeOverrideMFVCWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls).p }) + equal(lam7, { genericFakeOverrideMFVCWithMFVCUpperBound.p1 }) + equal(lam7, { (genericFakeOverrideMFVCWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls).p1 }) + + equal(lam2, { genericFakeOverrideMFVC.p = dPoint }) + equal(lam2, { (genericFakeOverrideMFVC as GenericMFVCHolderWithImpls).p = dPoint }) + equal(lam4, { genericFakeOverrideMFVC.p1 = dPoint }) + equal(lam4, { (genericFakeOverrideMFVC as GenericMFVCHolderWithImpls).p1 = dPoint }) + + equal(lam10, { reifiedFakeOverrideMFVC.p = dPoint }) + equal(lam10, { (reifiedFakeOverrideMFVC as ReifiedMFVCHolderWithImpls).p = dPoint }) + equal(lam12, { reifiedFakeOverrideMFVC.p1 = dPoint }) + equal(lam12, { (reifiedFakeOverrideMFVC as ReifiedMFVCHolderWithImpls).p1 = dPoint }) + + equal(lam6, { genericFakeOverrideMFVCWithMFVCUpperBound.p = dPoint }) + equal(lam6, { (genericFakeOverrideMFVCWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls).p = dPoint }) + equal(lam8, { genericFakeOverrideMFVCWithMFVCUpperBound.p1 = dPoint }) + equal(lam8, { (genericFakeOverrideMFVCWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls).p1 = dPoint }) + + + val dPointWithInterface = DPointWithInterface(1.0, 2.0) + + equal(lam15, { dPointWithInterface.somethingGeneric }) + equal(lam15, { (dPointWithInterface as SomePointInterface).somethingGeneric }) + equal(lam19, { dPointWithInterface.somethingRegular }) + equal(lam19, { (dPointWithInterface as SomePointInterface).somethingRegular }) + equal(lam17, { dPointWithInterface.somethingMFVC }) + equal(lam17, { (dPointWithInterface as SomePointInterface).somethingMFVC }) + + equal(lam15, { (dPointWithInterface as SomePointInterfaceWithMFVCBound).somethingGeneric }) + equal(lam19, { (dPointWithInterface as SomePointInterfaceWithMFVCBound).somethingRegular }) + equal(lam17, { (dPointWithInterface as SomePointInterfaceWithMFVCBound).somethingMFVC }) + + equal(lam16, { dPointWithInterface.somethingGeneric = dPoint }) + equal(lam16, { (dPointWithInterface as SomePointInterface).somethingGeneric = dPoint }) + equal(lam20, { dPointWithInterface.somethingRegular = 1 }) + equal(lam20, { (dPointWithInterface as SomePointInterface).somethingRegular = 1 }) + equal(lam18, { dPointWithInterface.somethingMFVC = dPoint }) + equal(lam18, { (dPointWithInterface as SomePointInterface).somethingMFVC = dPoint }) + + equal(lam16, { (dPointWithInterface as SomePointInterfaceWithMFVCBound).somethingGeneric = dPoint }) + equal(lam20, { (dPointWithInterface as SomePointInterfaceWithMFVCBound).somethingRegular = 1 }) + equal(lam18, { (dPointWithInterface as SomePointInterfaceWithMFVCBound).somethingMFVC = dPoint }) + + + val dSegment = DSegment(dPoint, otherDPoint) + + equal(dPointLam, { dSegment.p1 }) + equal(otherDPointLam, { dSegment.p2 }) + equal({ 1.0 }, { dPoint.x }) + equal({ 1.0 }, { dSegment.p1.x }) + equal({ 3.0 }, { otherDPoint.x }) + equal({ 3.0 }, { dSegment.p2.x }) + equal({ 2.0 }, { dPoint.y }) + equal({ 2.0 }, { dSegment.p1.y }) + equal({ 4.0 }, { otherDPoint.y }) + equal({ 4.0 }, { dSegment.p2.y }) + equal(dPointLam, { (dSegment as AbstractSegment).p1 }) + equal(otherDPointLam, { (dSegment as AbstractSegment).p2 }) + equal({ 1.0 }, { (dSegment as AbstractSegment).p1.x }) + equal({ 3.0 }, { (dSegment as AbstractSegment).p2.x }) + equal({ 2.0 }, { (dSegment as AbstractSegment).p1.y }) + equal({ 4.0 }, { (dSegment as AbstractSegment).p2.y }) + + return "OK" +} diff --git a/compiler/testData/codegen/box/valueClasses/overrides.txt b/compiler/testData/codegen/box/valueClasses/overrides.txt new file mode 100644 index 00000000000..2cba3ebcf09 --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/overrides.txt @@ -0,0 +1,2586 @@ +@kotlin.Metadata +public interface AbstractPoint { + // source: 'overrides.kt' + public abstract method getX(): java.lang.Object + public abstract method getY(): java.lang.Object +} + +@kotlin.Metadata +public interface AbstractSegment { + // source: 'overrides.kt' + public abstract method getP1(): java.lang.Object + public abstract method getP2(): java.lang.Object +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class DPoint { + // source: 'overrides.kt' + private final field field-0: double + private final field field-1: double + private synthetic method (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 @org.jetbrains.annotations.NotNull method getX(): java.lang.Double + public synthetic bridge method getX(): java.lang.Object + public @org.jetbrains.annotations.NotNull method getY(): java.lang.Double + public synthetic bridge method getY(): java.lang.Object + 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-0(): double + public synthetic final method unbox-impl-1(): double +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class DPointWithInterface { + // source: 'overrides.kt' + private final field field-0: double + private final field field-1: double + private synthetic method (p0: double, p1: double): void + public synthetic final static method box-impl(p0: double, p1: double): DPointWithInterface + 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 @org.jetbrains.annotations.NotNull method getSomethingGeneric(): DPoint + public synthetic bridge method getSomethingGeneric(): java.lang.Object + public static @org.jetbrains.annotations.NotNull method getSomethingGeneric-impl(p0: double, p1: double): DPoint + public @org.jetbrains.annotations.NotNull method getSomethingMFVC(): DPoint + public static @org.jetbrains.annotations.NotNull method getSomethingMFVC-impl(p0: double, p1: double): DPoint + public method getSomethingRegular(): int + public static method getSomethingRegular-impl(p0: double, p1: double): int + 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 static method setSomethingGeneric-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void + public method setSomethingMFVC-sUp7gFk(p0: double, p1: double): void + public static method setSomethingMFVC-sUp7gFk(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 + public static method toString-impl(p0: double, p1: double): java.lang.String + public synthetic final method unbox-impl-0(): double + public synthetic final method unbox-impl-1(): double +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class DSegment { + // source: 'overrides.kt' + private final field field-0-0: double + private final field field-0-1: double + private final field field-1-0: double + private final field field-1-1: double + private synthetic method (p0: double, p1: double, p2: double, p3: double): void + public synthetic final static method box-impl(p0: double, p1: double, p2: double, p3: double): DSegment + public final static method constructor-impl(p0: double, p1: double, p2: double, p3: double): void + 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: java.lang.Object): boolean + public final static method equals-impl0(p0: double, p1: double, p2: double, p3: double, p4: double, p5: double, p6: double, p7: double): boolean + public @org.jetbrains.annotations.NotNull method getP1(): DPoint + public synthetic bridge method getP1(): java.lang.Object + public @org.jetbrains.annotations.NotNull method getP2(): DPoint + public synthetic bridge method getP2(): java.lang.Object + public method hashCode(): int + public static method hashCode-impl(p0: double, p1: double, p2: double, p3: double): int + public @org.jetbrains.annotations.NotNull method toString(): java.lang.String + public static method toString-impl(p0: double, p1: double, p2: double, p3: double): java.lang.String + public synthetic final method unbox-impl-0(): DPoint + public synthetic final method unbox-impl-0-0(): double + public synthetic final method unbox-impl-0-1(): double + public synthetic final method unbox-impl-1(): DPoint + public synthetic final method unbox-impl-1-0(): double + public synthetic final method unbox-impl-1-1(): double +} + +@kotlin.Metadata +public final class DataClassException { + // source: 'overrides.kt' + private final @org.jetbrains.annotations.Nullable field value: java.lang.Object + public method (@org.jetbrains.annotations.Nullable p0: java.lang.Object): void + public final @org.jetbrains.annotations.Nullable method component1(): java.lang.Object + public synthetic static method copy$default(p0: DataClassException, p1: java.lang.Object, p2: int, p3: java.lang.Object): DataClassException + public final @org.jetbrains.annotations.NotNull method copy(@org.jetbrains.annotations.Nullable p0: java.lang.Object): DataClassException + public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean + public final @org.jetbrains.annotations.Nullable method getValue(): java.lang.Object + public method hashCode(): int + public @org.jetbrains.annotations.NotNull method toString(): java.lang.String +} + +@kotlin.Metadata +public final class GenericFakeOverride { + // source: 'overrides.kt' + public method (): void + public @org.jetbrains.annotations.NotNull method getP(): DPoint + public synthetic bridge method getP(): java.lang.Object + public @org.jetbrains.annotations.NotNull method getP1(): DPoint + public synthetic bridge method getP1(): java.lang.Object + public method setP(@org.jetbrains.annotations.NotNull p0: DPoint): void + public synthetic bridge method setP(p0: java.lang.Object): void + public method setP1(@org.jetbrains.annotations.NotNull p0: DPoint): void + public synthetic bridge method setP1(p0: java.lang.Object): void + public final inner class GenericMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class GenericFakeOverrideMFVC { + // source: 'overrides.kt' + private final field field-0: double + private final field field-1: double + private synthetic method (p0: double, p1: double): void + public synthetic final static method box-impl(p0: double, p1: double): GenericFakeOverrideMFVC + 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 @org.jetbrains.annotations.NotNull method getP(): DPoint + public synthetic bridge method getP(): java.lang.Object + public static @org.jetbrains.annotations.NotNull method getP-impl(p0: double, p1: double): DPoint + public @org.jetbrains.annotations.NotNull method getP1(): DPoint + public synthetic bridge method getP1(): java.lang.Object + 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 synthetic bridge method setP(p0: java.lang.Object): void + public method setP-sUp7gFk(@org.jetbrains.annotations.NotNull p0: DPoint): void + public static method setP-sUp7gFk(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 static method setP1-sUp7gFk(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-0(): double + public synthetic final method unbox-impl-1(): double + public final inner class GenericMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class GenericFakeOverrideMFVCWithMFVCUpperBound { + // source: 'overrides.kt' + private final field field-0: double + private final field field-1: double + private synthetic method (p0: double, p1: double): void + public synthetic final static method box-impl(p0: double, p1: double): GenericFakeOverrideMFVCWithMFVCUpperBound + 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 @org.jetbrains.annotations.NotNull method getP(): DPoint + public static @org.jetbrains.annotations.NotNull method getP-impl(p0: double, p1: double): DPoint + public @org.jetbrains.annotations.NotNull method getP1(): DPoint + 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 static method setP-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void + public method setP1-sUp7gFk(p0: double, p1: double): void + public static method setP1-sUp7gFk(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-0(): double + public synthetic final method unbox-impl-1(): double + public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls +} + +@kotlin.Metadata +public final class GenericFakeOverrideWithMFVCUpperBound { + // source: 'overrides.kt' + public method (): 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 setP1-sUp7gFk(p0: double, p1: double): void + public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface GenericMFVCHolder { + // source: 'overrides.kt' + public abstract method getP(): java.lang.Object + public abstract method getP1(): java.lang.Object + public abstract method setP(p0: java.lang.Object): void + public abstract method setP1(p0: java.lang.Object): void +} + +@kotlin.Metadata +public final class GenericMFVCHolderWithImpls$DefaultImpls { + // source: 'overrides.kt' + public static method getP(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithImpls): java.lang.Object + public static method getP1(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithImpls): java.lang.Object + public static method setP(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithImpls, p1: java.lang.Object): void + public static method setP1(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithImpls, p1: java.lang.Object): void + public final inner class GenericMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface GenericMFVCHolderWithImpls { + // source: 'overrides.kt' + public abstract method getP(): java.lang.Object + public abstract method getP1(): java.lang.Object + public abstract method setP(p0: java.lang.Object): void + public abstract method setP1(p0: java.lang.Object): void + public final inner class GenericMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface GenericMFVCHolderWithMFVCUpperBound { + // source: 'overrides.kt' + public abstract @org.jetbrains.annotations.NotNull method getP(): DPoint + public synthetic abstract method getP-0(): double + public synthetic abstract method getP-1(): double + public abstract @org.jetbrains.annotations.NotNull method getP1(): DPoint + public synthetic abstract method getP1-0(): double + public synthetic abstract method getP1-1(): double + public abstract method setP-sUp7gFk(p0: double, p1: double): void + public abstract method setP1-sUp7gFk(p0: double, p1: double): void +} + +@kotlin.Metadata +public final class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls { + // source: 'overrides.kt' + public static @org.jetbrains.annotations.NotNull method getP(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): DPoint + public synthetic static method getP-0(p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): double + public synthetic static method getP-1(p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): double + public static @org.jetbrains.annotations.NotNull method getP1(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): DPoint + public synthetic static method getP1-0(p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): double + public synthetic static method getP1-1(p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): double + public static method setP-sUp7gFk(@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 final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface GenericMFVCHolderWithMFVCUpperBoundWithImpls { + // source: 'overrides.kt' + public abstract @org.jetbrains.annotations.NotNull method getP(): DPoint + public synthetic abstract method getP-0(): double + public synthetic abstract method getP-1(): double + public abstract @org.jetbrains.annotations.NotNull method getP1(): DPoint + public synthetic abstract method getP1-0(): double + public synthetic abstract method getP1-1(): double + public abstract method setP-sUp7gFk(p0: double, p1: double): void + public abstract method setP1-sUp7gFk(p0: double, p1: double): void + public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls +} + +@kotlin.Metadata +final class OverridesKt$box$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$1 + inner (anonymous) class OverridesKt$box$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.String +} + +@kotlin.Metadata +final class OverridesKt$box$10 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$10 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$100 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class OverridesKt$box$100 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$101 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class OverridesKt$box$101 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$102 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class OverridesKt$box$102 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$103 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class OverridesKt$box$103 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$104 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class OverridesKt$box$104 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$105 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class OverridesKt$box$105 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$106 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class OverridesKt$box$106 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$107 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class OverridesKt$box$107 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$108 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class OverridesKt$box$108 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$109 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class OverridesKt$box$109 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$11 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$11 + inner (anonymous) class OverridesKt$box$11 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$110 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class OverridesKt$box$110 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$111 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class OverridesKt$box$111 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$112 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class OverridesKt$box$112 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$113 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class OverridesKt$box$113 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$114 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-0-0: double + synthetic final field $dSegment-field-0-1: double + inner (anonymous) class OverridesKt$box$114 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$115 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-1-0: double + synthetic final field $dSegment-field-1-1: double + inner (anonymous) class OverridesKt$box$115 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$116 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$116 + inner (anonymous) class OverridesKt$box$116 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$117 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + inner (anonymous) class OverridesKt$box$117 + method (p0: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$118 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$118 + inner (anonymous) class OverridesKt$box$118 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$119 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-0-0: double + inner (anonymous) class OverridesKt$box$119 + method (p0: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$12 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$12 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$120 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$120 + inner (anonymous) class OverridesKt$box$120 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$121 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $otherDPoint-field-0: double + inner (anonymous) class OverridesKt$box$121 + method (p0: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$122 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$122 + inner (anonymous) class OverridesKt$box$122 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$123 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-1-0: double + inner (anonymous) class OverridesKt$box$123 + method (p0: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$124 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$124 + inner (anonymous) class OverridesKt$box$124 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$125 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$125 + method (p0: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$126 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$126 + inner (anonymous) class OverridesKt$box$126 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$127 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-0-1: double + inner (anonymous) class OverridesKt$box$127 + method (p0: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$128 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$128 + inner (anonymous) class OverridesKt$box$128 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$129 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $otherDPoint-field-1: double + inner (anonymous) class OverridesKt$box$129 + method (p0: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$13 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$13 + inner (anonymous) class OverridesKt$box$13 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$130 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$130 + inner (anonymous) class OverridesKt$box$130 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$131 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-1-1: double + inner (anonymous) class OverridesKt$box$131 + method (p0: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$132 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-0-0: double + synthetic final field $dSegment-field-0-1: double + synthetic final field $dSegment-field-1-0: double + synthetic final field $dSegment-field-1-1: double + inner (anonymous) class OverridesKt$box$132 + method (p0: double, p1: double, p2: double, p3: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$133 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-0-0: double + synthetic final field $dSegment-field-0-1: double + synthetic final field $dSegment-field-1-0: double + synthetic final field $dSegment-field-1-1: double + inner (anonymous) class OverridesKt$box$133 + method (p0: double, p1: double, p2: double, p3: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$134 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$134 + inner (anonymous) class OverridesKt$box$134 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$135 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-0-0: double + synthetic final field $dSegment-field-0-1: double + synthetic final field $dSegment-field-1-0: double + synthetic final field $dSegment-field-1-1: double + inner (anonymous) class OverridesKt$box$135 + method (p0: double, p1: double, p2: double, p3: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$136 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$136 + inner (anonymous) class OverridesKt$box$136 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$137 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-0-0: double + synthetic final field $dSegment-field-0-1: double + synthetic final field $dSegment-field-1-0: double + synthetic final field $dSegment-field-1-1: double + inner (anonymous) class OverridesKt$box$137 + method (p0: double, p1: double, p2: double, p3: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$138 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$138 + inner (anonymous) class OverridesKt$box$138 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$139 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-0-0: double + synthetic final field $dSegment-field-0-1: double + synthetic final field $dSegment-field-1-0: double + synthetic final field $dSegment-field-1-1: double + inner (anonymous) class OverridesKt$box$139 + method (p0: double, p1: double, p2: double, p3: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$14 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $otherDPoint-field-0: double + synthetic final field $otherDPoint-field-1: double + inner (anonymous) class OverridesKt$box$14 + method (p0: double, p1: double, p2: double, p3: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$140 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$140 + inner (anonymous) class OverridesKt$box$140 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$141 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-0-0: double + synthetic final field $dSegment-field-0-1: double + synthetic final field $dSegment-field-1-0: double + synthetic final field $dSegment-field-1-1: double + inner (anonymous) class OverridesKt$box$141 + method (p0: double, p1: double, p2: double, p3: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$15 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$15 + inner (anonymous) class OverridesKt$box$15 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$16 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $otherDPoint-field-0: double + synthetic final field $otherDPoint-field-1: double + inner (anonymous) class OverridesKt$box$16 + method (p0: double, p1: double, p2: double, p3: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$17 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$17 + inner (anonymous) class OverridesKt$box$17 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$18 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $otherDPoint-field-0: double + synthetic final field $otherDPoint-field-1: double + inner (anonymous) class OverridesKt$box$18 + method (p0: double, p1: double, p2: double, p3: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$19 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$19 + inner (anonymous) class OverridesKt$box$19 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$2 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$2 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.String +} + +@kotlin.Metadata +final class OverridesKt$box$20 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $otherDPoint-field-0: double + synthetic final field $otherDPoint-field-1: double + inner (anonymous) class OverridesKt$box$20 + method (p0: double, p1: double, p2: double, p3: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$21 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$21 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$22 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$22 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$23 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$23 + inner (anonymous) class OverridesKt$box$23 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$24 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + inner (anonymous) class OverridesKt$box$24 + method (p0: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$25 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$25 + inner (anonymous) class OverridesKt$box$25 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$26 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$26 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$27 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$27 + inner (anonymous) class OverridesKt$box$27 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$28 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$28 + method (p0: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$29 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$29 + inner (anonymous) class OverridesKt$box$29 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$3 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$3 + inner (anonymous) class OverridesKt$box$3 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.String +} + +@kotlin.Metadata +final class OverridesKt$box$30 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$30 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$31 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class OverridesKt$box$31 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$32 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class OverridesKt$box$32 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$33 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class OverridesKt$box$33 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$34 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class OverridesKt$box$34 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$35 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class OverridesKt$box$35 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$36 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class OverridesKt$box$36 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$37 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class OverridesKt$box$37 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$38 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class OverridesKt$box$38 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$39 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class OverridesKt$box$39 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$4 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$4 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.String +} + +@kotlin.Metadata +final class OverridesKt$box$40 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $realOverride: RealOverride + inner (anonymous) class OverridesKt$box$40 + method (p0: RealOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$41 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $realOverride: RealOverride + inner (anonymous) class OverridesKt$box$41 + method (p0: RealOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$42 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $realOverride: RealOverride + inner (anonymous) class OverridesKt$box$42 + method (p0: RealOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$43 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $realOverride: RealOverride + inner (anonymous) class OverridesKt$box$43 + method (p0: RealOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$44 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $realOverride: RealOverride + inner (anonymous) class OverridesKt$box$44 + method (p0: RealOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$45 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $realOverride: RealOverride + inner (anonymous) class OverridesKt$box$45 + method (p0: RealOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$46 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $realOverride: RealOverride + inner (anonymous) class OverridesKt$box$46 + method (p0: RealOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$47 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $realOverride: RealOverride + inner (anonymous) class OverridesKt$box$47 + method (p0: RealOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$48 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class OverridesKt$box$48 + method (p0: GenericFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$49 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class OverridesKt$box$49 + method (p0: GenericFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$5 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$5 + inner (anonymous) class OverridesKt$box$5 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$50 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class OverridesKt$box$50 + method (p0: GenericFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$51 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class OverridesKt$box$51 + method (p0: GenericFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$52 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class OverridesKt$box$52 + method (p0: ReifiedFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$53 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class OverridesKt$box$53 + method (p0: ReifiedFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$54 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class OverridesKt$box$54 + method (p0: ReifiedFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$55 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class OverridesKt$box$55 + method (p0: ReifiedFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$56 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class OverridesKt$box$56 + method (p0: GenericFakeOverrideWithMFVCUpperBound): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$57 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class OverridesKt$box$57 + method (p0: GenericFakeOverrideWithMFVCUpperBound): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$58 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class OverridesKt$box$58 + method (p0: GenericFakeOverrideWithMFVCUpperBound): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$59 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class OverridesKt$box$59 + method (p0: GenericFakeOverrideWithMFVCUpperBound): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$6 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$6 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$60 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class OverridesKt$box$60 + method (p0: GenericFakeOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$61 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class OverridesKt$box$61 + method (p0: GenericFakeOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$62 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class OverridesKt$box$62 + method (p0: GenericFakeOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$63 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class OverridesKt$box$63 + method (p0: GenericFakeOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$64 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class OverridesKt$box$64 + method (p0: ReifiedFakeOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$65 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class OverridesKt$box$65 + method (p0: ReifiedFakeOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$66 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class OverridesKt$box$66 + method (p0: ReifiedFakeOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$67 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class OverridesKt$box$67 + method (p0: ReifiedFakeOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$68 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class OverridesKt$box$68 + method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$69 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class OverridesKt$box$69 + method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$7 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$7 + inner (anonymous) class OverridesKt$box$7 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$70 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class OverridesKt$box$70 + method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$71 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class OverridesKt$box$71 + method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$72 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVC-field-0: double + synthetic final field $genericFakeOverrideMFVC-field-1: double + inner (anonymous) class OverridesKt$box$72 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$73 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVC-field-0: double + synthetic final field $genericFakeOverrideMFVC-field-1: double + inner (anonymous) class OverridesKt$box$73 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$74 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVC-field-0: double + synthetic final field $genericFakeOverrideMFVC-field-1: double + inner (anonymous) class OverridesKt$box$74 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$75 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVC-field-0: double + synthetic final field $genericFakeOverrideMFVC-field-1: double + inner (anonymous) class OverridesKt$box$75 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$76 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverrideMFVC-field-0: double + synthetic final field $reifiedFakeOverrideMFVC-field-1: double + inner (anonymous) class OverridesKt$box$76 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$77 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverrideMFVC-field-0: double + synthetic final field $reifiedFakeOverrideMFVC-field-1: double + inner (anonymous) class OverridesKt$box$77 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$78 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverrideMFVC-field-0: double + synthetic final field $reifiedFakeOverrideMFVC-field-1: double + inner (anonymous) class OverridesKt$box$78 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$79 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverrideMFVC-field-0: double + synthetic final field $reifiedFakeOverrideMFVC-field-1: double + inner (anonymous) class OverridesKt$box$79 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$8 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$8 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$80 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: double + inner (anonymous) class OverridesKt$box$80 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$81 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: double + inner (anonymous) class OverridesKt$box$81 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$82 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: double + inner (anonymous) class OverridesKt$box$82 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$83 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: double + inner (anonymous) class OverridesKt$box$83 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$84 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideMFVC-field-0: double + synthetic final field $genericFakeOverrideMFVC-field-1: double + inner (anonymous) class OverridesKt$box$84 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$85 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideMFVC-field-0: double + synthetic final field $genericFakeOverrideMFVC-field-1: double + inner (anonymous) class OverridesKt$box$85 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$86 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideMFVC-field-0: double + synthetic final field $genericFakeOverrideMFVC-field-1: double + inner (anonymous) class OverridesKt$box$86 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$87 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideMFVC-field-0: double + synthetic final field $genericFakeOverrideMFVC-field-1: double + inner (anonymous) class OverridesKt$box$87 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$88 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $reifiedFakeOverrideMFVC-field-0: double + synthetic final field $reifiedFakeOverrideMFVC-field-1: double + inner (anonymous) class OverridesKt$box$88 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$89 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $reifiedFakeOverrideMFVC-field-0: double + synthetic final field $reifiedFakeOverrideMFVC-field-1: double + inner (anonymous) class OverridesKt$box$89 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$9 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$9 + inner (anonymous) class OverridesKt$box$9 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$90 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $reifiedFakeOverrideMFVC-field-0: double + synthetic final field $reifiedFakeOverrideMFVC-field-1: double + inner (anonymous) class OverridesKt$box$90 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$91 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $reifiedFakeOverrideMFVC-field-0: double + synthetic final field $reifiedFakeOverrideMFVC-field-1: double + inner (anonymous) class OverridesKt$box$91 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$92 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: double + inner (anonymous) class OverridesKt$box$92 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$93 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: double + inner (anonymous) class OverridesKt$box$93 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$94 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: double + inner (anonymous) class OverridesKt$box$94 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$95 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: double + inner (anonymous) class OverridesKt$box$95 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$96 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class OverridesKt$box$96 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$97 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class OverridesKt$box$97 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$98 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class OverridesKt$box$98 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$99 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class OverridesKt$box$99 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$dPointLam$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$dPointLam$1 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class OverridesKt$box$emptyLam$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$emptyLam$1 + inner (anonymous) class OverridesKt$box$emptyLam$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$lam1$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$lam1$1 + inner (anonymous) class OverridesKt$box$lam1$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class OverridesKt$box$lam10$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$lam10$1 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$lam11$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$lam11$1 + inner (anonymous) class OverridesKt$box$lam11$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class OverridesKt$box$lam12$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$lam12$1 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$lam13$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$lam13$1 + inner (anonymous) class OverridesKt$box$lam13$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class OverridesKt$box$lam14$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$lam14$1 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$lam15$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$lam15$1 + inner (anonymous) class OverridesKt$box$lam15$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class OverridesKt$box$lam16$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$lam16$1 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$lam17$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$lam17$1 + inner (anonymous) class OverridesKt$box$lam17$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class OverridesKt$box$lam18$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$lam18$1 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$lam19$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$lam19$1 + inner (anonymous) class OverridesKt$box$lam19$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class OverridesKt$box$lam2$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$lam2$1 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$lam20$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$lam20$1 + inner (anonymous) class OverridesKt$box$lam20$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$lam3$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$lam3$1 + inner (anonymous) class OverridesKt$box$lam3$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class OverridesKt$box$lam4$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$lam4$1 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$lam5$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$lam5$1 + inner (anonymous) class OverridesKt$box$lam5$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class OverridesKt$box$lam6$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$lam6$1 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$lam7$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$lam7$1 + inner (anonymous) class OverridesKt$box$lam7$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class OverridesKt$box$lam8$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class OverridesKt$box$lam8$1 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class OverridesKt$box$lam9$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + public final static field INSTANCE: OverridesKt$box$lam9$1 + inner (anonymous) class OverridesKt$box$lam9$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class OverridesKt$box$otherDPointLam$1 { + // source: 'overrides.kt' + enclosing method OverridesKt.box()Ljava/lang/String; + synthetic final field $otherDPoint-field-0: double + synthetic final field $otherDPoint-field-1: double + inner (anonymous) class OverridesKt$box$otherDPointLam$1 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +public final class OverridesKt { + // source: 'overrides.kt' + inner (anonymous) class OverridesKt$box$1 + inner (anonymous) class OverridesKt$box$10 + inner (anonymous) class OverridesKt$box$100 + inner (anonymous) class OverridesKt$box$101 + inner (anonymous) class OverridesKt$box$102 + inner (anonymous) class OverridesKt$box$103 + inner (anonymous) class OverridesKt$box$104 + inner (anonymous) class OverridesKt$box$105 + inner (anonymous) class OverridesKt$box$106 + inner (anonymous) class OverridesKt$box$107 + inner (anonymous) class OverridesKt$box$108 + inner (anonymous) class OverridesKt$box$109 + inner (anonymous) class OverridesKt$box$11 + inner (anonymous) class OverridesKt$box$110 + inner (anonymous) class OverridesKt$box$111 + inner (anonymous) class OverridesKt$box$112 + inner (anonymous) class OverridesKt$box$113 + inner (anonymous) class OverridesKt$box$114 + inner (anonymous) class OverridesKt$box$115 + inner (anonymous) class OverridesKt$box$116 + inner (anonymous) class OverridesKt$box$117 + inner (anonymous) class OverridesKt$box$118 + inner (anonymous) class OverridesKt$box$119 + inner (anonymous) class OverridesKt$box$12 + inner (anonymous) class OverridesKt$box$120 + inner (anonymous) class OverridesKt$box$121 + inner (anonymous) class OverridesKt$box$122 + inner (anonymous) class OverridesKt$box$123 + inner (anonymous) class OverridesKt$box$124 + inner (anonymous) class OverridesKt$box$125 + inner (anonymous) class OverridesKt$box$126 + inner (anonymous) class OverridesKt$box$127 + inner (anonymous) class OverridesKt$box$128 + inner (anonymous) class OverridesKt$box$129 + inner (anonymous) class OverridesKt$box$13 + inner (anonymous) class OverridesKt$box$130 + inner (anonymous) class OverridesKt$box$131 + inner (anonymous) class OverridesKt$box$132 + inner (anonymous) class OverridesKt$box$133 + inner (anonymous) class OverridesKt$box$134 + inner (anonymous) class OverridesKt$box$135 + inner (anonymous) class OverridesKt$box$136 + inner (anonymous) class OverridesKt$box$137 + inner (anonymous) class OverridesKt$box$138 + inner (anonymous) class OverridesKt$box$139 + inner (anonymous) class OverridesKt$box$14 + inner (anonymous) class OverridesKt$box$140 + inner (anonymous) class OverridesKt$box$141 + inner (anonymous) class OverridesKt$box$15 + inner (anonymous) class OverridesKt$box$16 + inner (anonymous) class OverridesKt$box$17 + inner (anonymous) class OverridesKt$box$18 + inner (anonymous) class OverridesKt$box$19 + inner (anonymous) class OverridesKt$box$2 + inner (anonymous) class OverridesKt$box$20 + inner (anonymous) class OverridesKt$box$21 + inner (anonymous) class OverridesKt$box$22 + inner (anonymous) class OverridesKt$box$23 + inner (anonymous) class OverridesKt$box$24 + inner (anonymous) class OverridesKt$box$25 + inner (anonymous) class OverridesKt$box$26 + inner (anonymous) class OverridesKt$box$27 + inner (anonymous) class OverridesKt$box$28 + inner (anonymous) class OverridesKt$box$29 + inner (anonymous) class OverridesKt$box$3 + inner (anonymous) class OverridesKt$box$30 + inner (anonymous) class OverridesKt$box$31 + inner (anonymous) class OverridesKt$box$32 + inner (anonymous) class OverridesKt$box$33 + inner (anonymous) class OverridesKt$box$34 + inner (anonymous) class OverridesKt$box$35 + inner (anonymous) class OverridesKt$box$36 + inner (anonymous) class OverridesKt$box$37 + inner (anonymous) class OverridesKt$box$38 + inner (anonymous) class OverridesKt$box$39 + inner (anonymous) class OverridesKt$box$4 + inner (anonymous) class OverridesKt$box$40 + inner (anonymous) class OverridesKt$box$41 + inner (anonymous) class OverridesKt$box$42 + inner (anonymous) class OverridesKt$box$43 + inner (anonymous) class OverridesKt$box$44 + inner (anonymous) class OverridesKt$box$45 + inner (anonymous) class OverridesKt$box$46 + inner (anonymous) class OverridesKt$box$47 + inner (anonymous) class OverridesKt$box$48 + inner (anonymous) class OverridesKt$box$49 + inner (anonymous) class OverridesKt$box$5 + inner (anonymous) class OverridesKt$box$50 + inner (anonymous) class OverridesKt$box$51 + inner (anonymous) class OverridesKt$box$52 + inner (anonymous) class OverridesKt$box$53 + inner (anonymous) class OverridesKt$box$54 + inner (anonymous) class OverridesKt$box$55 + inner (anonymous) class OverridesKt$box$56 + inner (anonymous) class OverridesKt$box$57 + inner (anonymous) class OverridesKt$box$58 + inner (anonymous) class OverridesKt$box$59 + inner (anonymous) class OverridesKt$box$6 + inner (anonymous) class OverridesKt$box$60 + inner (anonymous) class OverridesKt$box$61 + inner (anonymous) class OverridesKt$box$62 + inner (anonymous) class OverridesKt$box$63 + inner (anonymous) class OverridesKt$box$64 + inner (anonymous) class OverridesKt$box$65 + inner (anonymous) class OverridesKt$box$66 + inner (anonymous) class OverridesKt$box$67 + inner (anonymous) class OverridesKt$box$68 + inner (anonymous) class OverridesKt$box$69 + inner (anonymous) class OverridesKt$box$7 + inner (anonymous) class OverridesKt$box$70 + inner (anonymous) class OverridesKt$box$71 + inner (anonymous) class OverridesKt$box$72 + inner (anonymous) class OverridesKt$box$73 + inner (anonymous) class OverridesKt$box$74 + inner (anonymous) class OverridesKt$box$75 + inner (anonymous) class OverridesKt$box$76 + inner (anonymous) class OverridesKt$box$77 + inner (anonymous) class OverridesKt$box$78 + inner (anonymous) class OverridesKt$box$79 + inner (anonymous) class OverridesKt$box$8 + inner (anonymous) class OverridesKt$box$80 + inner (anonymous) class OverridesKt$box$81 + inner (anonymous) class OverridesKt$box$82 + inner (anonymous) class OverridesKt$box$83 + inner (anonymous) class OverridesKt$box$84 + inner (anonymous) class OverridesKt$box$85 + inner (anonymous) class OverridesKt$box$86 + inner (anonymous) class OverridesKt$box$87 + inner (anonymous) class OverridesKt$box$88 + inner (anonymous) class OverridesKt$box$89 + inner (anonymous) class OverridesKt$box$9 + inner (anonymous) class OverridesKt$box$90 + inner (anonymous) class OverridesKt$box$91 + inner (anonymous) class OverridesKt$box$92 + inner (anonymous) class OverridesKt$box$93 + inner (anonymous) class OverridesKt$box$94 + inner (anonymous) class OverridesKt$box$95 + inner (anonymous) class OverridesKt$box$96 + inner (anonymous) class OverridesKt$box$97 + inner (anonymous) class OverridesKt$box$98 + inner (anonymous) class OverridesKt$box$99 + inner (anonymous) class OverridesKt$box$dPointLam$1 + inner (anonymous) class OverridesKt$box$emptyLam$1 + inner (anonymous) class OverridesKt$box$lam1$1 + inner (anonymous) class OverridesKt$box$lam10$1 + inner (anonymous) class OverridesKt$box$lam11$1 + inner (anonymous) class OverridesKt$box$lam12$1 + inner (anonymous) class OverridesKt$box$lam13$1 + inner (anonymous) class OverridesKt$box$lam14$1 + inner (anonymous) class OverridesKt$box$lam15$1 + inner (anonymous) class OverridesKt$box$lam16$1 + inner (anonymous) class OverridesKt$box$lam17$1 + inner (anonymous) class OverridesKt$box$lam18$1 + inner (anonymous) class OverridesKt$box$lam19$1 + inner (anonymous) class OverridesKt$box$lam2$1 + inner (anonymous) class OverridesKt$box$lam20$1 + inner (anonymous) class OverridesKt$box$lam3$1 + inner (anonymous) class OverridesKt$box$lam4$1 + inner (anonymous) class OverridesKt$box$lam5$1 + inner (anonymous) class OverridesKt$box$lam6$1 + inner (anonymous) class OverridesKt$box$lam7$1 + inner (anonymous) class OverridesKt$box$lam8$1 + inner (anonymous) class OverridesKt$box$lam9$1 + inner (anonymous) class OverridesKt$box$otherDPointLam$1 + 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 +} + +@kotlin.Metadata +public final class RealOverride { + // source: 'overrides.kt' + private field p-0: double + private field p-1: double + public method (p0: double, p1: double): void + public @org.jetbrains.annotations.NotNull method getP(): DPoint + public synthetic bridge method getP(): java.lang.Object + public synthetic method getP-0(): double + public synthetic method getP-1(): double + public @org.jetbrains.annotations.NotNull method getP1(): DPoint + public synthetic bridge method getP1(): java.lang.Object + public synthetic method getP1-0(): double + public synthetic method getP1-1(): double + public synthetic bridge method setP(p0: java.lang.Object): void + public method setP-sUp7gFk(p0: double, p1: double): void + public synthetic bridge method setP1(p0: java.lang.Object): void + public method setP1-sUp7gFk(p0: double, p1: double): void +} + +@kotlin.Metadata +public final class ReifiedFakeOverride { + // source: 'overrides.kt' + public method (): 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 setP1-sUp7gFk(p0: double, p1: double): void + public final inner class ReifiedMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class ReifiedFakeOverrideMFVC { + // source: 'overrides.kt' + private final field field-0: double + private final field field-1: double + private synthetic method (p0: double, p1: double): void + public synthetic final static method box-impl(p0: double, p1: double): ReifiedFakeOverrideMFVC + 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 @org.jetbrains.annotations.NotNull method getP(): DPoint + public static @org.jetbrains.annotations.NotNull method getP-impl(p0: double, p1: double): DPoint + public @org.jetbrains.annotations.NotNull method getP1(): DPoint + 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 static method setP-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void + public method setP1-sUp7gFk(p0: double, p1: double): void + public static method setP1-sUp7gFk(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-0(): double + public synthetic final method unbox-impl-1(): double + public final inner class ReifiedMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface ReifiedMFVCHolder { + // source: 'overrides.kt' + public abstract @org.jetbrains.annotations.NotNull method getP(): DPoint + public synthetic abstract method getP-0(): double + public synthetic abstract method getP-1(): double + public abstract @org.jetbrains.annotations.NotNull method getP1(): DPoint + public synthetic abstract method getP1-0(): double + public synthetic abstract method getP1-1(): double + public abstract method setP-sUp7gFk(p0: double, p1: double): void + public abstract method setP1-sUp7gFk(p0: double, p1: double): void +} + +@kotlin.Metadata +public final class ReifiedMFVCHolderWithImpls$DefaultImpls { + // source: 'overrides.kt' + public static @org.jetbrains.annotations.NotNull method getP(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls): DPoint + public synthetic static method getP-0(p0: ReifiedMFVCHolderWithImpls): double + public synthetic static method getP-1(p0: ReifiedMFVCHolderWithImpls): double + public static @org.jetbrains.annotations.NotNull method getP1(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls): DPoint + public synthetic static method getP1-0(p0: ReifiedMFVCHolderWithImpls): double + public synthetic static method getP1-1(p0: ReifiedMFVCHolderWithImpls): double + public static method setP-sUp7gFk(@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 final inner class ReifiedMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface ReifiedMFVCHolderWithImpls { + // source: 'overrides.kt' + public abstract @org.jetbrains.annotations.NotNull method getP(): DPoint + public synthetic abstract method getP-0(): double + public synthetic abstract method getP-1(): double + public abstract @org.jetbrains.annotations.NotNull method getP1(): DPoint + public synthetic abstract method getP1-0(): double + public synthetic abstract method getP1-1(): double + public abstract method setP-sUp7gFk(p0: double, p1: double): void + public abstract method setP1-sUp7gFk(p0: double, p1: double): void + public final inner class ReifiedMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface SomePointInterface { + // source: 'overrides.kt' + public abstract method getSomethingGeneric(): java.lang.Object + public abstract @org.jetbrains.annotations.NotNull method getSomethingMFVC(): DPoint + public synthetic abstract method getSomethingMFVC-0(): double + public synthetic abstract method getSomethingMFVC-1(): 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 setSomethingRegular(p0: int): void +} + +@kotlin.Metadata +public interface SomePointInterfaceWithMFVCBound { + // source: 'overrides.kt' + public abstract @org.jetbrains.annotations.NotNull method getSomethingGeneric(): DPoint + public synthetic abstract method getSomethingGeneric-0(): double + public synthetic abstract method getSomethingGeneric-1(): double + public abstract @org.jetbrains.annotations.NotNull method getSomethingMFVC(): DPoint + public synthetic abstract method getSomethingMFVC-0(): double + public synthetic abstract method getSomethingMFVC-1(): double + public abstract method getSomethingRegular(): int + public abstract method setSomethingGeneric-sUp7gFk(p0: double, p1: double): void + public abstract method setSomethingMFVC-sUp7gFk(p0: double, p1: double): void + public abstract method setSomethingRegular(p0: int): void +} diff --git a/compiler/testData/codegen/box/valueClasses/overrides_inlineClass.kt b/compiler/testData/codegen/box/valueClasses/overrides_inlineClass.kt new file mode 100644 index 00000000000..90c73961f86 --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/overrides_inlineClass.kt @@ -0,0 +1,317 @@ +// 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 { + 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 + +interface GenericMFVCHolder { + var p: T + var p1: T +} + +interface GenericMFVCHolderWithMFVCUpperBound { + var p: T + var p1: T +} + +interface ReifiedMFVCHolder { + var p: DPoint + var p1: DPoint +} + +data class DataClassException(val value: Any?): Exception() + +interface GenericMFVCHolderWithImpls { + 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 { + 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, ReifiedMFVCHolder, GenericMFVCHolderWithMFVCUpperBound { + override var p1: DPoint + get() = throw DataClassException(13) + set(value) = throw DataClassException(14 to value) +} + +class GenericFakeOverride : GenericMFVCHolderWithImpls +class ReifiedFakeOverride : ReifiedMFVCHolderWithImpls +class GenericFakeOverrideWithMFVCUpperBound : GenericMFVCHolderWithMFVCUpperBoundWithImpls + + +@JvmInline +value class GenericFakeOverrideMFVC(val field1: MyDouble, val field2: MyDouble) : GenericMFVCHolderWithImpls +@JvmInline +value class ReifiedFakeOverrideMFVC(val field1: MyDouble, val field2: MyDouble) : ReifiedMFVCHolderWithImpls +@JvmInline +value class GenericFakeOverrideMFVCWithMFVCUpperBound(val field1: MyDouble, val field2: MyDouble) : GenericMFVCHolderWithMFVCUpperBoundWithImpls + + +interface SomePointInterface { + var somethingRegular: Int + + var somethingGeneric: T + + var somethingMFVC: DPoint +} + +interface SomePointInterfaceWithMFVCBound { + var somethingRegular: Int + + var somethingGeneric: T + + var somethingMFVC: DPoint +} + +@JvmInline +value class DPointWithInterface(val x: MyDouble, val y: MyDouble) : SomePointInterface, SomePointInterfaceWithMFVCBound { + 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 { + val p1: T + val p2: T +} + +@JvmInline +value class DSegment(override val p1: DPoint, override val p2: DPoint): AbstractSegment + +fun 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) + + val lam1: () -> DPoint = { throw DataClassException(1) } + val lam2: () -> Unit = { throw DataClassException(2 to dPoint) } + val lam3: () -> DPoint = { throw DataClassException(3) } + val lam4: () -> Unit = { throw DataClassException(4 to dPoint) } + val lam5: () -> DPoint = { throw DataClassException(5) } + val lam6: () -> Unit = { throw DataClassException(6 to dPoint) } + val lam7: () -> DPoint = { throw DataClassException(7) } + val lam8: () -> Unit = { throw DataClassException(8 to dPoint) } + val lam9: () -> DPoint = { throw DataClassException(9) } + val lam10: () -> Unit = { throw DataClassException(10 to dPoint) } + val lam11: () -> DPoint = { throw DataClassException(11) } + val lam12: () -> Unit = { throw DataClassException(12 to dPoint) } + val lam13: () -> DPoint = { throw DataClassException(13) } + val lam14: () -> Unit = { throw DataClassException(14 to dPoint) } + val lam15: () -> DPoint = { throw DataClassException(15) } + val lam16: () -> Unit = { throw DataClassException(16 to dPoint) } + val lam17: () -> DPoint = { throw DataClassException(17) } + val lam18: () -> Unit = { throw DataClassException(18 to dPoint) } + val lam19: () -> Int = { throw DataClassException(19) } + val lam20: () -> Unit = { throw DataClassException(20 to 1) } + val emptyLam = {} + val dPointLam = { dPoint } + val otherDPoint = DPoint(3.0.my, 4.0.my) + val otherDPointLam = { otherDPoint } + equal({ "DPoint(x=MyDouble(value=1.0), y=MyDouble(value=2.0))" }, { dPoint.toString() }) + equal({ "DPoint(x=MyDouble(value=1.0), y=MyDouble(value=2.0))" }, { (dPoint as Any).toString() }) + + equal({ true }, { dPoint.equals(dPoint) }) + equal({ true }, { dPoint.equals(dPoint as Any) }) + equal({ true }, { (dPoint as Any).equals(dPoint) }) + equal({ true }, { (dPoint as Any).equals(dPoint as Any) }) + + equal({ false }, { dPoint.equals(otherDPoint) }) + equal({ false }, { dPoint.equals(otherDPoint as Any) }) + equal({ false }, { (dPoint as Any).equals(otherDPoint) }) + equal({ false }, { (dPoint as Any).equals(otherDPoint as Any) }) + + equal({ dPoint.hashCode() }, { (dPoint as Any).hashCode() }) + + equal({ 1.0.my }, { dPoint.x }) + equal({ 1.0.my }, { (dPoint as AbstractPoint).x }) + equal({ 2.0.my }, { dPoint.y }) + equal({ 2.0.my }, { (dPoint as AbstractPoint).y }) + + + val realOverride = RealOverride(dPoint) + + equal(dPointLam, { realOverride.p }) + equal(dPointLam, { (realOverride as GenericMFVCHolder).p }) + equal(lam13, { realOverride.p1 }) + equal(lam13, { (realOverride as GenericMFVCHolder).p1 }) + equal(dPointLam, { (realOverride as ReifiedMFVCHolder).p }) + equal(lam13, { realOverride.p1 }) + equal(lam13, { (realOverride as ReifiedMFVCHolder).p1 }) + equal(dPointLam, { (realOverride as GenericMFVCHolderWithMFVCUpperBound).p }) + equal(lam13, { (realOverride as GenericMFVCHolderWithMFVCUpperBound).p1 }) + + + equal(emptyLam, { realOverride.p = dPoint }) + equal(emptyLam, { (realOverride as GenericMFVCHolder).p = dPoint }) + equal(lam14, { realOverride.p1 = dPoint }) + equal(lam14, { (realOverride as GenericMFVCHolder).p1 = dPoint }) + equal(emptyLam, { (realOverride as ReifiedMFVCHolder).p = dPoint }) + equal(lam14, { (realOverride as ReifiedMFVCHolder).p1 = dPoint }) + equal(emptyLam, { (realOverride as GenericMFVCHolderWithMFVCUpperBound).p = dPoint }) + equal(lam14, { (realOverride as GenericMFVCHolderWithMFVCUpperBound).p1 = dPoint }) + + + val genericFakeOverride = GenericFakeOverride() + + equal(lam1, { genericFakeOverride.p }) + equal(lam1, { (genericFakeOverride as GenericMFVCHolderWithImpls).p }) + equal(lam3, { genericFakeOverride.p1 }) + equal(lam3, { (genericFakeOverride as GenericMFVCHolderWithImpls).p1 }) + val reifiedFakeOverride = ReifiedFakeOverride() + equal(lam9, { reifiedFakeOverride.p }) + equal(lam9, { (reifiedFakeOverride as ReifiedMFVCHolderWithImpls).p }) + equal(lam11, { reifiedFakeOverride.p1 }) + equal(lam11, { (reifiedFakeOverride as ReifiedMFVCHolderWithImpls).p1 }) + val genericFakeOverrideWithMFVCUpperBound = GenericFakeOverrideWithMFVCUpperBound() + equal(lam5, { genericFakeOverrideWithMFVCUpperBound.p }) + equal(lam5, { (genericFakeOverrideWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls).p }) + equal(lam7, { genericFakeOverrideWithMFVCUpperBound.p1 }) + equal(lam7, { (genericFakeOverrideWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls).p1 }) + + equal(lam2, { genericFakeOverride.p = dPoint }) + equal(lam2, { (genericFakeOverride as GenericMFVCHolderWithImpls).p = dPoint }) + equal(lam4, { genericFakeOverride.p1 = dPoint }) + equal(lam4, { (genericFakeOverride as GenericMFVCHolderWithImpls).p1 = dPoint }) + equal(lam10, { reifiedFakeOverride.p = dPoint }) + equal(lam10, { (reifiedFakeOverride as ReifiedMFVCHolderWithImpls).p = dPoint }) + equal(lam12, { reifiedFakeOverride.p1 = dPoint }) + equal(lam12, { (reifiedFakeOverride as ReifiedMFVCHolderWithImpls).p1 = dPoint }) + equal(lam6, { genericFakeOverrideWithMFVCUpperBound.p = dPoint }) + equal(lam6, { (genericFakeOverrideWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls).p = dPoint }) + equal(lam8, { genericFakeOverrideWithMFVCUpperBound.p1 = dPoint }) + equal(lam8, { (genericFakeOverrideWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls).p1 = dPoint }) + + + val genericFakeOverrideMFVC = GenericFakeOverrideMFVC(1.0.my, 2.0.my) + + equal(lam1, { genericFakeOverrideMFVC.p }) + equal(lam1, { (genericFakeOverrideMFVC as GenericMFVCHolderWithImpls).p }) + equal(lam3, { genericFakeOverrideMFVC.p1 }) + equal(lam3, { (genericFakeOverrideMFVC as GenericMFVCHolderWithImpls).p1 }) + + val reifiedFakeOverrideMFVC = ReifiedFakeOverrideMFVC(1.0.my, 2.0.my) + equal(lam9, { reifiedFakeOverrideMFVC.p }) + equal(lam9, { (reifiedFakeOverrideMFVC as ReifiedMFVCHolderWithImpls).p }) + equal(lam11, { reifiedFakeOverrideMFVC.p1 }) + equal(lam11, { (reifiedFakeOverrideMFVC as ReifiedMFVCHolderWithImpls).p1 }) + + val genericFakeOverrideMFVCWithMFVCUpperBound = GenericFakeOverrideMFVCWithMFVCUpperBound(1.0.my, 2.0.my) + equal(lam5, { genericFakeOverrideMFVCWithMFVCUpperBound.p }) + equal(lam5, { (genericFakeOverrideMFVCWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls).p }) + equal(lam7, { genericFakeOverrideMFVCWithMFVCUpperBound.p1 }) + equal(lam7, { (genericFakeOverrideMFVCWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls).p1 }) + + equal(lam2, { genericFakeOverrideMFVC.p = dPoint }) + equal(lam2, { (genericFakeOverrideMFVC as GenericMFVCHolderWithImpls).p = dPoint }) + equal(lam4, { genericFakeOverrideMFVC.p1 = dPoint }) + equal(lam4, { (genericFakeOverrideMFVC as GenericMFVCHolderWithImpls).p1 = dPoint }) + + equal(lam10, { reifiedFakeOverrideMFVC.p = dPoint }) + equal(lam10, { (reifiedFakeOverrideMFVC as ReifiedMFVCHolderWithImpls).p = dPoint }) + equal(lam12, { reifiedFakeOverrideMFVC.p1 = dPoint }) + equal(lam12, { (reifiedFakeOverrideMFVC as ReifiedMFVCHolderWithImpls).p1 = dPoint }) + + equal(lam6, { genericFakeOverrideMFVCWithMFVCUpperBound.p = dPoint }) + equal(lam6, { (genericFakeOverrideMFVCWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls).p = dPoint }) + equal(lam8, { genericFakeOverrideMFVCWithMFVCUpperBound.p1 = dPoint }) + equal(lam8, { (genericFakeOverrideMFVCWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls).p1 = dPoint }) + + + val dPointWithInterface = DPointWithInterface(1.0.my, 2.0.my) + + equal(lam15, { dPointWithInterface.somethingGeneric }) + equal(lam15, { (dPointWithInterface as SomePointInterface).somethingGeneric }) + equal(lam19, { dPointWithInterface.somethingRegular }) + equal(lam19, { (dPointWithInterface as SomePointInterface).somethingRegular }) + equal(lam17, { dPointWithInterface.somethingMFVC }) + equal(lam17, { (dPointWithInterface as SomePointInterface).somethingMFVC }) + + equal(lam15, { (dPointWithInterface as SomePointInterfaceWithMFVCBound).somethingGeneric }) + equal(lam19, { (dPointWithInterface as SomePointInterfaceWithMFVCBound).somethingRegular }) + equal(lam17, { (dPointWithInterface as SomePointInterfaceWithMFVCBound).somethingMFVC }) + + equal(lam16, { dPointWithInterface.somethingGeneric = dPoint }) + equal(lam16, { (dPointWithInterface as SomePointInterface).somethingGeneric = dPoint }) + equal(lam20, { dPointWithInterface.somethingRegular = 1 }) + equal(lam20, { (dPointWithInterface as SomePointInterface).somethingRegular = 1 }) + equal(lam18, { dPointWithInterface.somethingMFVC = dPoint }) + equal(lam18, { (dPointWithInterface as SomePointInterface).somethingMFVC = dPoint }) + + equal(lam16, { (dPointWithInterface as SomePointInterfaceWithMFVCBound).somethingGeneric = dPoint }) + equal(lam20, { (dPointWithInterface as SomePointInterfaceWithMFVCBound).somethingRegular = 1 }) + equal(lam18, { (dPointWithInterface as SomePointInterfaceWithMFVCBound).somethingMFVC = dPoint }) + + + val dSegment = DSegment(dPoint, otherDPoint) + + equal(dPointLam, { dSegment.p1 }) + equal(otherDPointLam, { dSegment.p2 }) + equal({ 1.0.my }, { dPoint.x }) + equal({ 1.0.my }, { dSegment.p1.x }) + equal({ 3.0.my }, { otherDPoint.x }) + equal({ 3.0.my }, { dSegment.p2.x }) + equal({ 2.0.my }, { dPoint.y }) + equal({ 2.0.my }, { dSegment.p1.y }) + equal({ 4.0.my }, { otherDPoint.y }) + equal({ 4.0.my }, { dSegment.p2.y }) + equal(dPointLam, { (dSegment as AbstractSegment).p1 }) + equal(otherDPointLam, { (dSegment as AbstractSegment).p2 }) + equal({ 1.0.my }, { (dSegment as AbstractSegment).p1.x }) + equal({ 3.0.my }, { (dSegment as AbstractSegment).p2.x }) + equal({ 2.0.my }, { (dSegment as AbstractSegment).p1.y }) + equal({ 4.0.my }, { (dSegment as AbstractSegment).p2.y }) + + return "OK" +} diff --git a/compiler/testData/codegen/box/valueClasses/overrides_inlineClass.txt b/compiler/testData/codegen/box/valueClasses/overrides_inlineClass.txt new file mode 100644 index 00000000000..697dc295fb2 --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/overrides_inlineClass.txt @@ -0,0 +1,2603 @@ +@kotlin.Metadata +public interface AbstractPoint { + // source: 'overrides_inlineClass.kt' + public abstract method getX(): java.lang.Object + public abstract method getY(): java.lang.Object +} + +@kotlin.Metadata +public interface AbstractSegment { + // source: 'overrides_inlineClass.kt' + public abstract method getP1(): java.lang.Object + public abstract method getP2(): java.lang.Object +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class DPoint { + // source: 'overrides_inlineClass.kt' + private final field field-0: double + private final field field-1: double + private synthetic method (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 bridge method getX(): java.lang.Object + public method getX-3cLST_U(): double + public synthetic bridge method getY(): java.lang.Object + public method getY-3cLST_U(): 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-0(): double + public synthetic final method unbox-impl-1(): double +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class DPointWithInterface { + // source: 'overrides_inlineClass.kt' + private final field field-0: double + private final field field-1: double + private synthetic method (p0: double, p1: double): void + public synthetic final static method box-impl(p0: double, p1: double): DPointWithInterface + 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 @org.jetbrains.annotations.NotNull method getSomethingGeneric(): DPoint + public synthetic bridge method getSomethingGeneric(): java.lang.Object + public static @org.jetbrains.annotations.NotNull method getSomethingGeneric-impl(p0: double, p1: double): DPoint + public @org.jetbrains.annotations.NotNull method getSomethingMFVC(): DPoint + public static @org.jetbrains.annotations.NotNull method getSomethingMFVC-impl(p0: double, p1: double): DPoint + public method getSomethingRegular(): int + public static method getSomethingRegular-impl(p0: double, p1: double): int + 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 static method setSomethingGeneric-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void + public method setSomethingMFVC-sUp7gFk(p0: double, p1: double): void + public static method setSomethingMFVC-sUp7gFk(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 + public static method toString-impl(p0: double, p1: double): java.lang.String + public synthetic final method unbox-impl-0(): double + public synthetic final method unbox-impl-1(): double +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class DSegment { + // source: 'overrides_inlineClass.kt' + private final field field-0-0: double + private final field field-0-1: double + private final field field-1-0: double + private final field field-1-1: double + private synthetic method (p0: double, p1: double, p2: double, p3: double): void + public synthetic final static method box-impl(p0: double, p1: double, p2: double, p3: double): DSegment + public final static method constructor-impl(p0: double, p1: double, p2: double, p3: double): void + 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: java.lang.Object): boolean + public final static method equals-impl0(p0: double, p1: double, p2: double, p3: double, p4: double, p5: double, p6: double, p7: double): boolean + public @org.jetbrains.annotations.NotNull method getP1(): DPoint + public synthetic bridge method getP1(): java.lang.Object + public @org.jetbrains.annotations.NotNull method getP2(): DPoint + public synthetic bridge method getP2(): java.lang.Object + public method hashCode(): int + public static method hashCode-impl(p0: double, p1: double, p2: double, p3: double): int + public @org.jetbrains.annotations.NotNull method toString(): java.lang.String + public static method toString-impl(p0: double, p1: double, p2: double, p3: double): java.lang.String + public synthetic final method unbox-impl-0(): DPoint + public synthetic final method unbox-impl-0-0(): double + public synthetic final method unbox-impl-0-1(): double + public synthetic final method unbox-impl-1(): DPoint + public synthetic final method unbox-impl-1-0(): double + public synthetic final method unbox-impl-1-1(): double +} + +@kotlin.Metadata +public final class DataClassException { + // source: 'overrides_inlineClass.kt' + private final @org.jetbrains.annotations.Nullable field value: java.lang.Object + public method (@org.jetbrains.annotations.Nullable p0: java.lang.Object): void + public final @org.jetbrains.annotations.Nullable method component1(): java.lang.Object + public synthetic static method copy$default(p0: DataClassException, p1: java.lang.Object, p2: int, p3: java.lang.Object): DataClassException + public final @org.jetbrains.annotations.NotNull method copy(@org.jetbrains.annotations.Nullable p0: java.lang.Object): DataClassException + public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean + public final @org.jetbrains.annotations.Nullable method getValue(): java.lang.Object + public method hashCode(): int + public @org.jetbrains.annotations.NotNull method toString(): java.lang.String +} + +@kotlin.Metadata +public final class GenericFakeOverride { + // source: 'overrides_inlineClass.kt' + public method (): void + public @org.jetbrains.annotations.NotNull method getP(): DPoint + public synthetic bridge method getP(): java.lang.Object + public @org.jetbrains.annotations.NotNull method getP1(): DPoint + public synthetic bridge method getP1(): java.lang.Object + public method setP(@org.jetbrains.annotations.NotNull p0: DPoint): void + public synthetic bridge method setP(p0: java.lang.Object): void + public method setP1(@org.jetbrains.annotations.NotNull p0: DPoint): void + public synthetic bridge method setP1(p0: java.lang.Object): void + public final inner class GenericMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class GenericFakeOverrideMFVC { + // source: 'overrides_inlineClass.kt' + private final field field-0: double + private final field field-1: double + private synthetic method (p0: double, p1: double): void + public synthetic final static method box-impl(p0: double, p1: double): GenericFakeOverrideMFVC + 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 @org.jetbrains.annotations.NotNull method getP(): DPoint + public synthetic bridge method getP(): java.lang.Object + public static @org.jetbrains.annotations.NotNull method getP-impl(p0: double, p1: double): DPoint + public @org.jetbrains.annotations.NotNull method getP1(): DPoint + public synthetic bridge method getP1(): java.lang.Object + 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 synthetic bridge method setP(p0: java.lang.Object): void + public method setP-sUp7gFk(@org.jetbrains.annotations.NotNull p0: DPoint): void + public static method setP-sUp7gFk(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 static method setP1-sUp7gFk(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-0(): double + public synthetic final method unbox-impl-1(): double + public final inner class GenericMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class GenericFakeOverrideMFVCWithMFVCUpperBound { + // source: 'overrides_inlineClass.kt' + private final field field-0: double + private final field field-1: double + private synthetic method (p0: double, p1: double): void + public synthetic final static method box-impl(p0: double, p1: double): GenericFakeOverrideMFVCWithMFVCUpperBound + 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 @org.jetbrains.annotations.NotNull method getP(): DPoint + public static @org.jetbrains.annotations.NotNull method getP-impl(p0: double, p1: double): DPoint + public @org.jetbrains.annotations.NotNull method getP1(): DPoint + 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 static method setP-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void + public method setP1-sUp7gFk(p0: double, p1: double): void + public static method setP1-sUp7gFk(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-0(): double + public synthetic final method unbox-impl-1(): double + public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls +} + +@kotlin.Metadata +public final class GenericFakeOverrideWithMFVCUpperBound { + // source: 'overrides_inlineClass.kt' + public method (): 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 setP1-sUp7gFk(p0: double, p1: double): void + public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface GenericMFVCHolder { + // source: 'overrides_inlineClass.kt' + public abstract method getP(): java.lang.Object + public abstract method getP1(): java.lang.Object + public abstract method setP(p0: java.lang.Object): void + public abstract method setP1(p0: java.lang.Object): void +} + +@kotlin.Metadata +public final class GenericMFVCHolderWithImpls$DefaultImpls { + // source: 'overrides_inlineClass.kt' + public static method getP(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithImpls): java.lang.Object + public static method getP1(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithImpls): java.lang.Object + public static method setP(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithImpls, p1: java.lang.Object): void + public static method setP1(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithImpls, p1: java.lang.Object): void + public final inner class GenericMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface GenericMFVCHolderWithImpls { + // source: 'overrides_inlineClass.kt' + public abstract method getP(): java.lang.Object + public abstract method getP1(): java.lang.Object + public abstract method setP(p0: java.lang.Object): void + public abstract method setP1(p0: java.lang.Object): void + public final inner class GenericMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface GenericMFVCHolderWithMFVCUpperBound { + // source: 'overrides_inlineClass.kt' + public abstract @org.jetbrains.annotations.NotNull method getP(): DPoint + public synthetic abstract method getP-0(): double + public synthetic abstract method getP-1(): double + public abstract @org.jetbrains.annotations.NotNull method getP1(): DPoint + public synthetic abstract method getP1-0(): double + public synthetic abstract method getP1-1(): double + public abstract method setP-sUp7gFk(p0: double, p1: double): void + public abstract method setP1-sUp7gFk(p0: double, p1: double): void +} + +@kotlin.Metadata +public final class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls { + // source: 'overrides_inlineClass.kt' + public static @org.jetbrains.annotations.NotNull method getP(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): DPoint + public synthetic static method getP-0(p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): double + public synthetic static method getP-1(p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): double + public static @org.jetbrains.annotations.NotNull method getP1(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): DPoint + public synthetic static method getP1-0(p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): double + public synthetic static method getP1-1(p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): double + public static method setP-sUp7gFk(@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 final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface GenericMFVCHolderWithMFVCUpperBoundWithImpls { + // source: 'overrides_inlineClass.kt' + public abstract @org.jetbrains.annotations.NotNull method getP(): DPoint + public synthetic abstract method getP-0(): double + public synthetic abstract method getP-1(): double + public abstract @org.jetbrains.annotations.NotNull method getP1(): DPoint + public synthetic abstract method getP1-0(): double + public synthetic abstract method getP1-1(): double + public abstract method setP-sUp7gFk(p0: double, p1: double): void + public abstract method setP1-sUp7gFk(p0: double, p1: double): void + public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class MyDouble { + // source: 'overrides_inlineClass.kt' + private final field value: double + private synthetic method (p0: double): void + public synthetic final static method box-impl(p0: double): MyDouble + public static method constructor-impl(p0: double): double + public method equals(p0: java.lang.Object): boolean + public static method equals-impl(p0: double, p1: java.lang.Object): boolean + public final static method equals-impl0(p0: double, p1: double): boolean + public final method getValue(): double + public method hashCode(): int + public static method hashCode-impl(p0: double): int + public method toString(): java.lang.String + public static method toString-impl(p0: double): java.lang.String + public synthetic final method unbox-impl(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$1 + inner (anonymous) class Overrides_inlineClassKt$box$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.String +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$10 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$10 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$100 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$100 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$101 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$101 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$102 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$102 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$103 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$103 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$104 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$104 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$105 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$105 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$106 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$106 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$107 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$107 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$108 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$108 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$109 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$109 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$11 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$11 + inner (anonymous) class Overrides_inlineClassKt$box$11 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$110 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$110 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$111 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$111 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$112 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$112 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$113 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$113 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$114 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-0-0: double + synthetic final field $dSegment-field-0-1: double + inner (anonymous) class Overrides_inlineClassKt$box$114 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$115 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-1-0: double + synthetic final field $dSegment-field-1-1: double + inner (anonymous) class Overrides_inlineClassKt$box$115 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$116 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$116 + inner (anonymous) class Overrides_inlineClassKt$box$116 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$117 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + inner (anonymous) class Overrides_inlineClassKt$box$117 + method (p0: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$118 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$118 + inner (anonymous) class Overrides_inlineClassKt$box$118 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$119 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-0-0: double + inner (anonymous) class Overrides_inlineClassKt$box$119 + method (p0: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$12 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$12 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$120 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$120 + inner (anonymous) class Overrides_inlineClassKt$box$120 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$121 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $otherDPoint-field-0: double + inner (anonymous) class Overrides_inlineClassKt$box$121 + method (p0: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$122 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$122 + inner (anonymous) class Overrides_inlineClassKt$box$122 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$123 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-1-0: double + inner (anonymous) class Overrides_inlineClassKt$box$123 + method (p0: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$124 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$124 + inner (anonymous) class Overrides_inlineClassKt$box$124 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$125 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$125 + method (p0: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$126 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$126 + inner (anonymous) class Overrides_inlineClassKt$box$126 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$127 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-0-1: double + inner (anonymous) class Overrides_inlineClassKt$box$127 + method (p0: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$128 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$128 + inner (anonymous) class Overrides_inlineClassKt$box$128 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$129 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $otherDPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$129 + method (p0: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$13 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$13 + inner (anonymous) class Overrides_inlineClassKt$box$13 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$130 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$130 + inner (anonymous) class Overrides_inlineClassKt$box$130 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$131 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-1-1: double + inner (anonymous) class Overrides_inlineClassKt$box$131 + method (p0: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$132 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-0-0: double + synthetic final field $dSegment-field-0-1: double + synthetic final field $dSegment-field-1-0: double + synthetic final field $dSegment-field-1-1: double + inner (anonymous) class Overrides_inlineClassKt$box$132 + method (p0: double, p1: double, p2: double, p3: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$133 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-0-0: double + synthetic final field $dSegment-field-0-1: double + synthetic final field $dSegment-field-1-0: double + synthetic final field $dSegment-field-1-1: double + inner (anonymous) class Overrides_inlineClassKt$box$133 + method (p0: double, p1: double, p2: double, p3: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$134 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$134 + inner (anonymous) class Overrides_inlineClassKt$box$134 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$135 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-0-0: double + synthetic final field $dSegment-field-0-1: double + synthetic final field $dSegment-field-1-0: double + synthetic final field $dSegment-field-1-1: double + inner (anonymous) class Overrides_inlineClassKt$box$135 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$136 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$136 + inner (anonymous) class Overrides_inlineClassKt$box$136 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$137 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-0-0: double + synthetic final field $dSegment-field-0-1: double + synthetic final field $dSegment-field-1-0: double + synthetic final field $dSegment-field-1-1: double + inner (anonymous) class Overrides_inlineClassKt$box$137 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$138 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$138 + inner (anonymous) class Overrides_inlineClassKt$box$138 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$139 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-0-0: double + synthetic final field $dSegment-field-0-1: double + synthetic final field $dSegment-field-1-0: double + synthetic final field $dSegment-field-1-1: double + inner (anonymous) class Overrides_inlineClassKt$box$139 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$14 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $otherDPoint-field-0: double + synthetic final field $otherDPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$14 + method (p0: double, p1: double, p2: double, p3: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$140 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$140 + inner (anonymous) class Overrides_inlineClassKt$box$140 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$141 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dSegment-field-0-0: double + synthetic final field $dSegment-field-0-1: double + synthetic final field $dSegment-field-1-0: double + synthetic final field $dSegment-field-1-1: double + inner (anonymous) class Overrides_inlineClassKt$box$141 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$15 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$15 + inner (anonymous) class Overrides_inlineClassKt$box$15 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$16 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $otherDPoint-field-0: double + synthetic final field $otherDPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$16 + method (p0: double, p1: double, p2: double, p3: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$17 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$17 + inner (anonymous) class Overrides_inlineClassKt$box$17 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$18 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $otherDPoint-field-0: double + synthetic final field $otherDPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$18 + method (p0: double, p1: double, p2: double, p3: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$19 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$19 + inner (anonymous) class Overrides_inlineClassKt$box$19 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$2 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$2 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.String +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$20 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $otherDPoint-field-0: double + synthetic final field $otherDPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$20 + method (p0: double, p1: double, p2: double, p3: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$21 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$21 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$22 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$22 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$23 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$23 + inner (anonymous) class Overrides_inlineClassKt$box$23 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$24 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + inner (anonymous) class Overrides_inlineClassKt$box$24 + method (p0: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$25 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$25 + inner (anonymous) class Overrides_inlineClassKt$box$25 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$26 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$26 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$27 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$27 + inner (anonymous) class Overrides_inlineClassKt$box$27 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$28 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$28 + method (p0: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke-3cLST_U(): double +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$29 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$29 + inner (anonymous) class Overrides_inlineClassKt$box$29 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$3 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$3 + inner (anonymous) class Overrides_inlineClassKt$box$3 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.String +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$30 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$30 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$31 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_inlineClassKt$box$31 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$32 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_inlineClassKt$box$32 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$33 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_inlineClassKt$box$33 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$34 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_inlineClassKt$box$34 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$35 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_inlineClassKt$box$35 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$36 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_inlineClassKt$box$36 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$37 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_inlineClassKt$box$37 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$38 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_inlineClassKt$box$38 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$39 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_inlineClassKt$box$39 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$4 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$4 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.String +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$40 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_inlineClassKt$box$40 + method (p0: RealOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$41 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_inlineClassKt$box$41 + method (p0: RealOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$42 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_inlineClassKt$box$42 + method (p0: RealOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$43 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_inlineClassKt$box$43 + method (p0: RealOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$44 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_inlineClassKt$box$44 + method (p0: RealOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$45 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_inlineClassKt$box$45 + method (p0: RealOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$46 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_inlineClassKt$box$46 + method (p0: RealOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$47 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_inlineClassKt$box$47 + method (p0: RealOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$48 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class Overrides_inlineClassKt$box$48 + method (p0: GenericFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$49 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class Overrides_inlineClassKt$box$49 + method (p0: GenericFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$5 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$5 + inner (anonymous) class Overrides_inlineClassKt$box$5 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$50 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class Overrides_inlineClassKt$box$50 + method (p0: GenericFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$51 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class Overrides_inlineClassKt$box$51 + method (p0: GenericFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$52 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class Overrides_inlineClassKt$box$52 + method (p0: ReifiedFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$53 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class Overrides_inlineClassKt$box$53 + method (p0: ReifiedFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$54 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class Overrides_inlineClassKt$box$54 + method (p0: ReifiedFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$55 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class Overrides_inlineClassKt$box$55 + method (p0: ReifiedFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$56 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class Overrides_inlineClassKt$box$56 + method (p0: GenericFakeOverrideWithMFVCUpperBound): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$57 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class Overrides_inlineClassKt$box$57 + method (p0: GenericFakeOverrideWithMFVCUpperBound): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$58 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class Overrides_inlineClassKt$box$58 + method (p0: GenericFakeOverrideWithMFVCUpperBound): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$59 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class Overrides_inlineClassKt$box$59 + method (p0: GenericFakeOverrideWithMFVCUpperBound): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$6 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$6 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$60 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class Overrides_inlineClassKt$box$60 + method (p0: GenericFakeOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$61 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class Overrides_inlineClassKt$box$61 + method (p0: GenericFakeOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$62 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class Overrides_inlineClassKt$box$62 + method (p0: GenericFakeOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$63 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class Overrides_inlineClassKt$box$63 + method (p0: GenericFakeOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$64 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class Overrides_inlineClassKt$box$64 + method (p0: ReifiedFakeOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$65 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class Overrides_inlineClassKt$box$65 + method (p0: ReifiedFakeOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$66 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class Overrides_inlineClassKt$box$66 + method (p0: ReifiedFakeOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$67 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class Overrides_inlineClassKt$box$67 + method (p0: ReifiedFakeOverride, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$68 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class Overrides_inlineClassKt$box$68 + method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$69 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class Overrides_inlineClassKt$box$69 + method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$7 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$7 + inner (anonymous) class Overrides_inlineClassKt$box$7 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$70 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class Overrides_inlineClassKt$box$70 + method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$71 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class Overrides_inlineClassKt$box$71 + method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: double, p2: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$72 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVC-field-0: double + synthetic final field $genericFakeOverrideMFVC-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$72 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$73 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVC-field-0: double + synthetic final field $genericFakeOverrideMFVC-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$73 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$74 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVC-field-0: double + synthetic final field $genericFakeOverrideMFVC-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$74 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$75 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVC-field-0: double + synthetic final field $genericFakeOverrideMFVC-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$75 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$76 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverrideMFVC-field-0: double + synthetic final field $reifiedFakeOverrideMFVC-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$76 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$77 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverrideMFVC-field-0: double + synthetic final field $reifiedFakeOverrideMFVC-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$77 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$78 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverrideMFVC-field-0: double + synthetic final field $reifiedFakeOverrideMFVC-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$78 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$79 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverrideMFVC-field-0: double + synthetic final field $reifiedFakeOverrideMFVC-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$79 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$8 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$8 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$80 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$80 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$81 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$81 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$82 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$82 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$83 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$83 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$84 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideMFVC-field-0: double + synthetic final field $genericFakeOverrideMFVC-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$84 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$85 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideMFVC-field-0: double + synthetic final field $genericFakeOverrideMFVC-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$85 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$86 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideMFVC-field-0: double + synthetic final field $genericFakeOverrideMFVC-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$86 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$87 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideMFVC-field-0: double + synthetic final field $genericFakeOverrideMFVC-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$87 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$88 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $reifiedFakeOverrideMFVC-field-0: double + synthetic final field $reifiedFakeOverrideMFVC-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$88 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$89 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $reifiedFakeOverrideMFVC-field-0: double + synthetic final field $reifiedFakeOverrideMFVC-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$89 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$9 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$9 + inner (anonymous) class Overrides_inlineClassKt$box$9 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$90 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $reifiedFakeOverrideMFVC-field-0: double + synthetic final field $reifiedFakeOverrideMFVC-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$90 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$91 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $reifiedFakeOverrideMFVC-field-0: double + synthetic final field $reifiedFakeOverrideMFVC-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$91 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$92 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$92 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$93 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$93 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$94 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$94 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$95 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: double + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$95 + method (p0: double, p1: double, p2: double, p3: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$96 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$96 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$97 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$97 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$98 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$98 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$99 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPointWithInterface-field-0: double + synthetic final field $dPointWithInterface-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$99 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$dPointLam$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$dPointLam$1 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$emptyLam$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$emptyLam$1 + inner (anonymous) class Overrides_inlineClassKt$box$emptyLam$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam1$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$lam1$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam1$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam10$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$lam10$1 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam11$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$lam11$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam11$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam12$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$lam12$1 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam13$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$lam13$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam13$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam14$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$lam14$1 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam15$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$lam15$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam15$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam16$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$lam16$1 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam17$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$lam17$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam17$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam18$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$lam18$1 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam19$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$lam19$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam19$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam2$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$lam2$1 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam20$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$lam20$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam20$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam3$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$lam3$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam3$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam4$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$lam4$1 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam5$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$lam5$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam5$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam6$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$lam6$1 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam7$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$lam7$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam7$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam8$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $dPoint-field-0: double + synthetic final field $dPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$lam8$1 + method (p0: double, p1: double): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$lam9$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_inlineClassKt$box$lam9$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam9$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_inlineClassKt$box$otherDPointLam$1 { + // source: 'overrides_inlineClass.kt' + enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; + synthetic final field $otherDPoint-field-0: double + synthetic final field $otherDPoint-field-1: double + inner (anonymous) class Overrides_inlineClassKt$box$otherDPointLam$1 + method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method invoke(): DPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +public final class Overrides_inlineClassKt { + // source: 'overrides_inlineClass.kt' + inner (anonymous) class Overrides_inlineClassKt$box$1 + inner (anonymous) class Overrides_inlineClassKt$box$10 + inner (anonymous) class Overrides_inlineClassKt$box$100 + inner (anonymous) class Overrides_inlineClassKt$box$101 + inner (anonymous) class Overrides_inlineClassKt$box$102 + inner (anonymous) class Overrides_inlineClassKt$box$103 + inner (anonymous) class Overrides_inlineClassKt$box$104 + inner (anonymous) class Overrides_inlineClassKt$box$105 + inner (anonymous) class Overrides_inlineClassKt$box$106 + inner (anonymous) class Overrides_inlineClassKt$box$107 + inner (anonymous) class Overrides_inlineClassKt$box$108 + inner (anonymous) class Overrides_inlineClassKt$box$109 + inner (anonymous) class Overrides_inlineClassKt$box$11 + inner (anonymous) class Overrides_inlineClassKt$box$110 + inner (anonymous) class Overrides_inlineClassKt$box$111 + inner (anonymous) class Overrides_inlineClassKt$box$112 + inner (anonymous) class Overrides_inlineClassKt$box$113 + inner (anonymous) class Overrides_inlineClassKt$box$114 + inner (anonymous) class Overrides_inlineClassKt$box$115 + inner (anonymous) class Overrides_inlineClassKt$box$116 + inner (anonymous) class Overrides_inlineClassKt$box$117 + inner (anonymous) class Overrides_inlineClassKt$box$118 + inner (anonymous) class Overrides_inlineClassKt$box$119 + inner (anonymous) class Overrides_inlineClassKt$box$12 + inner (anonymous) class Overrides_inlineClassKt$box$120 + inner (anonymous) class Overrides_inlineClassKt$box$121 + inner (anonymous) class Overrides_inlineClassKt$box$122 + inner (anonymous) class Overrides_inlineClassKt$box$123 + inner (anonymous) class Overrides_inlineClassKt$box$124 + inner (anonymous) class Overrides_inlineClassKt$box$125 + inner (anonymous) class Overrides_inlineClassKt$box$126 + inner (anonymous) class Overrides_inlineClassKt$box$127 + inner (anonymous) class Overrides_inlineClassKt$box$128 + inner (anonymous) class Overrides_inlineClassKt$box$129 + inner (anonymous) class Overrides_inlineClassKt$box$13 + inner (anonymous) class Overrides_inlineClassKt$box$130 + inner (anonymous) class Overrides_inlineClassKt$box$131 + inner (anonymous) class Overrides_inlineClassKt$box$132 + inner (anonymous) class Overrides_inlineClassKt$box$133 + inner (anonymous) class Overrides_inlineClassKt$box$134 + inner (anonymous) class Overrides_inlineClassKt$box$135 + inner (anonymous) class Overrides_inlineClassKt$box$136 + inner (anonymous) class Overrides_inlineClassKt$box$137 + inner (anonymous) class Overrides_inlineClassKt$box$138 + inner (anonymous) class Overrides_inlineClassKt$box$139 + inner (anonymous) class Overrides_inlineClassKt$box$14 + inner (anonymous) class Overrides_inlineClassKt$box$140 + inner (anonymous) class Overrides_inlineClassKt$box$141 + inner (anonymous) class Overrides_inlineClassKt$box$15 + inner (anonymous) class Overrides_inlineClassKt$box$16 + inner (anonymous) class Overrides_inlineClassKt$box$17 + inner (anonymous) class Overrides_inlineClassKt$box$18 + inner (anonymous) class Overrides_inlineClassKt$box$19 + inner (anonymous) class Overrides_inlineClassKt$box$2 + inner (anonymous) class Overrides_inlineClassKt$box$20 + inner (anonymous) class Overrides_inlineClassKt$box$21 + inner (anonymous) class Overrides_inlineClassKt$box$22 + inner (anonymous) class Overrides_inlineClassKt$box$23 + inner (anonymous) class Overrides_inlineClassKt$box$24 + inner (anonymous) class Overrides_inlineClassKt$box$25 + inner (anonymous) class Overrides_inlineClassKt$box$26 + inner (anonymous) class Overrides_inlineClassKt$box$27 + inner (anonymous) class Overrides_inlineClassKt$box$28 + inner (anonymous) class Overrides_inlineClassKt$box$29 + inner (anonymous) class Overrides_inlineClassKt$box$3 + inner (anonymous) class Overrides_inlineClassKt$box$30 + inner (anonymous) class Overrides_inlineClassKt$box$31 + inner (anonymous) class Overrides_inlineClassKt$box$32 + inner (anonymous) class Overrides_inlineClassKt$box$33 + inner (anonymous) class Overrides_inlineClassKt$box$34 + inner (anonymous) class Overrides_inlineClassKt$box$35 + inner (anonymous) class Overrides_inlineClassKt$box$36 + inner (anonymous) class Overrides_inlineClassKt$box$37 + inner (anonymous) class Overrides_inlineClassKt$box$38 + inner (anonymous) class Overrides_inlineClassKt$box$39 + inner (anonymous) class Overrides_inlineClassKt$box$4 + inner (anonymous) class Overrides_inlineClassKt$box$40 + inner (anonymous) class Overrides_inlineClassKt$box$41 + inner (anonymous) class Overrides_inlineClassKt$box$42 + inner (anonymous) class Overrides_inlineClassKt$box$43 + inner (anonymous) class Overrides_inlineClassKt$box$44 + inner (anonymous) class Overrides_inlineClassKt$box$45 + inner (anonymous) class Overrides_inlineClassKt$box$46 + inner (anonymous) class Overrides_inlineClassKt$box$47 + inner (anonymous) class Overrides_inlineClassKt$box$48 + inner (anonymous) class Overrides_inlineClassKt$box$49 + inner (anonymous) class Overrides_inlineClassKt$box$5 + inner (anonymous) class Overrides_inlineClassKt$box$50 + inner (anonymous) class Overrides_inlineClassKt$box$51 + inner (anonymous) class Overrides_inlineClassKt$box$52 + inner (anonymous) class Overrides_inlineClassKt$box$53 + inner (anonymous) class Overrides_inlineClassKt$box$54 + inner (anonymous) class Overrides_inlineClassKt$box$55 + inner (anonymous) class Overrides_inlineClassKt$box$56 + inner (anonymous) class Overrides_inlineClassKt$box$57 + inner (anonymous) class Overrides_inlineClassKt$box$58 + inner (anonymous) class Overrides_inlineClassKt$box$59 + inner (anonymous) class Overrides_inlineClassKt$box$6 + inner (anonymous) class Overrides_inlineClassKt$box$60 + inner (anonymous) class Overrides_inlineClassKt$box$61 + inner (anonymous) class Overrides_inlineClassKt$box$62 + inner (anonymous) class Overrides_inlineClassKt$box$63 + inner (anonymous) class Overrides_inlineClassKt$box$64 + inner (anonymous) class Overrides_inlineClassKt$box$65 + inner (anonymous) class Overrides_inlineClassKt$box$66 + inner (anonymous) class Overrides_inlineClassKt$box$67 + inner (anonymous) class Overrides_inlineClassKt$box$68 + inner (anonymous) class Overrides_inlineClassKt$box$69 + inner (anonymous) class Overrides_inlineClassKt$box$7 + inner (anonymous) class Overrides_inlineClassKt$box$70 + inner (anonymous) class Overrides_inlineClassKt$box$71 + inner (anonymous) class Overrides_inlineClassKt$box$72 + inner (anonymous) class Overrides_inlineClassKt$box$73 + inner (anonymous) class Overrides_inlineClassKt$box$74 + inner (anonymous) class Overrides_inlineClassKt$box$75 + inner (anonymous) class Overrides_inlineClassKt$box$76 + inner (anonymous) class Overrides_inlineClassKt$box$77 + inner (anonymous) class Overrides_inlineClassKt$box$78 + inner (anonymous) class Overrides_inlineClassKt$box$79 + inner (anonymous) class Overrides_inlineClassKt$box$8 + inner (anonymous) class Overrides_inlineClassKt$box$80 + inner (anonymous) class Overrides_inlineClassKt$box$81 + inner (anonymous) class Overrides_inlineClassKt$box$82 + inner (anonymous) class Overrides_inlineClassKt$box$83 + inner (anonymous) class Overrides_inlineClassKt$box$84 + inner (anonymous) class Overrides_inlineClassKt$box$85 + inner (anonymous) class Overrides_inlineClassKt$box$86 + inner (anonymous) class Overrides_inlineClassKt$box$87 + inner (anonymous) class Overrides_inlineClassKt$box$88 + inner (anonymous) class Overrides_inlineClassKt$box$89 + inner (anonymous) class Overrides_inlineClassKt$box$9 + inner (anonymous) class Overrides_inlineClassKt$box$90 + inner (anonymous) class Overrides_inlineClassKt$box$91 + inner (anonymous) class Overrides_inlineClassKt$box$92 + inner (anonymous) class Overrides_inlineClassKt$box$93 + inner (anonymous) class Overrides_inlineClassKt$box$94 + inner (anonymous) class Overrides_inlineClassKt$box$95 + inner (anonymous) class Overrides_inlineClassKt$box$96 + inner (anonymous) class Overrides_inlineClassKt$box$97 + inner (anonymous) class Overrides_inlineClassKt$box$98 + inner (anonymous) class Overrides_inlineClassKt$box$99 + inner (anonymous) class Overrides_inlineClassKt$box$dPointLam$1 + inner (anonymous) class Overrides_inlineClassKt$box$emptyLam$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam1$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam10$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam11$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam12$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam13$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam14$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam15$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam16$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam17$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam18$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam19$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam2$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam20$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam3$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam4$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam5$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam6$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam7$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam8$1 + inner (anonymous) class Overrides_inlineClassKt$box$lam9$1 + inner (anonymous) class Overrides_inlineClassKt$box$otherDPointLam$1 + 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 getMy(p0: double): double +} + +@kotlin.Metadata +public final class RealOverride { + // source: 'overrides_inlineClass.kt' + private field p-0: double + private field p-1: double + private method (p0: double, p1: double): void + public synthetic method (p0: double, p1: double, p2: kotlin.jvm.internal.DefaultConstructorMarker): void + public @org.jetbrains.annotations.NotNull method getP(): DPoint + public synthetic bridge method getP(): java.lang.Object + public synthetic method getP-0(): double + public synthetic method getP-1(): double + public @org.jetbrains.annotations.NotNull method getP1(): DPoint + public synthetic bridge method getP1(): java.lang.Object + public synthetic method getP1-0(): double + public synthetic method getP1-1(): double + public synthetic bridge method setP(p0: java.lang.Object): void + public method setP-sUp7gFk(p0: double, p1: double): void + public synthetic bridge method setP1(p0: java.lang.Object): void + public method setP1-sUp7gFk(p0: double, p1: double): void +} + +@kotlin.Metadata +public final class ReifiedFakeOverride { + // source: 'overrides_inlineClass.kt' + public method (): 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 setP1-sUp7gFk(p0: double, p1: double): void + public final inner class ReifiedMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class ReifiedFakeOverrideMFVC { + // source: 'overrides_inlineClass.kt' + private final field field-0: double + private final field field-1: double + private synthetic method (p0: double, p1: double): void + public synthetic final static method box-impl(p0: double, p1: double): ReifiedFakeOverrideMFVC + 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 @org.jetbrains.annotations.NotNull method getP(): DPoint + public static @org.jetbrains.annotations.NotNull method getP-impl(p0: double, p1: double): DPoint + public @org.jetbrains.annotations.NotNull method getP1(): DPoint + 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 static method setP-sUp7gFk(p0: double, p1: double, p2: double, p3: double): void + public method setP1-sUp7gFk(p0: double, p1: double): void + public static method setP1-sUp7gFk(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-0(): double + public synthetic final method unbox-impl-1(): double + public final inner class ReifiedMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface ReifiedMFVCHolder { + // source: 'overrides_inlineClass.kt' + public abstract @org.jetbrains.annotations.NotNull method getP(): DPoint + public synthetic abstract method getP-0(): double + public synthetic abstract method getP-1(): double + public abstract @org.jetbrains.annotations.NotNull method getP1(): DPoint + public synthetic abstract method getP1-0(): double + public synthetic abstract method getP1-1(): double + public abstract method setP-sUp7gFk(p0: double, p1: double): void + public abstract method setP1-sUp7gFk(p0: double, p1: double): void +} + +@kotlin.Metadata +public final class ReifiedMFVCHolderWithImpls$DefaultImpls { + // source: 'overrides_inlineClass.kt' + public static @org.jetbrains.annotations.NotNull method getP(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls): DPoint + public synthetic static method getP-0(p0: ReifiedMFVCHolderWithImpls): double + public synthetic static method getP-1(p0: ReifiedMFVCHolderWithImpls): double + public static @org.jetbrains.annotations.NotNull method getP1(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls): DPoint + public synthetic static method getP1-0(p0: ReifiedMFVCHolderWithImpls): double + public synthetic static method getP1-1(p0: ReifiedMFVCHolderWithImpls): double + public static method setP-sUp7gFk(@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 final inner class ReifiedMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface ReifiedMFVCHolderWithImpls { + // source: 'overrides_inlineClass.kt' + public abstract @org.jetbrains.annotations.NotNull method getP(): DPoint + public synthetic abstract method getP-0(): double + public synthetic abstract method getP-1(): double + public abstract @org.jetbrains.annotations.NotNull method getP1(): DPoint + public synthetic abstract method getP1-0(): double + public synthetic abstract method getP1-1(): double + public abstract method setP-sUp7gFk(p0: double, p1: double): void + public abstract method setP1-sUp7gFk(p0: double, p1: double): void + public final inner class ReifiedMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface SomePointInterface { + // source: 'overrides_inlineClass.kt' + public abstract method getSomethingGeneric(): java.lang.Object + public abstract @org.jetbrains.annotations.NotNull method getSomethingMFVC(): DPoint + public synthetic abstract method getSomethingMFVC-0(): double + public synthetic abstract method getSomethingMFVC-1(): 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 setSomethingRegular(p0: int): void +} + +@kotlin.Metadata +public interface SomePointInterfaceWithMFVCBound { + // source: 'overrides_inlineClass.kt' + public abstract @org.jetbrains.annotations.NotNull method getSomethingGeneric(): DPoint + public synthetic abstract method getSomethingGeneric-0(): double + public synthetic abstract method getSomethingGeneric-1(): double + public abstract @org.jetbrains.annotations.NotNull method getSomethingMFVC(): DPoint + public synthetic abstract method getSomethingMFVC-0(): double + public synthetic abstract method getSomethingMFVC-1(): double + public abstract method getSomethingRegular(): int + public abstract method setSomethingGeneric-sUp7gFk(p0: double, p1: double): void + public abstract method setSomethingMFVC-sUp7gFk(p0: double, p1: double): void + public abstract method setSomethingRegular(p0: int): void +} diff --git a/compiler/testData/codegen/box/valueClasses/overrides_typeParameters.kt b/compiler/testData/codegen/box/valueClasses/overrides_typeParameters.kt new file mode 100644 index 00000000000..ecb515cdfbd --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/overrides_typeParameters.kt @@ -0,0 +1,327 @@ +// 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 +// LANGUAGE: +GenericInlineClassParameter +// CHECK_BYTECODE_LISTING + +interface AbstractPoint { + val x: T + val y: T +} + +interface SomeInterface { + fun someFunction1(x: X, t: T, r: R) = Unit + fun someFunction2(x: XPoint, t: XPoint, r: XPoint) = Unit + +} + +@JvmInline +value class XPoint(override val x: X, override val y: X): AbstractPoint, SomeInterface { + override fun someFunction1(x: X, t: T, r: R) = Unit + override fun someFunction2(x: XPoint, t: XPoint, r: XPoint) = Unit +} + +@JvmInline +value class YPoint(val x: X) + +fun > genericFunctionMFVC(v: XPoint) {} +fun > genericFunctionIC(v: YPoint) {} + +interface GenericMFVCHolder { + var p: T + var p1: T +} + +interface GenericMFVCHolderWithMFVCUpperBound> { + var p: T + var p1: T +} + +interface ReifiedMFVCHolder { + var p: XPoint + var p1: XPoint +} + +data class DataClassException(val value: Any?): Exception() + +interface GenericMFVCHolderWithImpls { + 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> { + 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: XPoint + get() = throw DataClassException(9) + set(value) = throw DataClassException(10 to value) + + var p1: XPoint + get() = throw DataClassException(11) + set(value) = throw DataClassException(12 to value) +} + +class RealOverride(override var p: XPoint) : GenericMFVCHolder>, ReifiedMFVCHolder, GenericMFVCHolderWithMFVCUpperBound> { + override var p1: XPoint + get() = throw DataClassException(13) + set(value) = throw DataClassException(14 to value) +} + +class GenericFakeOverride : GenericMFVCHolderWithImpls> +class ReifiedFakeOverride : ReifiedMFVCHolderWithImpls +class GenericFakeOverrideWithMFVCUpperBound : GenericMFVCHolderWithMFVCUpperBoundWithImpls> + + +@JvmInline +value class GenericFakeOverrideMFVC(val field1: X, val field2: X) : GenericMFVCHolderWithImpls> +@JvmInline +value class ReifiedFakeOverrideMFVC(val field1: X, val field2: X) : ReifiedMFVCHolderWithImpls +@JvmInline +value class GenericFakeOverrideMFVCWithMFVCUpperBound(val field1: X, val field2: X) : GenericMFVCHolderWithMFVCUpperBoundWithImpls> + + +interface SomePointInterface { + var somethingRegular: Int + + var somethingGeneric: T + + var somethingMFVC: XPoint +} + +interface SomePointInterfaceWithMFVCBound> { + var somethingRegular: Int + + var somethingGeneric: T + + var somethingMFVC: XPoint +} + +@JvmInline +value class XPointWithInterface(val x: Y, val y: Z) : SomePointInterface>, SomePointInterfaceWithMFVCBound> { + override var somethingGeneric: XPoint + get() = throw DataClassException(15) + set(value) = throw DataClassException(16 to value) + + override var somethingMFVC: XPoint + 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 { + val p1: T + val p2: T +} + +@JvmInline +value class XSegment(override val p1: XPoint, override val p2: XPoint): AbstractSegment> + +fun equal(expected: () -> T, actual: () -> T) { + val expectedResult = runCatching { expected() } + val actualResult = runCatching { actual() } + require(expectedResult == actualResult) { "Expected: $expectedResult\nActual: $actualResult" } +} + +fun box(): String { + val xPoint = XPoint(1.0, 2.0) + + val lam1: () -> XPoint = { throw DataClassException(1) } + val lam2: () -> Unit = { throw DataClassException(2 to xPoint) } + val lam3: () -> XPoint = { throw DataClassException(3) } + val lam4: () -> Unit = { throw DataClassException(4 to xPoint) } + val lam5: () -> XPoint = { throw DataClassException(5) } + val lam6: () -> Unit = { throw DataClassException(6 to xPoint) } + val lam7: () -> XPoint = { throw DataClassException(7) } + val lam8: () -> Unit = { throw DataClassException(8 to xPoint) } + val lam9: () -> XPoint = { throw DataClassException(9) } + val lam10: () -> Unit = { throw DataClassException(10 to xPoint) } + val lam11: () -> XPoint = { throw DataClassException(11) } + val lam12: () -> Unit = { throw DataClassException(12 to xPoint) } + val lam13: () -> XPoint = { throw DataClassException(13) } + val lam14: () -> Unit = { throw DataClassException(14 to xPoint) } + val lam15: () -> XPoint = { throw DataClassException(15) } + val lam16: () -> Unit = { throw DataClassException(16 to xPoint) } + val lam17: () -> XPoint = { throw DataClassException(17) } + val lam18: () -> Unit = { throw DataClassException(18 to xPoint) } + val lam19: () -> Int = { throw DataClassException(19) } + val lam20: () -> Unit = { throw DataClassException(20 to 1) } + val emptyLam = {} + val xPointLam = { xPoint } + val otherXPoint = XPoint(3.0, 4.0) + val otherXPointLam = { otherXPoint } + equal({ "XPoint(x=1.0, y=2.0)" }, { xPoint.toString() }) + equal({ "XPoint(x=1.0, y=2.0)" }, { (xPoint as Any).toString() }) + + equal({ true }, { xPoint.equals(xPoint) }) + equal({ true }, { xPoint.equals(xPoint as Any) }) + equal({ true }, { (xPoint as Any).equals(xPoint) }) + equal({ true }, { (xPoint as Any).equals(xPoint as Any) }) + + equal({ false }, { xPoint.equals(otherXPoint) }) + equal({ false }, { xPoint.equals(otherXPoint as Any) }) + equal({ false }, { (xPoint as Any).equals(otherXPoint) }) + equal({ false }, { (xPoint as Any).equals(otherXPoint as Any) }) + + equal({ xPoint.hashCode() }, { (xPoint as Any).hashCode() }) + + equal({ 1.0 }, { xPoint.x }) + equal({ 1.0 }, { (xPoint as AbstractPoint).x }) + equal({ 2.0 }, { xPoint.y }) + equal({ 2.0 }, { (xPoint as AbstractPoint).y }) + + + val realOverride = RealOverride(xPoint) + + equal(xPointLam, { realOverride.p }) + equal(xPointLam, { (realOverride as GenericMFVCHolder>).p }) + equal(lam13, { realOverride.p1 }) + equal(lam13, { (realOverride as GenericMFVCHolder>).p1 }) + equal(xPointLam, { (realOverride as ReifiedMFVCHolder).p }) + equal(lam13, { realOverride.p1 }) + equal(lam13, { (realOverride as ReifiedMFVCHolder).p1 }) + equal(xPointLam, { (realOverride as GenericMFVCHolderWithMFVCUpperBound>).p }) + equal(lam13, { (realOverride as GenericMFVCHolderWithMFVCUpperBound>).p1 }) + + + equal(emptyLam, { realOverride.p = xPoint }) + equal(emptyLam, { (realOverride as GenericMFVCHolder>).p = xPoint }) + equal(lam14, { realOverride.p1 = xPoint }) + equal(lam14, { (realOverride as GenericMFVCHolder>).p1 = xPoint }) + equal(emptyLam, { (realOverride as ReifiedMFVCHolder).p = xPoint }) + equal(lam14, { (realOverride as ReifiedMFVCHolder).p1 = xPoint }) + equal(emptyLam, { (realOverride as GenericMFVCHolderWithMFVCUpperBound>).p = xPoint }) + equal(lam14, { (realOverride as GenericMFVCHolderWithMFVCUpperBound>).p1 = xPoint }) + + + val genericFakeOverride = GenericFakeOverride() + + equal(lam1, { genericFakeOverride.p }) + equal(lam1, { (genericFakeOverride as GenericMFVCHolderWithImpls>).p }) + equal(lam3, { genericFakeOverride.p1 }) + equal(lam3, { (genericFakeOverride as GenericMFVCHolderWithImpls>).p1 }) + val reifiedFakeOverride = ReifiedFakeOverride() + equal(lam9, { reifiedFakeOverride.p }) + equal(lam9, { (reifiedFakeOverride as ReifiedMFVCHolderWithImpls).p }) + equal(lam11, { reifiedFakeOverride.p1 }) + equal(lam11, { (reifiedFakeOverride as ReifiedMFVCHolderWithImpls).p1 }) + val genericFakeOverrideWithMFVCUpperBound = GenericFakeOverrideWithMFVCUpperBound() + equal(lam5, { genericFakeOverrideWithMFVCUpperBound.p }) + equal(lam5, { (genericFakeOverrideWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls>).p }) + equal(lam7, { genericFakeOverrideWithMFVCUpperBound.p1 }) + equal(lam7, { (genericFakeOverrideWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls>).p1 }) + + equal(lam2, { genericFakeOverride.p = xPoint }) + equal(lam2, { (genericFakeOverride as GenericMFVCHolderWithImpls>).p = xPoint }) + equal(lam4, { genericFakeOverride.p1 = xPoint }) + equal(lam4, { (genericFakeOverride as GenericMFVCHolderWithImpls>).p1 = xPoint }) + equal(lam10, { reifiedFakeOverride.p = xPoint }) + equal(lam10, { (reifiedFakeOverride as ReifiedMFVCHolderWithImpls).p = xPoint }) + equal(lam12, { reifiedFakeOverride.p1 = xPoint }) + equal(lam12, { (reifiedFakeOverride as ReifiedMFVCHolderWithImpls).p1 = xPoint }) + equal(lam6, { genericFakeOverrideWithMFVCUpperBound.p = xPoint }) + equal(lam6, { (genericFakeOverrideWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls>).p = xPoint }) + equal(lam8, { genericFakeOverrideWithMFVCUpperBound.p1 = xPoint }) + equal(lam8, { (genericFakeOverrideWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls>).p1 = xPoint }) + + + val genericFakeOverrideMFVC = GenericFakeOverrideMFVC(1.0, 2.0) + + equal(lam1, { genericFakeOverrideMFVC.p }) + equal(lam1, { (genericFakeOverrideMFVC as GenericMFVCHolderWithImpls>).p }) + equal(lam3, { genericFakeOverrideMFVC.p1 }) + equal(lam3, { (genericFakeOverrideMFVC as GenericMFVCHolderWithImpls>).p1 }) + + val reifiedFakeOverrideMFVC = ReifiedFakeOverrideMFVC(1.0, 2.0) + equal(lam9, { reifiedFakeOverrideMFVC.p }) + equal(lam9, { (reifiedFakeOverrideMFVC as ReifiedMFVCHolderWithImpls).p }) + equal(lam11, { reifiedFakeOverrideMFVC.p1 }) + equal(lam11, { (reifiedFakeOverrideMFVC as ReifiedMFVCHolderWithImpls).p1 }) + + val genericFakeOverrideMFVCWithMFVCUpperBound = GenericFakeOverrideMFVCWithMFVCUpperBound(1.0, 2.0) + equal(lam5, { genericFakeOverrideMFVCWithMFVCUpperBound.p }) + equal(lam5, { (genericFakeOverrideMFVCWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls>).p }) + equal(lam7, { genericFakeOverrideMFVCWithMFVCUpperBound.p1 }) + equal(lam7, { (genericFakeOverrideMFVCWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls>).p1 }) + + equal(lam2, { genericFakeOverrideMFVC.p = xPoint }) + equal(lam2, { (genericFakeOverrideMFVC as GenericMFVCHolderWithImpls>).p = xPoint }) + equal(lam4, { genericFakeOverrideMFVC.p1 = xPoint }) + equal(lam4, { (genericFakeOverrideMFVC as GenericMFVCHolderWithImpls>).p1 = xPoint }) + + equal(lam10, { reifiedFakeOverrideMFVC.p = xPoint }) + equal(lam10, { (reifiedFakeOverrideMFVC as ReifiedMFVCHolderWithImpls).p = xPoint }) + equal(lam12, { reifiedFakeOverrideMFVC.p1 = xPoint }) + equal(lam12, { (reifiedFakeOverrideMFVC as ReifiedMFVCHolderWithImpls).p1 = xPoint }) + + equal(lam6, { genericFakeOverrideMFVCWithMFVCUpperBound.p = xPoint }) + equal(lam6, { (genericFakeOverrideMFVCWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls>).p = xPoint }) + equal(lam8, { genericFakeOverrideMFVCWithMFVCUpperBound.p1 = xPoint }) + equal(lam8, { (genericFakeOverrideMFVCWithMFVCUpperBound as GenericMFVCHolderWithMFVCUpperBoundWithImpls>).p1 = xPoint }) + + + val xPointWithInterface = XPointWithInterface(1.0, 2.0) + + equal(lam15, { xPointWithInterface.somethingGeneric }) + equal(lam15, { (xPointWithInterface as SomePointInterface>).somethingGeneric }) + equal(lam19, { xPointWithInterface.somethingRegular }) + equal(lam19, { (xPointWithInterface as SomePointInterface>).somethingRegular }) + equal(lam17, { xPointWithInterface.somethingMFVC }) + equal(lam17, { (xPointWithInterface as SomePointInterface>).somethingMFVC }) + + equal(lam15, { (xPointWithInterface as SomePointInterfaceWithMFVCBound>).somethingGeneric }) + equal(lam19, { (xPointWithInterface as SomePointInterfaceWithMFVCBound>).somethingRegular }) + equal(lam17, { (xPointWithInterface as SomePointInterfaceWithMFVCBound>).somethingMFVC }) + + equal(lam16, { xPointWithInterface.somethingGeneric = xPoint }) + equal(lam16, { (xPointWithInterface as SomePointInterface>).somethingGeneric = xPoint }) + equal(lam20, { xPointWithInterface.somethingRegular = 1 }) + equal(lam20, { (xPointWithInterface as SomePointInterface>).somethingRegular = 1 }) + equal(lam18, { xPointWithInterface.somethingMFVC = xPoint }) + equal(lam18, { (xPointWithInterface as SomePointInterface>).somethingMFVC = xPoint }) + + equal(lam16, { (xPointWithInterface as SomePointInterfaceWithMFVCBound>).somethingGeneric = xPoint }) + equal(lam20, { (xPointWithInterface as SomePointInterfaceWithMFVCBound>).somethingRegular = 1 }) + equal(lam18, { (xPointWithInterface as SomePointInterfaceWithMFVCBound>).somethingMFVC = xPoint }) + + + val xSegment = XSegment(xPoint, otherXPoint) + + equal(xPointLam, { xSegment.p1 }) + equal(otherXPointLam, { xSegment.p2 }) + equal({ 1.0 }, { xPoint.x }) + equal({ 1.0 }, { xSegment.p1.x }) + equal({ 3.0 }, { otherXPoint.x }) + equal({ 3.0 }, { xSegment.p2.x }) + equal({ 2.0 }, { xPoint.y }) + equal({ 2.0 }, { xSegment.p1.y }) + equal({ 4.0 }, { otherXPoint.y }) + equal({ 4.0 }, { xSegment.p2.y }) + equal(xPointLam, { (xSegment as AbstractSegment>).p1 }) + equal(otherXPointLam, { (xSegment as AbstractSegment>).p2 }) + equal({ 1.0 }, { (xSegment as AbstractSegment>).p1.x }) + equal({ 3.0 }, { (xSegment as AbstractSegment>).p2.x }) + equal({ 2.0 }, { (xSegment as AbstractSegment>).p1.y }) + equal({ 4.0 }, { (xSegment as AbstractSegment>).p2.y }) + + return "OK" +} diff --git a/compiler/testData/codegen/box/valueClasses/overrides_typeParameters.txt b/compiler/testData/codegen/box/valueClasses/overrides_typeParameters.txt new file mode 100644 index 00000000000..de1c92111f2 --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/overrides_typeParameters.txt @@ -0,0 +1,2625 @@ +@kotlin.Metadata +public interface AbstractPoint { + // source: 'overrides_typeParameters.kt' + public abstract method getX(): java.lang.Object + public abstract method getY(): java.lang.Object +} + +@kotlin.Metadata +public interface AbstractSegment { + // source: 'overrides_typeParameters.kt' + public abstract method getP1(): java.lang.Object + public abstract method getP2(): java.lang.Object +} + +@kotlin.Metadata +public final class DataClassException { + // source: 'overrides_typeParameters.kt' + private final @org.jetbrains.annotations.Nullable field value: java.lang.Object + public method (@org.jetbrains.annotations.Nullable p0: java.lang.Object): void + public final @org.jetbrains.annotations.Nullable method component1(): java.lang.Object + public synthetic static method copy$default(p0: DataClassException, p1: java.lang.Object, p2: int, p3: java.lang.Object): DataClassException + public final @org.jetbrains.annotations.NotNull method copy(@org.jetbrains.annotations.Nullable p0: java.lang.Object): DataClassException + public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean + public final @org.jetbrains.annotations.Nullable method getValue(): java.lang.Object + public method hashCode(): int + public @org.jetbrains.annotations.NotNull method toString(): java.lang.String +} + +@kotlin.Metadata +public final class GenericFakeOverride { + // source: 'overrides_typeParameters.kt' + public method (): void + public @org.jetbrains.annotations.NotNull method getP(): XPoint + public synthetic bridge method getP(): java.lang.Object + public @org.jetbrains.annotations.NotNull method getP1(): XPoint + public synthetic bridge method getP1(): java.lang.Object + public method setP(@org.jetbrains.annotations.NotNull p0: XPoint): void + public synthetic bridge method setP(p0: java.lang.Object): void + public method setP1(@org.jetbrains.annotations.NotNull p0: XPoint): void + public synthetic bridge method setP1(p0: java.lang.Object): void + public final inner class GenericMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class GenericFakeOverrideMFVC { + // source: 'overrides_typeParameters.kt' + private final field field-0: java.lang.Object + private final field field-1: java.lang.Object + private synthetic method (p0: java.lang.Object, p1: java.lang.Object): void + public synthetic final static method box-impl(p0: java.lang.Object, p1: java.lang.Object): GenericFakeOverrideMFVC + public final static method constructor-impl(p0: java.lang.Object, p1: java.lang.Object): void + public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean + public static method equals-impl(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): boolean + public final static method equals-impl0(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): boolean + public @org.jetbrains.annotations.NotNull method getP(): XPoint + public synthetic bridge method getP(): java.lang.Object + public static @org.jetbrains.annotations.NotNull method getP-impl(p0: java.lang.Object, p1: java.lang.Object): XPoint + public @org.jetbrains.annotations.NotNull method getP1(): XPoint + public synthetic bridge method getP1(): java.lang.Object + 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 synthetic bridge method setP(p0: java.lang.Object): void + public method setP-sUp7gFk(@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 synthetic bridge method setP1(p0: java.lang.Object): void + public method setP1-sUp7gFk(@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 @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-0(): java.lang.Object + public synthetic final method unbox-impl-1(): java.lang.Object + public final inner class GenericMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class GenericFakeOverrideMFVCWithMFVCUpperBound { + // source: 'overrides_typeParameters.kt' + private final field field-0: java.lang.Object + private final field field-1: java.lang.Object + private synthetic method (p0: java.lang.Object, p1: java.lang.Object): void + public synthetic final static method box-impl(p0: java.lang.Object, p1: java.lang.Object): GenericFakeOverrideMFVCWithMFVCUpperBound + public final static method constructor-impl(p0: java.lang.Object, p1: java.lang.Object): void + public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean + public static method equals-impl(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): boolean + public final static method equals-impl0(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): boolean + public @org.jetbrains.annotations.NotNull method getP(): XPoint + public static @org.jetbrains.annotations.NotNull method getP-impl(p0: java.lang.Object, p1: java.lang.Object): XPoint + public @org.jetbrains.annotations.NotNull method getP1(): XPoint + 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 static method setP-sUp7gFk(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 static method setP1-sUp7gFk(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-0(): java.lang.Object + public synthetic final method unbox-impl-1(): java.lang.Object + public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls +} + +@kotlin.Metadata +public final class GenericFakeOverrideWithMFVCUpperBound { + // source: 'overrides_typeParameters.kt' + public method (): 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 setP1-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void + public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface GenericMFVCHolder { + // source: 'overrides_typeParameters.kt' + public abstract method getP(): java.lang.Object + public abstract method getP1(): java.lang.Object + public abstract method setP(p0: java.lang.Object): void + public abstract method setP1(p0: java.lang.Object): void +} + +@kotlin.Metadata +public final class GenericMFVCHolderWithImpls$DefaultImpls { + // source: 'overrides_typeParameters.kt' + public static method getP(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithImpls): java.lang.Object + public static method getP1(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithImpls): java.lang.Object + public static method setP(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithImpls, p1: java.lang.Object): void + public static method setP1(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithImpls, p1: java.lang.Object): void + public final inner class GenericMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface GenericMFVCHolderWithImpls { + // source: 'overrides_typeParameters.kt' + public abstract method getP(): java.lang.Object + public abstract method getP1(): java.lang.Object + public abstract method setP(p0: java.lang.Object): void + public abstract method setP1(p0: java.lang.Object): void + public final inner class GenericMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface GenericMFVCHolderWithMFVCUpperBound { + // source: 'overrides_typeParameters.kt' + public abstract @org.jetbrains.annotations.NotNull method getP(): XPoint + public synthetic abstract method getP-0(): java.lang.Object + public synthetic abstract method getP-1(): java.lang.Object + public abstract @org.jetbrains.annotations.NotNull method getP1(): XPoint + public synthetic abstract method getP1-0(): java.lang.Object + public synthetic abstract method getP1-1(): java.lang.Object + public abstract method setP-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void + public abstract method setP1-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void +} + +@kotlin.Metadata +public final class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls { + // source: 'overrides_typeParameters.kt' + public static @org.jetbrains.annotations.NotNull method getP(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): XPoint + public synthetic static method getP-0(p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): java.lang.Object + public synthetic static method getP-1(p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): java.lang.Object + public static @org.jetbrains.annotations.NotNull method getP1(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): XPoint + public synthetic static method getP1-0(p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls): java.lang.Object + public synthetic static method getP1-1(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 setP1-sUp7gFk(@org.jetbrains.annotations.NotNull p0: GenericMFVCHolderWithMFVCUpperBoundWithImpls, p1: java.lang.Object, p2: java.lang.Object): void + public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface GenericMFVCHolderWithMFVCUpperBoundWithImpls { + // source: 'overrides_typeParameters.kt' + public abstract @org.jetbrains.annotations.NotNull method getP(): XPoint + public synthetic abstract method getP-0(): java.lang.Object + public synthetic abstract method getP-1(): java.lang.Object + public abstract @org.jetbrains.annotations.NotNull method getP1(): XPoint + public synthetic abstract method getP1-0(): java.lang.Object + public synthetic abstract method getP1-1(): java.lang.Object + public abstract method setP-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void + public abstract method setP1-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void + public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$1 + inner (anonymous) class Overrides_typeParametersKt$box$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.String +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$10 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$10 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$100 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPointWithInterface-field-0: java.lang.Object + synthetic final field $xPointWithInterface-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$100 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$101 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPointWithInterface-field-0: java.lang.Object + synthetic final field $xPointWithInterface-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$101 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$102 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPointWithInterface-field-0: java.lang.Object + synthetic final field $xPointWithInterface-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$102 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$103 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPointWithInterface-field-0: java.lang.Object + synthetic final field $xPointWithInterface-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$103 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$104 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPointWithInterface-field-0: java.lang.Object + synthetic final field $xPointWithInterface-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$104 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$105 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + synthetic final field $xPointWithInterface-field-0: java.lang.Object + synthetic final field $xPointWithInterface-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$105 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$106 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + synthetic final field $xPointWithInterface-field-0: java.lang.Object + synthetic final field $xPointWithInterface-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$106 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$107 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPointWithInterface-field-0: java.lang.Object + synthetic final field $xPointWithInterface-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$107 + method (p0: java.lang.Object, p1: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$108 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPointWithInterface-field-0: java.lang.Object + synthetic final field $xPointWithInterface-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$108 + method (p0: java.lang.Object, p1: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$109 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + synthetic final field $xPointWithInterface-field-0: java.lang.Object + synthetic final field $xPointWithInterface-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$109 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$11 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$11 + inner (anonymous) class Overrides_typeParametersKt$box$11 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$110 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + synthetic final field $xPointWithInterface-field-0: java.lang.Object + synthetic final field $xPointWithInterface-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$110 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$111 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + synthetic final field $xPointWithInterface-field-0: java.lang.Object + synthetic final field $xPointWithInterface-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$111 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$112 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPointWithInterface-field-0: java.lang.Object + synthetic final field $xPointWithInterface-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$112 + method (p0: java.lang.Object, p1: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$113 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + synthetic final field $xPointWithInterface-field-0: java.lang.Object + synthetic final field $xPointWithInterface-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$113 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$114 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xSegment-field-0-0: java.lang.Object + synthetic final field $xSegment-field-0-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$114 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$115 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xSegment-field-1-0: java.lang.Object + synthetic final field $xSegment-field-1-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$115 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$116 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$116 + inner (anonymous) class Overrides_typeParametersKt$box$116 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$117 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$117 + method (p0: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$118 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$118 + inner (anonymous) class Overrides_typeParametersKt$box$118 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$119 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xSegment-field-0-0: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$119 + method (p0: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$12 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$12 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$120 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$120 + inner (anonymous) class Overrides_typeParametersKt$box$120 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$121 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $otherXPoint-field-0: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$121 + method (p0: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$122 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$122 + inner (anonymous) class Overrides_typeParametersKt$box$122 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$123 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xSegment-field-1-0: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$123 + method (p0: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$124 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$124 + inner (anonymous) class Overrides_typeParametersKt$box$124 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$125 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$125 + method (p0: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$126 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$126 + inner (anonymous) class Overrides_typeParametersKt$box$126 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$127 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xSegment-field-0-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$127 + method (p0: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$128 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$128 + inner (anonymous) class Overrides_typeParametersKt$box$128 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$129 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $otherXPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$129 + method (p0: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$13 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$13 + inner (anonymous) class Overrides_typeParametersKt$box$13 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$130 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$130 + inner (anonymous) class Overrides_typeParametersKt$box$130 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$131 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xSegment-field-1-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$131 + method (p0: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$132 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xSegment-field-0-0: java.lang.Object + synthetic final field $xSegment-field-0-1: java.lang.Object + synthetic final field $xSegment-field-1-0: java.lang.Object + synthetic final field $xSegment-field-1-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$132 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$133 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xSegment-field-0-0: java.lang.Object + synthetic final field $xSegment-field-0-1: java.lang.Object + synthetic final field $xSegment-field-1-0: java.lang.Object + synthetic final field $xSegment-field-1-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$133 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$134 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$134 + inner (anonymous) class Overrides_typeParametersKt$box$134 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$135 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xSegment-field-0-0: java.lang.Object + synthetic final field $xSegment-field-0-1: java.lang.Object + synthetic final field $xSegment-field-1-0: java.lang.Object + synthetic final field $xSegment-field-1-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$135 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$136 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$136 + inner (anonymous) class Overrides_typeParametersKt$box$136 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$137 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xSegment-field-0-0: java.lang.Object + synthetic final field $xSegment-field-0-1: java.lang.Object + synthetic final field $xSegment-field-1-0: java.lang.Object + synthetic final field $xSegment-field-1-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$137 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$138 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$138 + inner (anonymous) class Overrides_typeParametersKt$box$138 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$139 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xSegment-field-0-0: java.lang.Object + synthetic final field $xSegment-field-0-1: java.lang.Object + synthetic final field $xSegment-field-1-0: java.lang.Object + synthetic final field $xSegment-field-1-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$139 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$14 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $otherXPoint-field-0: java.lang.Object + synthetic final field $otherXPoint-field-1: java.lang.Object + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$14 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$140 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$140 + inner (anonymous) class Overrides_typeParametersKt$box$140 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$141 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xSegment-field-0-0: java.lang.Object + synthetic final field $xSegment-field-0-1: java.lang.Object + synthetic final field $xSegment-field-1-0: java.lang.Object + synthetic final field $xSegment-field-1-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$141 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$15 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$15 + inner (anonymous) class Overrides_typeParametersKt$box$15 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$16 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $otherXPoint-field-0: java.lang.Object + synthetic final field $otherXPoint-field-1: java.lang.Object + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$16 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$17 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$17 + inner (anonymous) class Overrides_typeParametersKt$box$17 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$18 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $otherXPoint-field-0: java.lang.Object + synthetic final field $otherXPoint-field-1: java.lang.Object + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$18 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$19 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$19 + inner (anonymous) class Overrides_typeParametersKt$box$19 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$2 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$2 + method (p0: java.lang.Object, p1: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.String +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$20 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $otherXPoint-field-0: java.lang.Object + synthetic final field $otherXPoint-field-1: java.lang.Object + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$20 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$21 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$21 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$22 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$22 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$23 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$23 + inner (anonymous) class Overrides_typeParametersKt$box$23 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$24 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$24 + method (p0: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$25 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$25 + inner (anonymous) class Overrides_typeParametersKt$box$25 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$26 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$26 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$27 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$27 + inner (anonymous) class Overrides_typeParametersKt$box$27 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$28 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$28 + method (p0: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$29 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$29 + inner (anonymous) class Overrides_typeParametersKt$box$29 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$3 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$3 + inner (anonymous) class Overrides_typeParametersKt$box$3 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.String +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$30 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$30 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$31 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_typeParametersKt$box$31 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$32 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_typeParametersKt$box$32 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$33 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_typeParametersKt$box$33 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$34 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_typeParametersKt$box$34 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$35 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_typeParametersKt$box$35 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$36 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_typeParametersKt$box$36 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$37 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_typeParametersKt$box$37 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$38 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_typeParametersKt$box$38 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$39 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + inner (anonymous) class Overrides_typeParametersKt$box$39 + method (p0: RealOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$4 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$4 + method (p0: java.lang.Object, p1: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.String +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$40 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$40 + method (p0: RealOverride, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$41 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$41 + method (p0: RealOverride, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$42 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$42 + method (p0: RealOverride, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$43 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$43 + method (p0: RealOverride, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$44 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$44 + method (p0: RealOverride, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$45 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$45 + method (p0: RealOverride, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$46 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$46 + method (p0: RealOverride, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$47 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $realOverride: RealOverride + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$47 + method (p0: RealOverride, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$48 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class Overrides_typeParametersKt$box$48 + method (p0: GenericFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$49 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class Overrides_typeParametersKt$box$49 + method (p0: GenericFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$5 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$5 + inner (anonymous) class Overrides_typeParametersKt$box$5 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$50 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class Overrides_typeParametersKt$box$50 + method (p0: GenericFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$51 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverride: GenericFakeOverride + inner (anonymous) class Overrides_typeParametersKt$box$51 + method (p0: GenericFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$52 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class Overrides_typeParametersKt$box$52 + method (p0: ReifiedFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$53 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class Overrides_typeParametersKt$box$53 + method (p0: ReifiedFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$54 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class Overrides_typeParametersKt$box$54 + method (p0: ReifiedFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$55 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + inner (anonymous) class Overrides_typeParametersKt$box$55 + method (p0: ReifiedFakeOverride): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$56 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class Overrides_typeParametersKt$box$56 + method (p0: GenericFakeOverrideWithMFVCUpperBound): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$57 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class Overrides_typeParametersKt$box$57 + method (p0: GenericFakeOverrideWithMFVCUpperBound): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$58 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class Overrides_typeParametersKt$box$58 + method (p0: GenericFakeOverrideWithMFVCUpperBound): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$59 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + inner (anonymous) class Overrides_typeParametersKt$box$59 + method (p0: GenericFakeOverrideWithMFVCUpperBound): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$6 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$6 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$60 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverride: GenericFakeOverride + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$60 + method (p0: GenericFakeOverride, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$61 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverride: GenericFakeOverride + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$61 + method (p0: GenericFakeOverride, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$62 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverride: GenericFakeOverride + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$62 + method (p0: GenericFakeOverride, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$63 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverride: GenericFakeOverride + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$63 + method (p0: GenericFakeOverride, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$64 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$64 + method (p0: ReifiedFakeOverride, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$65 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$65 + method (p0: ReifiedFakeOverride, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$66 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$66 + method (p0: ReifiedFakeOverride, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$67 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverride: ReifiedFakeOverride + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$67 + method (p0: ReifiedFakeOverride, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$68 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$68 + method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$69 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$69 + method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$7 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$7 + inner (anonymous) class Overrides_typeParametersKt$box$7 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$70 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$70 + method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$71 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideWithMFVCUpperBound: GenericFakeOverrideWithMFVCUpperBound + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$71 + method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: java.lang.Object, p2: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$72 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVC-field-0: java.lang.Object + synthetic final field $genericFakeOverrideMFVC-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$72 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$73 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVC-field-0: java.lang.Object + synthetic final field $genericFakeOverrideMFVC-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$73 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$74 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVC-field-0: java.lang.Object + synthetic final field $genericFakeOverrideMFVC-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$74 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$75 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVC-field-0: java.lang.Object + synthetic final field $genericFakeOverrideMFVC-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$75 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$76 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverrideMFVC-field-0: java.lang.Object + synthetic final field $reifiedFakeOverrideMFVC-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$76 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$77 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverrideMFVC-field-0: java.lang.Object + synthetic final field $reifiedFakeOverrideMFVC-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$77 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$78 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverrideMFVC-field-0: java.lang.Object + synthetic final field $reifiedFakeOverrideMFVC-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$78 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$79 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverrideMFVC-field-0: java.lang.Object + synthetic final field $reifiedFakeOverrideMFVC-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$79 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$8 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$8 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$80 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: java.lang.Object + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$80 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$81 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: java.lang.Object + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$81 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$82 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: java.lang.Object + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$82 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$83 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: java.lang.Object + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$83 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$84 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVC-field-0: java.lang.Object + synthetic final field $genericFakeOverrideMFVC-field-1: java.lang.Object + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$84 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$85 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVC-field-0: java.lang.Object + synthetic final field $genericFakeOverrideMFVC-field-1: java.lang.Object + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$85 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$86 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVC-field-0: java.lang.Object + synthetic final field $genericFakeOverrideMFVC-field-1: java.lang.Object + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$86 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$87 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVC-field-0: java.lang.Object + synthetic final field $genericFakeOverrideMFVC-field-1: java.lang.Object + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$87 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$88 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverrideMFVC-field-0: java.lang.Object + synthetic final field $reifiedFakeOverrideMFVC-field-1: java.lang.Object + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$88 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$89 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverrideMFVC-field-0: java.lang.Object + synthetic final field $reifiedFakeOverrideMFVC-field-1: java.lang.Object + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$89 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$9 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$9 + inner (anonymous) class Overrides_typeParametersKt$box$9 + static method (): void + method (): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$90 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverrideMFVC-field-0: java.lang.Object + synthetic final field $reifiedFakeOverrideMFVC-field-1: java.lang.Object + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$90 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$91 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $reifiedFakeOverrideMFVC-field-0: java.lang.Object + synthetic final field $reifiedFakeOverrideMFVC-field-1: java.lang.Object + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$91 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$92 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: java.lang.Object + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: java.lang.Object + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$92 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$93 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: java.lang.Object + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: java.lang.Object + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$93 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$94 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: java.lang.Object + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: java.lang.Object + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$94 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$95 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-0: java.lang.Object + synthetic final field $genericFakeOverrideMFVCWithMFVCUpperBound-field-1: java.lang.Object + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$95 + method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$96 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPointWithInterface-field-0: java.lang.Object + synthetic final field $xPointWithInterface-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$96 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$97 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPointWithInterface-field-0: java.lang.Object + synthetic final field $xPointWithInterface-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$97 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$98 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPointWithInterface-field-0: java.lang.Object + synthetic final field $xPointWithInterface-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$98 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$99 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPointWithInterface-field-0: java.lang.Object + synthetic final field $xPointWithInterface-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$99 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$emptyLam$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$emptyLam$1 + inner (anonymous) class Overrides_typeParametersKt$box$emptyLam$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam1$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$lam1$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam1$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam10$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$lam10$1 + method (p0: java.lang.Object, p1: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam11$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$lam11$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam11$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam12$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$lam12$1 + method (p0: java.lang.Object, p1: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam13$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$lam13$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam13$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam14$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$lam14$1 + method (p0: java.lang.Object, p1: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam15$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$lam15$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam15$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam16$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$lam16$1 + method (p0: java.lang.Object, p1: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam17$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$lam17$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam17$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam18$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$lam18$1 + method (p0: java.lang.Object, p1: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam19$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$lam19$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam19$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam2$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$lam2$1 + method (p0: java.lang.Object, p1: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam20$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$lam20$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam20$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam3$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$lam3$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam3$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam4$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$lam4$1 + method (p0: java.lang.Object, p1: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam5$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$lam5$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam5$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam6$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$lam6$1 + method (p0: java.lang.Object, p1: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam7$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$lam7$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam7$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam8$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$lam8$1 + method (p0: java.lang.Object, p1: java.lang.Object): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$lam9$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + public final static field INSTANCE: Overrides_typeParametersKt$box$lam9$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam9$1 + static method (): void + method (): void + public synthetic bridge method invoke(): java.lang.Object + public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Void +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$otherXPointLam$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $otherXPoint-field-0: java.lang.Object + synthetic final field $otherXPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$otherXPointLam$1 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +final class Overrides_typeParametersKt$box$xPointLam$1 { + // source: 'overrides_typeParameters.kt' + enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; + synthetic final field $xPoint-field-0: java.lang.Object + synthetic final field $xPoint-field-1: java.lang.Object + inner (anonymous) class Overrides_typeParametersKt$box$xPointLam$1 + method (p0: java.lang.Object, p1: java.lang.Object): void + public final @org.jetbrains.annotations.NotNull method invoke(): XPoint + public synthetic bridge method invoke(): java.lang.Object +} + +@kotlin.Metadata +public final class Overrides_typeParametersKt { + // source: 'overrides_typeParameters.kt' + inner (anonymous) class Overrides_typeParametersKt$box$1 + inner (anonymous) class Overrides_typeParametersKt$box$10 + inner (anonymous) class Overrides_typeParametersKt$box$100 + inner (anonymous) class Overrides_typeParametersKt$box$101 + inner (anonymous) class Overrides_typeParametersKt$box$102 + inner (anonymous) class Overrides_typeParametersKt$box$103 + inner (anonymous) class Overrides_typeParametersKt$box$104 + inner (anonymous) class Overrides_typeParametersKt$box$105 + inner (anonymous) class Overrides_typeParametersKt$box$106 + inner (anonymous) class Overrides_typeParametersKt$box$107 + inner (anonymous) class Overrides_typeParametersKt$box$108 + inner (anonymous) class Overrides_typeParametersKt$box$109 + inner (anonymous) class Overrides_typeParametersKt$box$11 + inner (anonymous) class Overrides_typeParametersKt$box$110 + inner (anonymous) class Overrides_typeParametersKt$box$111 + inner (anonymous) class Overrides_typeParametersKt$box$112 + inner (anonymous) class Overrides_typeParametersKt$box$113 + inner (anonymous) class Overrides_typeParametersKt$box$114 + inner (anonymous) class Overrides_typeParametersKt$box$115 + inner (anonymous) class Overrides_typeParametersKt$box$116 + inner (anonymous) class Overrides_typeParametersKt$box$117 + inner (anonymous) class Overrides_typeParametersKt$box$118 + inner (anonymous) class Overrides_typeParametersKt$box$119 + inner (anonymous) class Overrides_typeParametersKt$box$12 + inner (anonymous) class Overrides_typeParametersKt$box$120 + inner (anonymous) class Overrides_typeParametersKt$box$121 + inner (anonymous) class Overrides_typeParametersKt$box$122 + inner (anonymous) class Overrides_typeParametersKt$box$123 + inner (anonymous) class Overrides_typeParametersKt$box$124 + inner (anonymous) class Overrides_typeParametersKt$box$125 + inner (anonymous) class Overrides_typeParametersKt$box$126 + inner (anonymous) class Overrides_typeParametersKt$box$127 + inner (anonymous) class Overrides_typeParametersKt$box$128 + inner (anonymous) class Overrides_typeParametersKt$box$129 + inner (anonymous) class Overrides_typeParametersKt$box$13 + inner (anonymous) class Overrides_typeParametersKt$box$130 + inner (anonymous) class Overrides_typeParametersKt$box$131 + inner (anonymous) class Overrides_typeParametersKt$box$132 + inner (anonymous) class Overrides_typeParametersKt$box$133 + inner (anonymous) class Overrides_typeParametersKt$box$134 + inner (anonymous) class Overrides_typeParametersKt$box$135 + inner (anonymous) class Overrides_typeParametersKt$box$136 + inner (anonymous) class Overrides_typeParametersKt$box$137 + inner (anonymous) class Overrides_typeParametersKt$box$138 + inner (anonymous) class Overrides_typeParametersKt$box$139 + inner (anonymous) class Overrides_typeParametersKt$box$14 + inner (anonymous) class Overrides_typeParametersKt$box$140 + inner (anonymous) class Overrides_typeParametersKt$box$141 + inner (anonymous) class Overrides_typeParametersKt$box$15 + inner (anonymous) class Overrides_typeParametersKt$box$16 + inner (anonymous) class Overrides_typeParametersKt$box$17 + inner (anonymous) class Overrides_typeParametersKt$box$18 + inner (anonymous) class Overrides_typeParametersKt$box$19 + inner (anonymous) class Overrides_typeParametersKt$box$2 + inner (anonymous) class Overrides_typeParametersKt$box$20 + inner (anonymous) class Overrides_typeParametersKt$box$21 + inner (anonymous) class Overrides_typeParametersKt$box$22 + inner (anonymous) class Overrides_typeParametersKt$box$23 + inner (anonymous) class Overrides_typeParametersKt$box$24 + inner (anonymous) class Overrides_typeParametersKt$box$25 + inner (anonymous) class Overrides_typeParametersKt$box$26 + inner (anonymous) class Overrides_typeParametersKt$box$27 + inner (anonymous) class Overrides_typeParametersKt$box$28 + inner (anonymous) class Overrides_typeParametersKt$box$29 + inner (anonymous) class Overrides_typeParametersKt$box$3 + inner (anonymous) class Overrides_typeParametersKt$box$30 + inner (anonymous) class Overrides_typeParametersKt$box$31 + inner (anonymous) class Overrides_typeParametersKt$box$32 + inner (anonymous) class Overrides_typeParametersKt$box$33 + inner (anonymous) class Overrides_typeParametersKt$box$34 + inner (anonymous) class Overrides_typeParametersKt$box$35 + inner (anonymous) class Overrides_typeParametersKt$box$36 + inner (anonymous) class Overrides_typeParametersKt$box$37 + inner (anonymous) class Overrides_typeParametersKt$box$38 + inner (anonymous) class Overrides_typeParametersKt$box$39 + inner (anonymous) class Overrides_typeParametersKt$box$4 + inner (anonymous) class Overrides_typeParametersKt$box$40 + inner (anonymous) class Overrides_typeParametersKt$box$41 + inner (anonymous) class Overrides_typeParametersKt$box$42 + inner (anonymous) class Overrides_typeParametersKt$box$43 + inner (anonymous) class Overrides_typeParametersKt$box$44 + inner (anonymous) class Overrides_typeParametersKt$box$45 + inner (anonymous) class Overrides_typeParametersKt$box$46 + inner (anonymous) class Overrides_typeParametersKt$box$47 + inner (anonymous) class Overrides_typeParametersKt$box$48 + inner (anonymous) class Overrides_typeParametersKt$box$49 + inner (anonymous) class Overrides_typeParametersKt$box$5 + inner (anonymous) class Overrides_typeParametersKt$box$50 + inner (anonymous) class Overrides_typeParametersKt$box$51 + inner (anonymous) class Overrides_typeParametersKt$box$52 + inner (anonymous) class Overrides_typeParametersKt$box$53 + inner (anonymous) class Overrides_typeParametersKt$box$54 + inner (anonymous) class Overrides_typeParametersKt$box$55 + inner (anonymous) class Overrides_typeParametersKt$box$56 + inner (anonymous) class Overrides_typeParametersKt$box$57 + inner (anonymous) class Overrides_typeParametersKt$box$58 + inner (anonymous) class Overrides_typeParametersKt$box$59 + inner (anonymous) class Overrides_typeParametersKt$box$6 + inner (anonymous) class Overrides_typeParametersKt$box$60 + inner (anonymous) class Overrides_typeParametersKt$box$61 + inner (anonymous) class Overrides_typeParametersKt$box$62 + inner (anonymous) class Overrides_typeParametersKt$box$63 + inner (anonymous) class Overrides_typeParametersKt$box$64 + inner (anonymous) class Overrides_typeParametersKt$box$65 + inner (anonymous) class Overrides_typeParametersKt$box$66 + inner (anonymous) class Overrides_typeParametersKt$box$67 + inner (anonymous) class Overrides_typeParametersKt$box$68 + inner (anonymous) class Overrides_typeParametersKt$box$69 + inner (anonymous) class Overrides_typeParametersKt$box$7 + inner (anonymous) class Overrides_typeParametersKt$box$70 + inner (anonymous) class Overrides_typeParametersKt$box$71 + inner (anonymous) class Overrides_typeParametersKt$box$72 + inner (anonymous) class Overrides_typeParametersKt$box$73 + inner (anonymous) class Overrides_typeParametersKt$box$74 + inner (anonymous) class Overrides_typeParametersKt$box$75 + inner (anonymous) class Overrides_typeParametersKt$box$76 + inner (anonymous) class Overrides_typeParametersKt$box$77 + inner (anonymous) class Overrides_typeParametersKt$box$78 + inner (anonymous) class Overrides_typeParametersKt$box$79 + inner (anonymous) class Overrides_typeParametersKt$box$8 + inner (anonymous) class Overrides_typeParametersKt$box$80 + inner (anonymous) class Overrides_typeParametersKt$box$81 + inner (anonymous) class Overrides_typeParametersKt$box$82 + inner (anonymous) class Overrides_typeParametersKt$box$83 + inner (anonymous) class Overrides_typeParametersKt$box$84 + inner (anonymous) class Overrides_typeParametersKt$box$85 + inner (anonymous) class Overrides_typeParametersKt$box$86 + inner (anonymous) class Overrides_typeParametersKt$box$87 + inner (anonymous) class Overrides_typeParametersKt$box$88 + inner (anonymous) class Overrides_typeParametersKt$box$89 + inner (anonymous) class Overrides_typeParametersKt$box$9 + inner (anonymous) class Overrides_typeParametersKt$box$90 + inner (anonymous) class Overrides_typeParametersKt$box$91 + inner (anonymous) class Overrides_typeParametersKt$box$92 + inner (anonymous) class Overrides_typeParametersKt$box$93 + inner (anonymous) class Overrides_typeParametersKt$box$94 + inner (anonymous) class Overrides_typeParametersKt$box$95 + inner (anonymous) class Overrides_typeParametersKt$box$96 + inner (anonymous) class Overrides_typeParametersKt$box$97 + inner (anonymous) class Overrides_typeParametersKt$box$98 + inner (anonymous) class Overrides_typeParametersKt$box$99 + inner (anonymous) class Overrides_typeParametersKt$box$emptyLam$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam1$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam10$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam11$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam12$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam13$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam14$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam15$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam16$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam17$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam18$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam19$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam2$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam20$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam3$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam4$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam5$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam6$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam7$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam8$1 + inner (anonymous) class Overrides_typeParametersKt$box$lam9$1 + inner (anonymous) class Overrides_typeParametersKt$box$otherXPointLam$1 + inner (anonymous) class Overrides_typeParametersKt$box$xPointLam$1 + 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 +} + +@kotlin.Metadata +public final class RealOverride { + // source: 'overrides_typeParameters.kt' + private field p-0: java.lang.Object + private field p-1: java.lang.Object + public method (p0: java.lang.Object, p1: java.lang.Object): void + public @org.jetbrains.annotations.NotNull method getP(): XPoint + public synthetic bridge method getP(): java.lang.Object + public synthetic method getP-0(): java.lang.Object + public synthetic method getP-1(): java.lang.Object + public @org.jetbrains.annotations.NotNull method getP1(): XPoint + public synthetic bridge method getP1(): java.lang.Object + public synthetic method getP1-0(): java.lang.Object + public synthetic method getP1-1(): 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 synthetic bridge method setP1(p0: java.lang.Object): void + public method setP1-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void +} + +@kotlin.Metadata +public final class ReifiedFakeOverride { + // source: 'overrides_typeParameters.kt' + public method (): 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 setP1-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void + public final inner class ReifiedMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class ReifiedFakeOverrideMFVC { + // source: 'overrides_typeParameters.kt' + private final field field-0: java.lang.Object + private final field field-1: java.lang.Object + private synthetic method (p0: java.lang.Object, p1: java.lang.Object): void + public synthetic final static method box-impl(p0: java.lang.Object, p1: java.lang.Object): ReifiedFakeOverrideMFVC + public final static method constructor-impl(p0: java.lang.Object, p1: java.lang.Object): void + public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean + public static method equals-impl(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): boolean + public final static method equals-impl0(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): boolean + public @org.jetbrains.annotations.NotNull method getP(): XPoint + public static @org.jetbrains.annotations.NotNull method getP-impl(p0: java.lang.Object, p1: java.lang.Object): XPoint + public @org.jetbrains.annotations.NotNull method getP1(): XPoint + 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 static method setP-sUp7gFk(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 static method setP1-sUp7gFk(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-0(): java.lang.Object + public synthetic final method unbox-impl-1(): java.lang.Object + public final inner class ReifiedMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface ReifiedMFVCHolder { + // source: 'overrides_typeParameters.kt' + public abstract @org.jetbrains.annotations.NotNull method getP(): XPoint + public synthetic abstract method getP-0(): java.lang.Object + public synthetic abstract method getP-1(): java.lang.Object + public abstract @org.jetbrains.annotations.NotNull method getP1(): XPoint + public synthetic abstract method getP1-0(): java.lang.Object + public synthetic abstract method getP1-1(): java.lang.Object + public abstract method setP-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void + public abstract method setP1-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void +} + +@kotlin.Metadata +public final class ReifiedMFVCHolderWithImpls$DefaultImpls { + // source: 'overrides_typeParameters.kt' + public static @org.jetbrains.annotations.NotNull method getP(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls): XPoint + public synthetic static method getP-0(p0: ReifiedMFVCHolderWithImpls): java.lang.Object + public synthetic static method getP-1(p0: ReifiedMFVCHolderWithImpls): java.lang.Object + public static @org.jetbrains.annotations.NotNull method getP1(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls): XPoint + public synthetic static method getP1-0(p0: ReifiedMFVCHolderWithImpls): java.lang.Object + public synthetic static method getP1-1(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 setP1-sUp7gFk(@org.jetbrains.annotations.NotNull p0: ReifiedMFVCHolderWithImpls, p1: java.lang.Object, p2: java.lang.Object): void + public final inner class ReifiedMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.Metadata +public interface ReifiedMFVCHolderWithImpls { + // source: 'overrides_typeParameters.kt' + public abstract @org.jetbrains.annotations.NotNull method getP(): XPoint + public synthetic abstract method getP-0(): java.lang.Object + public synthetic abstract method getP-1(): java.lang.Object + public abstract @org.jetbrains.annotations.NotNull method getP1(): XPoint + public synthetic abstract method getP1-0(): java.lang.Object + public synthetic abstract method getP1-1(): java.lang.Object + public abstract method setP-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void + public abstract method setP1-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void + public final inner class ReifiedMFVCHolderWithImpls$DefaultImpls +} + +@kotlin.Metadata +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 final inner class SomeInterface$DefaultImpls +} + +@kotlin.Metadata +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 final inner class SomeInterface$DefaultImpls +} + +@kotlin.Metadata +public interface SomePointInterface { + // source: 'overrides_typeParameters.kt' + public abstract method getSomethingGeneric(): java.lang.Object + public abstract @org.jetbrains.annotations.NotNull method getSomethingMFVC(): XPoint + public synthetic abstract method getSomethingMFVC-0(): java.lang.Object + public synthetic abstract method getSomethingMFVC-1(): 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 setSomethingRegular(p0: int): void +} + +@kotlin.Metadata +public interface SomePointInterfaceWithMFVCBound { + // source: 'overrides_typeParameters.kt' + public abstract @org.jetbrains.annotations.NotNull method getSomethingGeneric(): XPoint + public synthetic abstract method getSomethingGeneric-0(): java.lang.Object + public synthetic abstract method getSomethingGeneric-1(): java.lang.Object + public abstract @org.jetbrains.annotations.NotNull method getSomethingMFVC(): XPoint + public synthetic abstract method getSomethingMFVC-0(): java.lang.Object + public synthetic abstract method getSomethingMFVC-1(): 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 setSomethingMFVC-sUp7gFk(p0: java.lang.Object, p1: java.lang.Object): void + public abstract method setSomethingRegular(p0: int): void +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class XPoint { + // source: 'overrides_typeParameters.kt' + private final field field-0: java.lang.Object + private final field field-1: java.lang.Object + private synthetic method (p0: java.lang.Object, p1: java.lang.Object): void + public synthetic final static method box-impl(p0: java.lang.Object, p1: java.lang.Object): XPoint + public final static method constructor-impl(p0: java.lang.Object, p1: java.lang.Object): void + public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean + public static method equals-impl(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): boolean + public final static method equals-impl0(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): boolean + public method getX(): java.lang.Object + public method getY(): java.lang.Object + public method hashCode(): int + 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 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 @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-0(): java.lang.Object + public synthetic final method unbox-impl-1(): java.lang.Object +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class XPointWithInterface { + // source: 'overrides_typeParameters.kt' + private final field field-0: java.lang.Object + private final field field-1: java.lang.Object + private synthetic method (p0: java.lang.Object, p1: java.lang.Object): void + public synthetic final static method box-impl(p0: java.lang.Object, p1: java.lang.Object): XPointWithInterface + public final static method constructor-impl(p0: java.lang.Object, p1: java.lang.Object): void + public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean + public static method equals-impl(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): boolean + public final static method equals-impl0(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): boolean + public @org.jetbrains.annotations.NotNull method getSomethingGeneric(): XPoint + public synthetic bridge method getSomethingGeneric(): java.lang.Object + public static @org.jetbrains.annotations.NotNull method getSomethingGeneric-impl(p0: java.lang.Object, p1: java.lang.Object): XPoint + public @org.jetbrains.annotations.NotNull method getSomethingMFVC(): XPoint + public static @org.jetbrains.annotations.NotNull method getSomethingMFVC-impl(p0: java.lang.Object, p1: java.lang.Object): XPoint + public method getSomethingRegular(): int + public static method getSomethingRegular-impl(p0: java.lang.Object, p1: java.lang.Object): int + 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 static method setSomethingGeneric-sUp7gFk(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 static method setSomethingMFVC-sUp7gFk(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 + public static method toString-impl(p0: java.lang.Object, p1: java.lang.Object): java.lang.String + public synthetic final method unbox-impl-0(): java.lang.Object + public synthetic final method unbox-impl-1(): java.lang.Object +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class XSegment { + // source: 'overrides_typeParameters.kt' + private final field field-0-0: java.lang.Object + private final field field-0-1: java.lang.Object + private final field field-1-0: java.lang.Object + private final field field-1-1: java.lang.Object + private synthetic method (p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public synthetic final static method box-impl(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): XSegment + public final static method constructor-impl(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): void + public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean + public static method equals-impl(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object, p4: java.lang.Object): boolean + public final static method equals-impl0(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): boolean + public @org.jetbrains.annotations.NotNull method getP1(): XPoint + public synthetic bridge method getP1(): java.lang.Object + public @org.jetbrains.annotations.NotNull method getP2(): XPoint + public synthetic bridge method getP2(): java.lang.Object + public method hashCode(): int + public static method hashCode-impl(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): int + public @org.jetbrains.annotations.NotNull method toString(): java.lang.String + public static method toString-impl(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): java.lang.String + public synthetic final method unbox-impl-0(): XPoint + public synthetic final method unbox-impl-0-0(): java.lang.Object + public synthetic final method unbox-impl-0-1(): java.lang.Object + public synthetic final method unbox-impl-1(): XPoint + public synthetic final method unbox-impl-1-0(): java.lang.Object + public synthetic final method unbox-impl-1-1(): java.lang.Object +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class YPoint { + // source: 'overrides_typeParameters.kt' + private final field x: java.lang.Object + private synthetic method (p0: java.lang.Object): void + public synthetic final static method box-impl(p0: java.lang.Object): YPoint + public static @org.jetbrains.annotations.NotNull method constructor-impl(p0: java.lang.Object): java.lang.Object + public method equals(p0: java.lang.Object): boolean + public static method equals-impl(p0: java.lang.Object, p1: java.lang.Object): boolean + public final static method equals-impl0(p0: java.lang.Object, p1: java.lang.Object): boolean + public final method getX(): java.lang.Object + public method hashCode(): int + public static method hashCode-impl(p0: java.lang.Object): int + public method toString(): java.lang.String + public static method toString-impl(p0: java.lang.Object): java.lang.String + public synthetic final method unbox-impl(): java.lang.Object +} diff --git a/compiler/testData/codegen/box/valueClasses/throwingMFVCReassignments.kt b/compiler/testData/codegen/box/valueClasses/throwingMFVCReassignments.kt new file mode 100644 index 00000000000..0e2f8992ceb --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/throwingMFVCReassignments.kt @@ -0,0 +1,34 @@ +// WITH_STDLIB +// TARGET_BACKEND: JVM_IR +// WORKS_WHEN_VALUE_CLASS +// LANGUAGE: +ValueClasses +// CHECK_BYTECODE_LISTING + +@JvmInline +value class DPoint(val x: Double, val y: Double) + +class PointBox(var value: DPoint) + +fun box(): String { + var p = DPoint(1.0, 2.0) + try { + p = DPoint(3.0, error("Failure")) + } catch (_: Exception) { + } + if (p != DPoint(1.0, 2.0)) { + return "Partially reassigned variable" + } + + val box = PointBox(p) + + try { + box.value = DPoint(3.0, error("Failure")) + } catch (_: Exception) { + } + + if (box.value != DPoint(1.0, 2.0)) { + return "Partially reassigned field" + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/valueClasses/throwingMFVCReassignments.txt b/compiler/testData/codegen/box/valueClasses/throwingMFVCReassignments.txt new file mode 100644 index 00000000000..a644d185f32 --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/throwingMFVCReassignments.txt @@ -0,0 +1,37 @@ +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class DPoint { + // source: 'throwingMFVCReassignments.kt' + private final field field-0: double + private final field field-1: double + private synthetic method (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 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-0(): double + public synthetic final method unbox-impl-1(): double +} + +@kotlin.Metadata +public final class PointBox { + // source: 'throwingMFVCReassignments.kt' + private field value-0: double + private field value-1: double + public method (p0: double, p1: double): void + public final @org.jetbrains.annotations.NotNull method getValue(): DPoint + public synthetic final method getValue-0(): double + public synthetic final method getValue-1(): double + 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 +} diff --git a/compiler/testData/codegen/box/valueClasses/tryExpressions.kt b/compiler/testData/codegen/box/valueClasses/tryExpressions.kt new file mode 100644 index 00000000000..7447986239a --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/tryExpressions.kt @@ -0,0 +1,43 @@ +// CHECK_BYTECODE_LISTING +// WITH_STDLIB +// TARGET_BACKEND: JVM_IR +// WORKS_WHEN_VALUE_CLASS +// LANGUAGE: +ValueClasses + +@JvmInline +value class DPoint(val x: Double, val y: Double) { + init { + require(x != 0.0 && y != 0.0) + } +} + +fun tryOk() = try { + DPoint(1.0, 2.0) +} catch(_: Throwable) { + DPoint(0.0, 3.0) +} finally { + DPoint(4.0, 5.0) +} + +fun tryFail1() = try { + DPoint(0.0, 1.0) +} catch(_: Throwable) { + DPoint(2.0, 3.0) +} finally { + DPoint(4.0, 5.0) +} + +fun tryFail2() = try { + DPoint(1.0, 2.0) +} catch(_: Throwable) { + DPoint(3.0, 4.0) +} finally { + DPoint(5.0, 0.0) +} + +fun box(): String { + require(runCatching { tryOk() } == Result.success(DPoint(1.0, 2.0))) + require(runCatching { tryFail1() } == Result.success(DPoint(2.0, 3.0))) + require(runCatching { tryFail2() }.isFailure) + return "OK" +} diff --git a/compiler/testData/codegen/box/valueClasses/tryExpressions.txt b/compiler/testData/codegen/box/valueClasses/tryExpressions.txt new file mode 100644 index 00000000000..eb2ecb04ed3 --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/tryExpressions.txt @@ -0,0 +1,29 @@ +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class DPoint { + // source: 'tryExpressions.kt' + private final field field-0: double + private final field field-1: double + private synthetic method (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 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-0(): double + public synthetic final method unbox-impl-1(): double +} + +@kotlin.Metadata +public final class TryExpressionsKt { + // source: 'tryExpressions.kt' + public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String + public final static @org.jetbrains.annotations.NotNull method tryFail1(): DPoint + public final static @org.jetbrains.annotations.NotNull method tryFail2(): DPoint + public final static @org.jetbrains.annotations.NotNull method tryOk(): DPoint + public final inner class kotlin/Result$Companion +} diff --git a/compiler/testData/codegen/box/valueClasses/visibility.kt b/compiler/testData/codegen/box/valueClasses/visibility.kt new file mode 100644 index 00000000000..14272fd1063 --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/visibility.kt @@ -0,0 +1,296 @@ +// CHECK_BYTECODE_LISTING +// WITH_STDLIB +// TARGET_BACKEND: JVM_IR +// WORKS_WHEN_VALUE_CLASS +// LANGUAGE: +ValueClasses + +@JvmInline +value class Public(val x: Int, val y: Int) { + companion object { + var x: Int = 0 + val y: Int + get() = 1 + var z: Public = Public(0, 0) + val t: Public + get() = Public(0, 0) + } +} + +@JvmInline +value class Internal(internal val x: Int, internal val y: Int) { + companion object { + @JvmStatic + var x: Int = 0 + + @JvmStatic + val y: Int + get() = 1 + var z: Internal = Internal(0, 0) + + @JvmStatic + val t: Internal + get() = Internal(0, 0) + } +} + +@JvmInline +value class Private(private val x: Int, private val y: Int) + +@JvmInline +value class PublicPublic(val value: Public) + +@JvmInline +value class InternalPublic(internal val value: Public) + +@JvmInline +value class PrivatePublic(private val value: Public) + +@JvmInline +value class PublicInternal(val value: Internal) + +@JvmInline +value class InternalInternal(internal val value: Internal) + +@JvmInline +value class PrivateInternal(private val value: Internal) + +@JvmInline +value class PublicPrivate(val value: Private) + +@JvmInline +value class InternalPrivate(internal val value: Private) + +@JvmInline +value class PrivatePrivate(private val value: Private) + +class Regular { + var x1: Public = Public(1, 2) + internal var x2: Public = Public(3, 4) + private var x3: Public = Public(5, 6) + + var x4: Public = Public(7, 8) + private set + internal var x5: Public = Public(9, 10) + private set + + var x6: Public = Public(11, 12) + internal set + + + var y1: Internal = Internal(13, 14) + internal var y2: Internal = Internal(15, 16) + private var y3: Internal = Internal(17, 18) + + var y4: Internal = Internal(19, 20) + private set + internal var y5: Internal = Internal(21, 22) + private set + + var y6: Internal = Internal(23, 24) + internal set + + + var z1: Private = Private(25, 26) + internal var z2: Private = Private(27, 28) + private var z3: Private = Private(29, 30) + + var z4: Private = Private(31, 32) + private set + internal var z5: Private = Private(33, 34) + private set + + var z6: Private = Private(35, 36) + internal set + + companion object { + var staticX1: Public = Public(-1, -2) + internal var staticX2: Public = Public(-3, -4) + private var staticX3: Public = Public(-5, -6) + + var staticX4: Public = Public(-7, -8) + private set + internal var staticX5: Public = Public(-9, -10) + private set + + var staticX6: Public = Public(-11, -12) + internal set + + + var staticY1: Internal = Internal(-13, -14) + internal var staticY2: Internal = Internal(-15, -16) + private var staticY3: Internal = Internal(-17, -18) + + var staticY4: Internal = Internal(-19, -20) + private set + internal var staticY5: Internal = Internal(-21, -22) + private set + + var staticY6: Internal = Internal(-23, -24) + internal set + + + var staticZ1: Private = Private(-25, -26) + internal var staticZ2: Private = Private(-27, -28) + private var staticZ3: Private = Private(-29, -30) + + var staticZ4: Private = Private(-31, -32) + private set + internal var staticZ5: Private = Private(-33, -34) + private set + + var staticZ6: Private = Private(-35, -36) + internal set + + @JvmStatic + var jvmStaticX1: Public = Public(-1, -2) + + @JvmStatic + internal var jvmStaticX2: Public = Public(-3, -4) + + @JvmStatic + private var jvmStaticX3: Public = Public(-5, -6) + + @JvmStatic + var jvmStaticX4: Public = Public(-7, -8) + private set + + @JvmStatic + internal var jvmStaticX5: Public = Public(-9, -10) + private set + + @JvmStatic + var jvmStaticX6: Public = Public(-11, -12) + internal set + + + @JvmStatic + var jvmStaticY1: Internal = Internal(-13, -14) + + @JvmStatic + internal var jvmStaticY2: Internal = Internal(-15, -16) + + @JvmStatic + private var jvmStaticY3: Internal = Internal(-17, -18) + + @JvmStatic + var jvmStaticY4: Internal = Internal(-19, -20) + private set + + @JvmStatic + internal var jvmStaticY5: Internal = Internal(-21, -22) + private set + + @JvmStatic + var jvmStaticY6: Internal = Internal(-23, -24) + internal set + + + @JvmStatic + var jvmStaticZ1: Private = Private(-25, -26) + + @JvmStatic + internal var jvmStaticZ2: Private = Private(-27, -28) + + @JvmStatic + private var jvmStaticZ3: Private = Private(-29, -30) + + @JvmStatic + var jvmStaticZ4: Private = Private(-31, -32) + private set + + @JvmStatic + internal var jvmStaticZ5: Private = Private(-33, -34) + private set + + @JvmStatic + var jvmStaticZ6: Private = Private(-35, -36) + internal set + + } + + fun callAll() { + x1; x2; x3; x4; x5; x6 + x1.x; x1.y; x2.x; x2.y; x3.x; x3.y; x4.x; x4.y; x5.x; x5.y; x6.x; x6.y + x1 = x1; x2 = x2; x3 = x3; x4 = x4; x5 = x5; x6 = x6 + + y1; y2; y3; y4; y5; y6 + y1.x; y1.y; y2.x; y2.y; y3.x; y3.y; y4.x; y4.y; y5.x; y5.y; y6.x; y6.y + y1 = y1; y2 = y2; y3 = y3; y4 = y4; y5 = y5; y6 = y6 + + z1; z2; z3; z4; z5; z6 + z1 = z1; z2 = z2; z3 = z3; z4 = z4; z5 = z5; z6 = z6 + + + staticX1; staticX2; staticX3; staticX4; staticX5; staticX6 + staticX1.x; staticX1.y; staticX2.x; staticX2.y; staticX3.x; staticX3.y; staticX4.x; staticX4.y; staticX5.x; staticX5.y; staticX6.x; staticX6.y + staticX1 = staticX1; staticX2 = staticX2; staticX3 = staticX3; staticX4 = staticX4; staticX5 = staticX5; staticX6 = staticX6 + + staticY1; staticY2; staticY3; staticY4; staticY5; staticY6 + staticY1.x; staticY1.y; staticY2.x; staticY2.y; staticY3.x; staticY3.y; staticY4.x; staticY4.y; staticY5.x; staticY5.y; staticY6.x; staticY6.y + staticY1 = staticY1; staticY2 = staticY2; staticY3 = staticY3; staticY4 = staticY4; staticY5 = staticY5; staticY6 = staticY6 + + staticZ1; staticZ2; staticZ3; staticZ4; staticZ5; staticZ6 + staticZ1 = staticZ1; staticZ2 = staticZ2; staticZ3 = staticZ3; staticZ4 = staticZ4; staticZ5 = staticZ5; staticZ6 = staticZ6 + + + jvmStaticX1; jvmStaticX2; jvmStaticX3; jvmStaticX4; jvmStaticX5; jvmStaticX6 + jvmStaticX1.x; jvmStaticX1.y; jvmStaticX2.x; jvmStaticX2.y; jvmStaticX3.x; jvmStaticX3.y; jvmStaticX4.x; jvmStaticX4.y; jvmStaticX5.x; jvmStaticX5.y; jvmStaticX6.x; jvmStaticX6.y + jvmStaticX1 = jvmStaticX1; jvmStaticX2 = jvmStaticX2; jvmStaticX3 = jvmStaticX3; jvmStaticX4 = jvmStaticX4; jvmStaticX5 = + jvmStaticX5; jvmStaticX6 = jvmStaticX6 + + jvmStaticY1; jvmStaticY2; jvmStaticY3; jvmStaticY4; jvmStaticY5; jvmStaticY6 + jvmStaticY1.x; jvmStaticY1.y; jvmStaticY2.x; jvmStaticY2.y; jvmStaticY3.x; jvmStaticY3.y; jvmStaticY4.x; jvmStaticY4.y; jvmStaticY5.x; jvmStaticY5.y; jvmStaticY6.x; jvmStaticY6.y + jvmStaticY1 = jvmStaticY1; jvmStaticY2 = jvmStaticY2; jvmStaticY3 = jvmStaticY3; jvmStaticY4 = jvmStaticY4; jvmStaticY5 = + jvmStaticY5; jvmStaticY6 = jvmStaticY6 + + jvmStaticZ1; jvmStaticZ2; jvmStaticZ3; jvmStaticZ4; jvmStaticZ5; jvmStaticZ6 + jvmStaticZ1 = jvmStaticZ1; jvmStaticZ2 = jvmStaticZ2; jvmStaticZ3 = jvmStaticZ3; jvmStaticZ4 = jvmStaticZ4; jvmStaticZ5 = + jvmStaticZ5; jvmStaticZ6 = jvmStaticZ6 + } +} + +fun box(): String { + val r = Regular() + r.apply { + callAll() + + + x1; x2; x4; x5; x6 + x1.x; x1.y; x2.x; x2.y; x4.x; x4.y; x5.x; x5.y; x6.x; x6.y + x1 = x1; x2 = x2; x6 = x6 + + y1; y2; y4; y5; y6 + y1.x; y1.y; y2.x; y2.y; y4.x; y4.y; y5.x; y5.y; y6.x; y6.y + y1 = y1; y2 = y2; y6 = y6 + + z1; z2; z4; z5; z6 + z1 = z1; z2 = z2; z6 = z6 + } + + Regular.Companion.apply { + staticX1; staticX2; staticX4; staticX5; staticX6 + staticX1.x; staticX1.y; staticX2.x; staticX2.y; staticX4.x; staticX4.y; staticX5.x; staticX5.y; staticX6.x; staticX6.y + staticX1 = staticX1; staticX2 = staticX2; staticX6 = staticX6 + + staticY1; staticY2; staticY4; staticY5; staticY6 + staticY1.x; staticY1.y; staticY2.x; staticY2.y; staticY4.x; staticY4.y; staticY5.x; staticY5.y; staticY6.x; staticY6.y + staticY1 = staticY1; staticY2 = staticY2; staticY6 = staticY6 + + staticZ1; staticZ2; staticZ4; staticZ5; staticZ6 + staticZ1 = staticZ1; staticZ2 = staticZ2; staticZ6 = staticZ6 + + + jvmStaticX1; jvmStaticX2; jvmStaticX4; jvmStaticX5; jvmStaticX6 + jvmStaticX1.x; jvmStaticX1.y; jvmStaticX2.x; jvmStaticX2.y; jvmStaticX4.x; jvmStaticX4.y; jvmStaticX5.x; jvmStaticX5.y; jvmStaticX6.x; jvmStaticX6.y + jvmStaticX1 = jvmStaticX1; jvmStaticX2 = jvmStaticX2; jvmStaticX6 = jvmStaticX6 + + jvmStaticY1; jvmStaticY2; jvmStaticY4; jvmStaticY5; jvmStaticY6 + jvmStaticY1.x; jvmStaticY1.y; jvmStaticY2.x; jvmStaticY2.y; jvmStaticY4.x; jvmStaticY4.y; jvmStaticY5.x; jvmStaticY5.y; jvmStaticY6.x; jvmStaticY6.y + jvmStaticY1 = jvmStaticY1; jvmStaticY2 = jvmStaticY2; jvmStaticY6 = jvmStaticY6 + + jvmStaticZ1; jvmStaticZ2; jvmStaticZ4; jvmStaticZ5; jvmStaticZ6 + jvmStaticZ1 = jvmStaticZ1; jvmStaticZ2 = jvmStaticZ2; jvmStaticZ6 = jvmStaticZ6 + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/valueClasses/visibility.txt b/compiler/testData/codegen/box/valueClasses/visibility.txt new file mode 100644 index 00000000000..8189433e5f7 --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/visibility.txt @@ -0,0 +1,780 @@ +@kotlin.Metadata +public final class Internal$Companion { + // source: 'visibility.kt' + private method (): void + public synthetic method (p0: kotlin.jvm.internal.DefaultConstructorMarker): void + public synthetic deprecated static @kotlin.jvm.JvmStatic method getT$annotations(): void + public final @org.jetbrains.annotations.NotNull method getT(): Internal + public synthetic final method getT-0(): int + public synthetic final method getT-1(): int + public synthetic deprecated static @kotlin.jvm.JvmStatic method getX$annotations(): void + public final method getX(): int + public synthetic deprecated static @kotlin.jvm.JvmStatic method getY$annotations(): void + public final method getY(): int + public final @org.jetbrains.annotations.NotNull method getZ(): Internal + public synthetic final method getZ-0(): int + public synthetic final method getZ-1(): int + public final method setX(p0: int): void + public final method setZ-sUp7gFk(p0: int, p1: int): void + public final inner class Internal$Companion +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class Internal { + // source: 'visibility.kt' + public final static @org.jetbrains.annotations.NotNull field Companion: Internal$Companion + private final field field-0: int + private final field field-1: int + private static field x: int + static method (): void + private synthetic method (p0: int, p1: int): void + public synthetic final static method access$getX$cp(): int + public synthetic final static method access$getZ-0$cp(): int + public synthetic final static method access$getZ-1$cp(): int + public synthetic final static method access$setX$cp(p0: int): void + public synthetic final static method access$setZ-0$cp(p0: int): void + public synthetic final static method access$setZ-1$cp(p0: int): void + public synthetic final static method box-impl(p0: int, p1: int): Internal + 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(): Internal + public final static method getX(): int + public final static method getY(): int + public method hashCode(): int + public static method hashCode-impl(p0: int, p1: int): int + public final static method setX(p0: 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-0(): int + public synthetic final method unbox-impl-1(): int + public final inner class Internal$Companion +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class InternalInternal { + // source: 'visibility.kt' + private final field field-0-0: int + private final field field-0-1: int + private synthetic method (p0: int, p1: int): void + public synthetic final static method box-impl(p0: int, p1: int): InternalInternal + 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 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-impl-0(): Internal + public synthetic final method unbox-impl-0-0(): int + public synthetic final method unbox-impl-0-1(): int +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class InternalPrivate { + // source: 'visibility.kt' + private final field field-0-0: int + private final field field-0-1: int + private synthetic method (p0: int, p1: int): void + public synthetic final static method box-impl(p0: int, p1: int): InternalPrivate + 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 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-impl-0(): Private + public synthetic final method unbox-impl-0-0(): int + public synthetic final method unbox-impl-0-1(): int +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class InternalPublic { + // source: 'visibility.kt' + private final field field-0-0: int + private final field field-0-1: int + private synthetic method (p0: int, p1: int): void + public synthetic final static method box-impl(p0: int, p1: int): InternalPublic + 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 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-impl-0(): Public + public synthetic final method unbox-impl-0-0(): int + public synthetic final method unbox-impl-0-1(): int +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class Private { + // source: 'visibility.kt' + private final field field-0: int + private final field field-1: int + private synthetic method (p0: int, p1: int): void + public synthetic final static method box-impl(p0: int, p1: int): Private + 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 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-impl-0(): int + public synthetic final method unbox-impl-1(): int +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class PrivateInternal { + // source: 'visibility.kt' + private final field field-0-0: int + private final field field-0-1: int + private synthetic method (p0: int, p1: int): void + public synthetic final static method box-impl(p0: int, p1: int): PrivateInternal + 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 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-impl-0(): Internal + public synthetic final method unbox-impl-0-0(): int + public synthetic final method unbox-impl-0-1(): int +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class PrivatePrivate { + // source: 'visibility.kt' + private final field field-0-0: int + private final field field-0-1: int + private synthetic method (p0: int, p1: int): void + public synthetic final static method box-impl(p0: int, p1: int): PrivatePrivate + 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 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-impl-0(): Private + public synthetic final method unbox-impl-0-0(): int + public synthetic final method unbox-impl-0-1(): int +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class PrivatePublic { + // source: 'visibility.kt' + private final field field-0-0: int + private final field field-0-1: int + private synthetic method (p0: int, p1: int): void + public synthetic final static method box-impl(p0: int, p1: int): PrivatePublic + 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 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-impl-0(): Public + public synthetic final method unbox-impl-0-0(): int + public synthetic final method unbox-impl-0-1(): int +} + +@kotlin.Metadata +public final class Public$Companion { + // source: 'visibility.kt' + private method (): void + public synthetic method (p0: kotlin.jvm.internal.DefaultConstructorMarker): void + public final @org.jetbrains.annotations.NotNull method getT(): Public + public synthetic final method getT-0(): int + public synthetic final method getT-1(): int + public final method getX(): int + public final method getY(): int + public final @org.jetbrains.annotations.NotNull method getZ(): Public + public synthetic final method getZ-0(): int + public synthetic final method getZ-1(): int + public final method setX(p0: int): void + public final method setZ-sUp7gFk(p0: int, p1: int): void + public final inner class Public$Companion +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class Public { + // source: 'visibility.kt' + public final static @org.jetbrains.annotations.NotNull field Companion: Public$Companion + private final field field-0: int + private final field field-1: int + private static field x: int + static method (): void + private synthetic method (p0: int, p1: int): void + public synthetic final static method access$getX$cp(): int + public synthetic final static method access$getZ-0$cp(): int + public synthetic final static method access$getZ-1$cp(): int + public synthetic final static method access$setX$cp(p0: int): void + public synthetic final static method access$setZ-0$cp(p0: int): void + public synthetic final static method access$setZ-1$cp(p0: int): void + public synthetic final static method box-impl(p0: int, p1: int): Public + 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 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-impl-0(): int + public synthetic final method unbox-impl-1(): int + public final inner class Public$Companion +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class PublicInternal { + // source: 'visibility.kt' + private final field field-0-0: int + private final field field-0-1: int + private synthetic method (p0: int, p1: int): void + public synthetic final static method box-impl(p0: int, p1: int): PublicInternal + 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 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-impl-0(): Internal + public synthetic final method unbox-impl-0-0(): int + public synthetic final method unbox-impl-0-1(): int +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class PublicPrivate { + // source: 'visibility.kt' + private final field field-0-0: int + private final field field-0-1: int + private synthetic method (p0: int, p1: int): void + public synthetic final static method box-impl(p0: int, p1: int): PublicPrivate + 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 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-impl-0(): Private + public synthetic final method unbox-impl-0-0(): int + public synthetic final method unbox-impl-0-1(): int +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class PublicPublic { + // source: 'visibility.kt' + private final field field-0-0: int + private final field field-0-1: int + private synthetic method (p0: int, p1: int): void + public synthetic final static method box-impl(p0: int, p1: int): PublicPublic + 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 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-impl-0(): Public + public synthetic final method unbox-impl-0-0(): int + public synthetic final method unbox-impl-0-1(): int +} + +@kotlin.Metadata +public final class Regular$Companion { + // source: 'visibility.kt' + private method (): void + public synthetic method (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 deprecated static @kotlin.jvm.JvmStatic method getJvmStaticX1$annotations(): void + public final @org.jetbrains.annotations.NotNull method getJvmStaticX1(): Public + public synthetic final method getJvmStaticX1-0(): int + public synthetic final method getJvmStaticX1-1(): int + public synthetic deprecated static @kotlin.jvm.JvmStatic method getJvmStaticX2$main$annotations(): void + public final @org.jetbrains.annotations.NotNull method getJvmStaticX2$main(): Public + public synthetic final method getJvmStaticX2-0(): int + public synthetic final method getJvmStaticX2-1(): int + private synthetic deprecated static @kotlin.jvm.JvmStatic method getJvmStaticX3$annotations(): void + private final method getJvmStaticX3(): Public + public synthetic final method getJvmStaticX3-0(): int + public synthetic final method getJvmStaticX3-1(): int + public synthetic deprecated static @kotlin.jvm.JvmStatic method getJvmStaticX4$annotations(): void + public final @org.jetbrains.annotations.NotNull method getJvmStaticX4(): Public + public synthetic final method getJvmStaticX4-0(): int + public synthetic final method getJvmStaticX4-1(): int + public synthetic deprecated static @kotlin.jvm.JvmStatic method getJvmStaticX5$main$annotations(): void + public final @org.jetbrains.annotations.NotNull method getJvmStaticX5$main(): Public + public synthetic final method getJvmStaticX5-0(): int + public synthetic final method getJvmStaticX5-1(): int + public synthetic deprecated static @kotlin.jvm.JvmStatic method getJvmStaticX6$annotations(): void + public final @org.jetbrains.annotations.NotNull method getJvmStaticX6(): Public + public synthetic final method getJvmStaticX6-0(): int + public synthetic final method getJvmStaticX6-1(): int + public synthetic deprecated static @kotlin.jvm.JvmStatic method getJvmStaticY1$annotations(): void + public final @org.jetbrains.annotations.NotNull method getJvmStaticY1(): Internal + public synthetic final method getJvmStaticY1-0(): int + public synthetic final method getJvmStaticY1-1(): int + public synthetic deprecated static @kotlin.jvm.JvmStatic method getJvmStaticY2$main$annotations(): void + public final @org.jetbrains.annotations.NotNull method getJvmStaticY2$main(): Internal + public synthetic final method getJvmStaticY2-0(): int + public synthetic final method getJvmStaticY2-1(): int + private synthetic deprecated static @kotlin.jvm.JvmStatic method getJvmStaticY3$annotations(): void + private final method getJvmStaticY3(): Internal + public synthetic final method getJvmStaticY3-0(): int + public synthetic final method getJvmStaticY3-1(): int + public synthetic deprecated static @kotlin.jvm.JvmStatic method getJvmStaticY4$annotations(): void + public final @org.jetbrains.annotations.NotNull method getJvmStaticY4(): Internal + public synthetic final method getJvmStaticY4-0(): int + public synthetic final method getJvmStaticY4-1(): int + public synthetic deprecated static @kotlin.jvm.JvmStatic method getJvmStaticY5$main$annotations(): void + public final @org.jetbrains.annotations.NotNull method getJvmStaticY5$main(): Internal + public synthetic final method getJvmStaticY5-0(): int + public synthetic final method getJvmStaticY5-1(): int + public synthetic deprecated static @kotlin.jvm.JvmStatic method getJvmStaticY6$annotations(): void + public final @org.jetbrains.annotations.NotNull method getJvmStaticY6(): Internal + public synthetic final method getJvmStaticY6-0(): int + public synthetic final method getJvmStaticY6-1(): int + public synthetic deprecated static @kotlin.jvm.JvmStatic method getJvmStaticZ1$annotations(): void + public final @org.jetbrains.annotations.NotNull method getJvmStaticZ1(): Private + public synthetic final method getJvmStaticZ1-0(): int + public synthetic final method getJvmStaticZ1-1(): int + public synthetic deprecated static @kotlin.jvm.JvmStatic method getJvmStaticZ2$main$annotations(): void + public final @org.jetbrains.annotations.NotNull method getJvmStaticZ2$main(): Private + public synthetic final method getJvmStaticZ2-0(): int + public synthetic final method getJvmStaticZ2-1(): int + private synthetic deprecated static @kotlin.jvm.JvmStatic method getJvmStaticZ3$annotations(): void + private final method getJvmStaticZ3(): Private + public synthetic final method getJvmStaticZ3-0(): int + public synthetic final method getJvmStaticZ3-1(): int + public synthetic deprecated static @kotlin.jvm.JvmStatic method getJvmStaticZ4$annotations(): void + public final @org.jetbrains.annotations.NotNull method getJvmStaticZ4(): Private + public synthetic final method getJvmStaticZ4-0(): int + public synthetic final method getJvmStaticZ4-1(): int + public synthetic deprecated static @kotlin.jvm.JvmStatic method getJvmStaticZ5$main$annotations(): void + public final @org.jetbrains.annotations.NotNull method getJvmStaticZ5$main(): Private + public synthetic final method getJvmStaticZ5-0(): int + public synthetic final method getJvmStaticZ5-1(): int + public synthetic deprecated static @kotlin.jvm.JvmStatic method getJvmStaticZ6$annotations(): void + public final @org.jetbrains.annotations.NotNull method getJvmStaticZ6(): Private + public synthetic final method getJvmStaticZ6-0(): int + public synthetic final method getJvmStaticZ6-1(): int + public final @org.jetbrains.annotations.NotNull method getStaticX1(): Public + public synthetic final method getStaticX1-0(): int + public synthetic final method getStaticX1-1(): int + public final @org.jetbrains.annotations.NotNull method getStaticX2$main(): Public + public synthetic final method getStaticX2-0(): int + public synthetic final method getStaticX2-1(): int + private final method getStaticX3(): Public + public synthetic final method getStaticX3-0(): int + public synthetic final method getStaticX3-1(): int + public final @org.jetbrains.annotations.NotNull method getStaticX4(): Public + public synthetic final method getStaticX4-0(): int + public synthetic final method getStaticX4-1(): int + public final @org.jetbrains.annotations.NotNull method getStaticX5$main(): Public + public synthetic final method getStaticX5-0(): int + public synthetic final method getStaticX5-1(): int + public final @org.jetbrains.annotations.NotNull method getStaticX6(): Public + public synthetic final method getStaticX6-0(): int + public synthetic final method getStaticX6-1(): int + public final @org.jetbrains.annotations.NotNull method getStaticY1(): Internal + public synthetic final method getStaticY1-0(): int + public synthetic final method getStaticY1-1(): int + public final @org.jetbrains.annotations.NotNull method getStaticY2$main(): Internal + public synthetic final method getStaticY2-0(): int + public synthetic final method getStaticY2-1(): int + private final method getStaticY3(): Internal + public synthetic final method getStaticY3-0(): int + public synthetic final method getStaticY3-1(): int + public final @org.jetbrains.annotations.NotNull method getStaticY4(): Internal + public synthetic final method getStaticY4-0(): int + public synthetic final method getStaticY4-1(): int + public final @org.jetbrains.annotations.NotNull method getStaticY5$main(): Internal + public synthetic final method getStaticY5-0(): int + public synthetic final method getStaticY5-1(): int + public final @org.jetbrains.annotations.NotNull method getStaticY6(): Internal + public synthetic final method getStaticY6-0(): int + public synthetic final method getStaticY6-1(): int + public final @org.jetbrains.annotations.NotNull method getStaticZ1(): Private + public synthetic final method getStaticZ1-0(): int + public synthetic final method getStaticZ1-1(): int + public final @org.jetbrains.annotations.NotNull method getStaticZ2$main(): Private + public synthetic final method getStaticZ2-0(): int + public synthetic final method getStaticZ2-1(): int + private final method getStaticZ3(): Private + public synthetic final method getStaticZ3-0(): int + public synthetic final method getStaticZ3-1(): int + public final @org.jetbrains.annotations.NotNull method getStaticZ4(): Private + public synthetic final method getStaticZ4-0(): int + public synthetic final method getStaticZ4-1(): int + public final @org.jetbrains.annotations.NotNull method getStaticZ5$main(): Private + public synthetic final method getStaticZ5-0(): int + public synthetic final method getStaticZ5-1(): int + public final @org.jetbrains.annotations.NotNull method getStaticZ6(): Private + public synthetic final method getStaticZ6-0(): int + public synthetic final method getStaticZ6-1(): int + public final method setJvmStaticX1-sUp7gFk(p0: int, p1: int): void + public final method setJvmStaticX2-sUp7gFk$main(p0: int, p1: int): void + public final method setJvmStaticX6-sUp7gFk$main(p0: int, p1: int): void + public final method setJvmStaticY1-sUp7gFk(p0: int, p1: int): void + public final method setJvmStaticY2-sUp7gFk$main(p0: int, p1: int): void + public final method setJvmStaticY6-sUp7gFk$main(p0: int, p1: int): void + public final method setJvmStaticZ1-sUp7gFk(p0: int, p1: int): void + public final method setJvmStaticZ2-sUp7gFk$main(p0: int, p1: int): void + public final method setJvmStaticZ6-sUp7gFk$main(p0: int, p1: int): void + public final method setStaticX1-sUp7gFk(p0: int, p1: int): void + public final method setStaticX2-sUp7gFk$main(p0: int, p1: int): void + public final method setStaticX6-sUp7gFk$main(p0: int, p1: int): void + public final method setStaticY1-sUp7gFk(p0: int, p1: int): void + public final method setStaticY2-sUp7gFk$main(p0: int, p1: int): void + public final method setStaticY6-sUp7gFk$main(p0: int, p1: int): void + public final method setStaticZ1-sUp7gFk(p0: int, p1: int): void + public final method setStaticZ2-sUp7gFk$main(p0: int, p1: int): void + public final method setStaticZ6-sUp7gFk$main(p0: int, p1: int): void + public final inner class Regular$Companion +} + +@kotlin.Metadata +public final class Regular { + // source: 'visibility.kt' + public final static @org.jetbrains.annotations.NotNull field Companion: Regular$Companion + private static field jvmStaticX1-0: int + private static field jvmStaticX1-1: int + private static field jvmStaticX2-0: int + private static field jvmStaticX2-1: int + private static field jvmStaticX3-0: int + private static field jvmStaticX3-1: int + private static field jvmStaticX4-0: int + private static field jvmStaticX4-1: int + private static field jvmStaticX5-0: int + private static field jvmStaticX5-1: int + private static field jvmStaticX6-0: int + private static field jvmStaticX6-1: int + private static field jvmStaticY1-0: int + private static field jvmStaticY1-1: int + private static field jvmStaticY2-0: int + private static field jvmStaticY2-1: int + private static field jvmStaticY3-0: int + private static field jvmStaticY3-1: int + private static field jvmStaticY4-0: int + private static field jvmStaticY4-1: int + private static field jvmStaticY5-0: int + private static field jvmStaticY5-1: int + private static field jvmStaticY6-0: int + private static field jvmStaticY6-1: int + private static field jvmStaticZ1-0: int + private static field jvmStaticZ1-1: int + private static field jvmStaticZ2-0: int + private static field jvmStaticZ2-1: int + private static field jvmStaticZ3-0: int + private static field jvmStaticZ3-1: int + private static field jvmStaticZ4-0: int + private static field jvmStaticZ4-1: int + private static field jvmStaticZ5-0: int + private static field jvmStaticZ5-1: int + private static field jvmStaticZ6-0: int + private static field jvmStaticZ6-1: int + private static field staticX1-0: int + private static field staticX1-1: int + private static field staticX2-0: int + private static field staticX2-1: int + private static field staticX3-0: int + private static field staticX3-1: int + private static field staticX4-0: int + private static field staticX4-1: int + private static field staticX5-0: int + private static field staticX5-1: int + private static field staticX6-0: int + private static field staticX6-1: int + private static field staticY1-0: int + private static field staticY1-1: int + private static field staticY2-0: int + private static field staticY2-1: int + private static field staticY3-0: int + private static field staticY3-1: int + private static field staticY4-0: int + private static field staticY4-1: int + private static field staticY5-0: int + private static field staticY5-1: int + private static field staticY6-0: int + private static field staticY6-1: int + private static field staticZ1-0: int + private static field staticZ1-1: int + private static field staticZ2-0: int + private static field staticZ2-1: int + private static field staticZ3-0: int + private static field staticZ3-1: int + private static field staticZ4-0: int + private static field staticZ4-1: int + private static field staticZ5-0: int + private static field staticZ5-1: int + private static field staticZ6-0: int + private static field staticZ6-1: int + private field x1-0: int + private field x1-1: int + private field x2-0: int + private field x2-1: int + private field x3-0: int + private field x3-1: int + private field x4-0: int + private field x4-1: int + private field x5-0: int + private field x5-1: int + private field x6-0: int + private field x6-1: int + private field y1-0: int + private field y1-1: int + private field y2-0: int + private field y2-1: int + private field y3-0: int + private field y3-1: int + private field y4-0: int + private field y4-1: int + private field y5-0: int + private field y5-1: int + private field y6-0: int + private field y6-1: int + private field z1-0: int + private field z1-1: int + private field z2-0: int + private field z2-1: int + private field z3-0: int + private field z3-1: int + private field z4-0: int + private field z4-1: int + private field z5-0: int + private field z5-1: int + private field z6-0: int + private field z6-1: int + static method (): void + public method (): void + public synthetic final static method access$getJvmStaticX1-0$cp(): int + public synthetic final static method access$getJvmStaticX1-1$cp(): int + public synthetic final static method access$getJvmStaticX2-0$cp(): int + public synthetic final static method access$getJvmStaticX2-1$cp(): int + public synthetic final static method access$getJvmStaticX3-0$cp(): int + public synthetic final static method access$getJvmStaticX3-1$cp(): int + public synthetic final static method access$getJvmStaticX4-0$cp(): int + public synthetic final static method access$getJvmStaticX4-1$cp(): int + public synthetic final static method access$getJvmStaticX5-0$cp(): int + public synthetic final static method access$getJvmStaticX5-1$cp(): int + public synthetic final static method access$getJvmStaticX6-0$cp(): int + public synthetic final static method access$getJvmStaticX6-1$cp(): int + public synthetic final static method access$getJvmStaticY1-0$cp(): int + public synthetic final static method access$getJvmStaticY1-1$cp(): int + public synthetic final static method access$getJvmStaticY2-0$cp(): int + public synthetic final static method access$getJvmStaticY2-1$cp(): int + public synthetic final static method access$getJvmStaticY3-0$cp(): int + public synthetic final static method access$getJvmStaticY3-1$cp(): int + public synthetic final static method access$getJvmStaticY4-0$cp(): int + public synthetic final static method access$getJvmStaticY4-1$cp(): int + public synthetic final static method access$getJvmStaticY5-0$cp(): int + public synthetic final static method access$getJvmStaticY5-1$cp(): int + public synthetic final static method access$getJvmStaticY6-0$cp(): int + public synthetic final static method access$getJvmStaticY6-1$cp(): int + public synthetic final static method access$getJvmStaticZ1-0$cp(): int + public synthetic final static method access$getJvmStaticZ1-1$cp(): int + public synthetic final static method access$getJvmStaticZ2-0$cp(): int + public synthetic final static method access$getJvmStaticZ2-1$cp(): int + public synthetic final static method access$getJvmStaticZ3-0$cp(): int + public synthetic final static method access$getJvmStaticZ3-1$cp(): int + public synthetic final static method access$getJvmStaticZ4-0$cp(): int + public synthetic final static method access$getJvmStaticZ4-1$cp(): int + public synthetic final static method access$getJvmStaticZ5-0$cp(): int + public synthetic final static method access$getJvmStaticZ5-1$cp(): int + public synthetic final static method access$getJvmStaticZ6-0$cp(): int + public synthetic final static method access$getJvmStaticZ6-1$cp(): int + public synthetic final static method access$getStaticX1-0$cp(): int + public synthetic final static method access$getStaticX1-1$cp(): int + public synthetic final static method access$getStaticX2-0$cp(): int + public synthetic final static method access$getStaticX2-1$cp(): int + public synthetic final static method access$getStaticX3-0$cp(): int + public synthetic final static method access$getStaticX3-1$cp(): int + public synthetic final static method access$getStaticX4-0$cp(): int + public synthetic final static method access$getStaticX4-1$cp(): int + public synthetic final static method access$getStaticX5-0$cp(): int + public synthetic final static method access$getStaticX5-1$cp(): int + public synthetic final static method access$getStaticX6-0$cp(): int + public synthetic final static method access$getStaticX6-1$cp(): int + public synthetic final static method access$getStaticY1-0$cp(): int + public synthetic final static method access$getStaticY1-1$cp(): int + public synthetic final static method access$getStaticY2-0$cp(): int + public synthetic final static method access$getStaticY2-1$cp(): int + public synthetic final static method access$getStaticY3-0$cp(): int + public synthetic final static method access$getStaticY3-1$cp(): int + public synthetic final static method access$getStaticY4-0$cp(): int + public synthetic final static method access$getStaticY4-1$cp(): int + public synthetic final static method access$getStaticY5-0$cp(): int + public synthetic final static method access$getStaticY5-1$cp(): int + public synthetic final static method access$getStaticY6-0$cp(): int + public synthetic final static method access$getStaticY6-1$cp(): int + public synthetic final static method access$getStaticZ1-0$cp(): int + public synthetic final static method access$getStaticZ1-1$cp(): int + public synthetic final static method access$getStaticZ2-0$cp(): int + public synthetic final static method access$getStaticZ2-1$cp(): int + public synthetic final static method access$getStaticZ3-0$cp(): int + public synthetic final static method access$getStaticZ3-1$cp(): int + public synthetic final static method access$getStaticZ4-0$cp(): int + public synthetic final static method access$getStaticZ4-1$cp(): int + public synthetic final static method access$getStaticZ5-0$cp(): int + public synthetic final static method access$getStaticZ5-1$cp(): int + public synthetic final static method access$getStaticZ6-0$cp(): int + public synthetic final static method access$getStaticZ6-1$cp(): int + public synthetic final static method access$setJvmStaticX1-0$cp(p0: int): void + public synthetic final static method access$setJvmStaticX1-1$cp(p0: int): void + public synthetic final static method access$setJvmStaticX2-0$cp(p0: int): void + public synthetic final static method access$setJvmStaticX2-1$cp(p0: int): void + public synthetic final static method access$setJvmStaticX6-0$cp(p0: int): void + public synthetic final static method access$setJvmStaticX6-1$cp(p0: int): void + public synthetic final static method access$setJvmStaticY1-0$cp(p0: int): void + public synthetic final static method access$setJvmStaticY1-1$cp(p0: int): void + public synthetic final static method access$setJvmStaticY2-0$cp(p0: int): void + public synthetic final static method access$setJvmStaticY2-1$cp(p0: int): void + public synthetic final static method access$setJvmStaticY6-0$cp(p0: int): void + public synthetic final static method access$setJvmStaticY6-1$cp(p0: int): void + public synthetic final static method access$setJvmStaticZ1-0$cp(p0: int): void + public synthetic final static method access$setJvmStaticZ1-1$cp(p0: int): void + public synthetic final static method access$setJvmStaticZ2-0$cp(p0: int): void + public synthetic final static method access$setJvmStaticZ2-1$cp(p0: int): void + public synthetic final static method access$setJvmStaticZ6-0$cp(p0: int): void + public synthetic final static method access$setJvmStaticZ6-1$cp(p0: int): void + public synthetic final static method access$setStaticX1-0$cp(p0: int): void + public synthetic final static method access$setStaticX1-1$cp(p0: int): void + public synthetic final static method access$setStaticX2-0$cp(p0: int): void + public synthetic final static method access$setStaticX2-1$cp(p0: int): void + public synthetic final static method access$setStaticX6-0$cp(p0: int): void + public synthetic final static method access$setStaticX6-1$cp(p0: int): void + public synthetic final static method access$setStaticY1-0$cp(p0: int): void + public synthetic final static method access$setStaticY1-1$cp(p0: int): void + public synthetic final static method access$setStaticY2-0$cp(p0: int): void + public synthetic final static method access$setStaticY2-1$cp(p0: int): void + public synthetic final static method access$setStaticY6-0$cp(p0: int): void + public synthetic final static method access$setStaticY6-1$cp(p0: int): void + public synthetic final static method access$setStaticZ1-0$cp(p0: int): void + public synthetic final static method access$setStaticZ1-1$cp(p0: int): void + public synthetic final static method access$setStaticZ2-0$cp(p0: int): void + public synthetic final static method access$setStaticZ2-1$cp(p0: int): void + public synthetic final static method access$setStaticZ6-0$cp(p0: int): void + public synthetic final static method access$setStaticZ6-1$cp(p0: int): void + public final method callAll(): void + public final static @org.jetbrains.annotations.NotNull method getJvmStaticX1(): Public + public final static @org.jetbrains.annotations.NotNull method getJvmStaticX2$main(): Public + private final static method getJvmStaticX3(): Public + public final static @org.jetbrains.annotations.NotNull method getJvmStaticX4(): Public + public final static @org.jetbrains.annotations.NotNull method getJvmStaticX5$main(): Public + public final static @org.jetbrains.annotations.NotNull method getJvmStaticX6(): Public + public final static @org.jetbrains.annotations.NotNull method getJvmStaticY1(): Internal + public final static @org.jetbrains.annotations.NotNull method getJvmStaticY2$main(): Internal + private final static method getJvmStaticY3(): Internal + public final static @org.jetbrains.annotations.NotNull method getJvmStaticY4(): Internal + public final static @org.jetbrains.annotations.NotNull method getJvmStaticY5$main(): Internal + public final static @org.jetbrains.annotations.NotNull method getJvmStaticY6(): Internal + public final static @org.jetbrains.annotations.NotNull method getJvmStaticZ1(): Private + public final static @org.jetbrains.annotations.NotNull method getJvmStaticZ2$main(): Private + private final static method getJvmStaticZ3(): Private + public final static @org.jetbrains.annotations.NotNull method getJvmStaticZ4(): Private + public final static @org.jetbrains.annotations.NotNull method getJvmStaticZ5$main(): Private + public final static @org.jetbrains.annotations.NotNull method getJvmStaticZ6(): Private + public final @org.jetbrains.annotations.NotNull method getX1(): Public + public synthetic final method getX1-0(): int + public synthetic final method getX1-1(): int + public final @org.jetbrains.annotations.NotNull method getX2$main(): Public + public synthetic final method getX2-0(): int + public synthetic final method getX2-1(): int + private final method getX3(): Public + public synthetic final method getX3-0(): int + public synthetic final method getX3-1(): int + public final @org.jetbrains.annotations.NotNull method getX4(): Public + public synthetic final method getX4-0(): int + public synthetic final method getX4-1(): int + public final @org.jetbrains.annotations.NotNull method getX5$main(): Public + public synthetic final method getX5-0(): int + public synthetic final method getX5-1(): int + public final @org.jetbrains.annotations.NotNull method getX6(): Public + public synthetic final method getX6-0(): int + public synthetic final method getX6-1(): int + public final @org.jetbrains.annotations.NotNull method getY1(): Internal + public synthetic final method getY1-0(): int + public synthetic final method getY1-1(): int + public final @org.jetbrains.annotations.NotNull method getY2$main(): Internal + public synthetic final method getY2-0(): int + public synthetic final method getY2-1(): int + private final method getY3(): Internal + public synthetic final method getY3-0(): int + public synthetic final method getY3-1(): int + public final @org.jetbrains.annotations.NotNull method getY4(): Internal + public synthetic final method getY4-0(): int + public synthetic final method getY4-1(): int + public final @org.jetbrains.annotations.NotNull method getY5$main(): Internal + public synthetic final method getY5-0(): int + public synthetic final method getY5-1(): int + public final @org.jetbrains.annotations.NotNull method getY6(): Internal + public synthetic final method getY6-0(): int + public synthetic final method getY6-1(): int + public final @org.jetbrains.annotations.NotNull method getZ1(): Private + public synthetic final method getZ1-0(): int + public synthetic final method getZ1-1(): int + public final @org.jetbrains.annotations.NotNull method getZ2$main(): Private + public synthetic final method getZ2-0(): int + public synthetic final method getZ2-1(): int + private final method getZ3(): Private + public synthetic final method getZ3-0(): int + public synthetic final method getZ3-1(): int + public final @org.jetbrains.annotations.NotNull method getZ4(): Private + public synthetic final method getZ4-0(): int + public synthetic final method getZ4-1(): int + public final @org.jetbrains.annotations.NotNull method getZ5$main(): Private + public synthetic final method getZ5-0(): int + public synthetic final method getZ5-1(): int + public final @org.jetbrains.annotations.NotNull method getZ6(): Private + public synthetic final method getZ6-0(): int + public synthetic final method getZ6-1(): int + public final method setX1-sUp7gFk(p0: int, p1: int): void + public final method setX2-sUp7gFk$main(p0: int, p1: int): void + public final method setX6-sUp7gFk$main(p0: int, p1: int): void + public final method setY1-sUp7gFk(p0: int, p1: int): void + public final method setY2-sUp7gFk$main(p0: int, p1: int): void + public final method setY6-sUp7gFk$main(p0: int, p1: int): void + public final method setZ1-sUp7gFk(p0: int, p1: int): void + public final method setZ2-sUp7gFk$main(p0: int, p1: int): void + public final method setZ6-sUp7gFk$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 +} diff --git a/compiler/testData/codegen/bytecodeText/valueClasses/conditionalExpressions.kt b/compiler/testData/codegen/bytecodeText/valueClasses/conditionalExpressions.kt new file mode 100644 index 00000000000..8cadc8dbba8 --- /dev/null +++ b/compiler/testData/codegen/bytecodeText/valueClasses/conditionalExpressions.kt @@ -0,0 +1,41 @@ +// CHECK_BYTECODE_LISTING +// WITH_STDLIB +// TARGET_BACKEND: JVM_IR +// WORKS_WHEN_VALUE_CLASS +// LANGUAGE: +ValueClasses + +@JvmInline +value class DPoint(val x: Double, val y: Double) + +fun ifExpr() = if (DPoint(0.0, 1.0).x > 0.0) DPoint(2.0, 3.0) else DPoint(4.0, 5.0) + +fun whenExpr() = when { + DPoint(6.0, 7.0).x > 0.0 -> DPoint(8.0, 9.0) + DPoint(10.0, 11.0).x > 0.0 -> DPoint(12.0, 13.0) + else -> DPoint(14.0, 15.0) +} + +fun ifBody() { + if (DPoint(0.0, 1.0).x > 0.0) DPoint(2.0, 3.0) else DPoint(4.0, 5.0) + val x = if (DPoint(0.0, 1.0).x > 0.0) DPoint(2.0, 3.0) else DPoint(4.0, 5.0) +} + +fun whenBody() { + when { + DPoint(6.0, 7.0).x > 0.0 -> DPoint(8.0, 9.0) + DPoint(10.0, 11.0).x > 0.0 -> DPoint(12.0, 13.0) + else -> DPoint(14.0, 15.0) + } + val x = when { + DPoint(6.0, 7.0).x > 0.0 -> DPoint(8.0, 9.0) + DPoint(10.0, 11.0).x > 0.0 -> DPoint(12.0, 13.0) + else -> DPoint(14.0, 15.0) + } +} + +// 1 ifExpr.*(\n .*)(\n .*)*(\n .*box-impl.*)(\n .*)*(\n .*box-impl.*) +// 0 ifExpr.*(\n .*)(\n .*)*(\n .*box-impl.*)(\n .*)*(\n .*box-impl.*)(\n .*)*(\n .*box-impl.*) +// 1 whenExpr.*(\n .*)(\n .*)*(\n .*box-impl.*)(\n .*)*(\n .*box-impl.*)(\n .*)*(\n .*box-impl.*) +// 0 whenExpr.*(\n .*)(\n .*)*(\n .*box-impl.*)(\n .*)*(\n .*box-impl.*)(\n .*)*(\n .*box-impl.*)(\n .*)*(\n .*box-impl.*) +// 0 ifBody.*(\n .*)*(\n .*box-impl.*) +// 0 whenBody.*(\n .*)*(\n .*box-impl.*) diff --git a/compiler/testData/codegen/bytecodeText/valueClasses/equalsBoxTest.kt b/compiler/testData/codegen/bytecodeText/valueClasses/equalsBoxTest.kt new file mode 100644 index 00000000000..939d65ebd3b --- /dev/null +++ b/compiler/testData/codegen/bytecodeText/valueClasses/equalsBoxTest.kt @@ -0,0 +1,67 @@ +// CHECK_BYTECODE_LISTING +// WITH_STDLIB +// TARGET_BACKEND: JVM_IR +// WORKS_WHEN_VALUE_CLASS +// LANGUAGE: +ValueClasses + +@JvmInline +value class DPoint(val x: Double, val y: Double) + +fun require(index: Int, condition: Boolean) = require(condition) { "$index" } + +fun DPoint.toObject() = this as Any +fun DPoint.toDPointOrNull() = this as DPoint? +fun Nothing?.toDPointOrNull() = this as DPoint? + +// separate to escape from StackOverflow in regex + +fun equalsChecks1(left: DPoint, right: DPoint) { + require(100, left == right) +} + +fun equalsChecks2(left: DPoint, right: DPoint) { + require(101, left.toObject() == right) +} +fun equalsChecks3(left: DPoint, right: DPoint) { + require(102, left == right.toObject()) +} +fun equalsChecks4(left: DPoint, right: DPoint) { + require(103, left.toObject() == right.toObject()) +} +fun equalsChecks5(left: DPoint, right: DPoint) { + require(104, null == right) +} +fun equalsChecks6(left: DPoint, right: DPoint) { + require(105, left == null) +} +fun equalsChecks7(left: DPoint, right: DPoint) { + require(106, null as Any? == right) +} +fun equalsChecks8(left: DPoint, right: DPoint) { + require(107, left == null as Any?) +} +fun equalsChecks9(left: DPoint, right: DPoint) { + require(108, null.toDPointOrNull() == right) +} +fun equalsChecks10(left: DPoint, right: DPoint) { + require(109, left == null.toDPointOrNull()) +} +fun equalsChecks11(left: DPoint, right: DPoint) { + require(110, left.toDPointOrNull() == right) +} +fun equalsChecks12(left: DPoint, right: DPoint) { + require(111, left == right.toDPointOrNull()) +} + +// 1 BIPUSH 100\n {4}DLOAD 0\n {4}DLOAD 2\n {4}DLOAD 4\n {4}DLOAD 6\n {4}INVOKESTATIC .*equals-impl0.*\n {4}INVOKESTATIC .*require +// 1 BIPUSH 101\n {4}DLOAD 0\n {4}DLOAD 2\n {4}.*toObject.*\n {4}DLOAD 4\n {4}DLOAD 6\n {4}.*box-impl.*\n {4}INVOKESTATIC .*Intrinsics.areEqual.*\n {4}INVOKESTATIC .*require +// 1 BIPUSH 102\n {4}DLOAD 0\n {4}DLOAD 2\n {4}DLOAD 4\n {4}DLOAD 6\n {4}.*toObject.*\n {4}INVOKESTATIC .*equals-impl .*\n {4}INVOKESTATIC .*require +// 1 BIPUSH 103\n {4}DLOAD 0\n {4}DLOAD 2\n {4}.*toObject.*\n {4}DLOAD 4\n {4}DLOAD 6\n {4}.*toObject.*\n {4}INVOKESTATIC .*Intrinsics.areEqual.*\n {4}INVOKESTATIC .*require +// 1 BIPUSH 104\n {4}ICONST_0\n {4}INVOKESTATIC .*require +// 1 BIPUSH 105\n {4}DLOAD 0\n {4}DLOAD 2\n {4}ACONST_NULL\n {4}INVOKESTATIC .*equals-impl .*\n {4}INVOKESTATIC .*require +// 1 BIPUSH 106\n {4}ACONST_NULL\n {4}DLOAD 4\n {4}DLOAD 6\n {4}.*box.*\n {4}INVOKESTATIC .*Intrinsics.areEqual.*\n {4}INVOKESTATIC .*require +// 1 BIPUSH 107\n {4}DLOAD 0\n {4}DLOAD 2\n {4}ACONST_NULL\n {4}INVOKESTATIC .*equals-impl .*\n {4}INVOKESTATIC .*require +// 1 BIPUSH 108\n {4}ACONST_NULL\n {4}.*toDPointOrNull.*\n {4}ASTORE.*\n {4}ALOAD.*\n {4}DUP\n {4}IFNONNULL.*(\n {3}([^b\n]|b[^o\n]|bo[^x\n]|box-impl-\d)+)*\n {4}INVOKESTATIC .*require +// 1 BIPUSH 109\n {4}DLOAD 0\n {4}DLOAD 2\n {4}ACONST_NULL\n {4}.*toDPointOrNull.*\n {4}INVOKESTATIC .*equals-impl .*\n {4}INVOKESTATIC .*require +// 1 BIPUSH 110\n {4}DLOAD 0\n {4}DLOAD 2\n {4}.*toDPointOrNull.*\n {4}ASTORE.*\n {4}ALOAD.*\n {4}DUP\n {4}IFNONNULL.*(\n {3}([^b\n]|b[^o\n]|bo[^x\n]|box-impl-\d)+)*\n {4}INVOKESTATIC .*require +// 1 BIPUSH 111\n {4}DLOAD 0\n {4}DLOAD 2\n {4}DLOAD 4\n {4}DLOAD 6\n {4}.*toDPointOrNull.*\n {4}INVOKESTATIC .*equals-impl .*\n {4}INVOKESTATIC .*require diff --git a/compiler/testData/codegen/bytecodeText/valueClasses/mfvcDeclaration.kt b/compiler/testData/codegen/bytecodeText/valueClasses/mfvcDeclaration.kt new file mode 100644 index 00000000000..dbb658f8223 --- /dev/null +++ b/compiler/testData/codegen/bytecodeText/valueClasses/mfvcDeclaration.kt @@ -0,0 +1,76 @@ +// CHECK_BYTECODE_LISTING +// WITH_STDLIB +// TARGET_BACKEND: JVM_IR +// WORKS_WHEN_VALUE_CLASS +// LANGUAGE: +ValueClasses + +@JvmInline +value class A(val x: List) + +@JvmInline +value class B(val x: UInt) + +@JvmInline +value class C(val x: Int, val y: B, val z: String = "3") + +@JvmInline +value class D(val x: C) { + constructor(x: Int, y: UInt, z: Int) : this(C(x, B(y), z.toString())) + + init { + println(x.x) + } +} + +class Regular(private val x: D) { + fun privateAccess() { + listOf(x.x.x) + listOf(x.x) + listOf(x) + } +} + +fun functionWithoutBoxes(x: D, y: D) { + var z: D = x + val t: D = D(C(1, B(3U), "4")) + z = t + require(z == y) +} + +// 2 public static toString-impl\(IILjava/lang/String;\)Ljava/lang/String; +// 2 INVOKESTATIC C.toString-impl \(IILjava/lang/String;\)Ljava/lang/String; +// 1 INVOKESTATIC D.toString-impl \(IILjava/lang/String;\)Ljava/lang/String; +// 2 public static hashCode-impl\(IILjava/lang/String;\)I +// 2 INVOKESTATIC C.hashCode-impl \(IILjava/lang/String;\)I +// 1 INVOKESTATIC D.hashCode-impl \(IILjava/lang/String;\)I +// 2 public static equals-impl\(IILjava/lang/String;Ljava/lang/Object;\)Z +// 2 public final static equals-impl0\(IILjava/lang/String;IILjava/lang/String;\)Z +// 1 public final static constructor-impl\(III\)LD; +// 2 public final static constructor-impl\(IILjava/lang/String;\)V +// 2 INVOKESTATIC D.constructor-impl \(IILjava/lang/String;\)V +// 2 INVOKESTATIC C.constructor-impl \(IILjava/lang/String;\)V +// 0 public final getX\(\)LC; +// 1 public final synthetic unbox-impl-0-0\(\)I +// 1 public final synthetic unbox-impl-0-1\(\)I +// 1 public final synthetic unbox-impl-0-2\(\)Ljava/lang/String; +// 2 private synthetic \(IILjava/lang/String;\)V +// 1 public final static synthetic box-impl\(IILjava/lang/String;\)LD; +// 1 public final static synthetic box-impl\(IILjava/lang/String;\)LC; +// 1 public final synthetic unbox-impl-0\(\)I +// 1 public final synthetic unbox-impl-1\(\)I +// 1 public final synthetic unbox-impl-2\(\)Ljava/lang/String; +// 1 private final I field-0-0\n +// 1 private final I field-0-1\n +// 1 private final Ljava/lang/String; field-0-2\n +// 0 private final LC; (field.*)x\n +// 1 private final I x\n +// 1 private final I field-0\n +// 1 private final I field-1\n +// 1 private final Ljava/lang/String; field-2\n +// 1 INVOKESPECIAL C. \(IILjava/lang/String;\)V +// 1 INVOKESPECIAL D. \(IILjava/lang/String;\)V +// 2 INVOKESTATIC D.box-impl \(IILjava/lang/String;\)LD; +// 2 INVOKESTATIC C.box-impl \(IILjava/lang/String;\)LC; +// 1 public final static functionWithoutBoxes-GPBa7dw\(IILjava/lang/String;IILjava/lang/String;\)V +// 0 functionWithoutBoxes.*(\n {3}.*)*(\n {4}(NEW [ABCD]|.*(box|[ABCD]\.|LA;|LB;|LC;|LD;))) +// 1 privateAccess.*(\n .+)*(\n GETFIELD Regular\.x-0-0 : I)(\n .+)*(\n INVOKEVIRTUAL Regular\.getX-0 \(\)LC;)(\n .+)*(\n INVOKESPECIAL Regular\.getX \(\)LD;) diff --git a/compiler/testData/codegen/bytecodeText/valueClasses/mfvcReassignments.kt b/compiler/testData/codegen/bytecodeText/valueClasses/mfvcReassignments.kt new file mode 100644 index 00000000000..13430de8ad9 --- /dev/null +++ b/compiler/testData/codegen/bytecodeText/valueClasses/mfvcReassignments.kt @@ -0,0 +1,71 @@ +// CHECK_BYTECODE_LISTING +// WITH_STDLIB +// TARGET_BACKEND: JVM_IR +// WORKS_WHEN_VALUE_CLASS +// LANGUAGE: +ValueClasses + +@JvmInline +value class DPoint(val x: Double, val y: Double) + +class Box(var value: DPoint) + +fun supplier(index: Int) {} // to make usage of the argument +fun supplier(index: Int, x: DPoint) {} // to make usage of the argument + +fun reassignVariable(x: DPoint, box: Box) { + supplier(100) + var p = DPoint(1.0, 2.0) // should not use temporary variables + supplier(101, p) + p = p // should not use temporary variables + supplier(102, p) + p = DPoint(3.0, 4.0) // should use tempVars + supplier(103, p) + p = x // should not use temporary variables + supplier(104, p) + p = box.value // should use temporary variables + supplier(105, p) + p = listOf(p)[0] // should use temporary variables + supplier(106, p) +} + +fun reassignField(x: DPoint, box: Box) { + supplier(107) + val p = DPoint(5.0, 6.0) + supplier(108, p) + var b = Box(p) // should not use temporary variables + supplier(109) + b.value = b.value // should not use temporary variables + supplier(110) + b.value = DPoint(7.0, 8.0) // should use tempVars + supplier(111) + b.value = x // should not use temporary variables + supplier(112) + b.value = box.value // should not use temporary variables + supplier(113) + b.value = listOf(p)[0] // should use temporary variables + supplier(114) +} + +// 1 100(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){2}101 +// 0 100(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){3}101 +// 1 101(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){2}102 +// 0 101(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){3}102 +// 1 102(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){4}103 +// 0 102(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){5}103 +// 1 103(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){2}104 +// 0 103(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){3}104 +// 1 104(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){4}105 +// 0 104(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){5}105 +// 1 105(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){4}106 +// 0 105(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){5}106 + +// 1 107(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){2}108 +// 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)*([DA]STORE(\D|\d\D|\d\d\D)*){1}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)*([DA]STORE(\D|\d\D|\d\d\D)*){1}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 diff --git a/compiler/testData/codegen/bytecodeText/valueClasses/passingMFVC2Functions.kt b/compiler/testData/codegen/bytecodeText/valueClasses/passingMFVC2Functions.kt new file mode 100644 index 00000000000..1bb0077f41b --- /dev/null +++ b/compiler/testData/codegen/bytecodeText/valueClasses/passingMFVC2Functions.kt @@ -0,0 +1,49 @@ +// CHECK_BYTECODE_LISTING +// WITH_STDLIB +// TARGET_BACKEND: JVM_IR +// WORKS_WHEN_VALUE_CLASS +// LANGUAGE: +ValueClasses + +@JvmInline +value class DPoint(val x: Double, val y: Double) + +fun acceptBoxed(x: Any?) {} +fun acceptFlattened(x: DPoint) {} +fun returnBoxed() = DPoint(3.0, 4.0) + +fun testFlattened2Boxed() { + acceptBoxed(DPoint(1.0, 2.0)) +} + +fun testBoxed2Boxed() { + acceptBoxed(returnBoxed()) +} + +fun testFlattened2Flattened() { + acceptFlattened(DPoint(1.0, 2.0)) +} + +fun testBoxed2Flattened() { + acceptFlattened(returnBoxed()) +} + +fun testIgnoredFlattened() { + DPoint(1.0, 2.0) + DPoint(1.0, 2.0) +} + +fun testIgnoredBoxed() { + returnBoxed() +} + +// 1 testFlattened2Boxed\(\)V(\n {3}.*)*((\n {3}.*box-impl .*)(\n {3}.*)*){1} +// 0 testFlattened2Boxed\(\)V(\n {3}.*)*((\n {3}.*box-impl.*)(\n {3}.*)*){2} +// 0 testBoxed2Boxed\(\)V(\n {3}.*)*((\n {3}.*(box-impl|DSTORE|DLOAD).*)(\n {3}.*)*){1} +// 0 testFlattened2Flattened\(\)V(\n {3}.*)*((\n {3}.*box-impl.*)(\n {3}.*)*){1} +// 1 testFlattened2Flattened\(\)V(\n {3}.*)*((\n {3}.*DSTORE.*)(\n {3}.*)*){2} +// 0 testFlattened2Flattened\(\)V(\n {3}.*)*((\n {3}.*DSTORE.*)(\n {3}.*)*){3} +// 0 testBoxed2Flattened\(\)V(\n {3}.*)*((\n {3}.*box-impl .*)(\n {3}.*)*){1} +// 1 testBoxed2Flattened\(\)V(\n {3}.*)*((\n {3}.*unbox-impl.*)(\n {3}.*)*){2} +// 0 testBoxed2Flattened\(\)V(\n {3}.*)*((\n {3}.*unbox-impl.*)(\n {3}.*)*){3} +// 0 testIgnoredFlattened\(\)V(\n {3}.*)*((\n {3}.*box-impl.*)(\n {3}.*)*){1} +// 0 testIgnoredBoxed\(\)V(\n {3}.*)*((\n {3}.*box-impl.*)(\n {3}.*)*){1} diff --git a/compiler/testData/codegen/bytecodeText/valueClasses/regularClassWithMFVC.kt b/compiler/testData/codegen/bytecodeText/valueClasses/regularClassWithMFVC.kt new file mode 100644 index 00000000000..548ecf738bb --- /dev/null +++ b/compiler/testData/codegen/bytecodeText/valueClasses/regularClassWithMFVC.kt @@ -0,0 +1,144 @@ +// CHECK_BYTECODE_LISTING +// WITH_STDLIB +// TARGET_BACKEND: JVM_IR +// WORKS_WHEN_VALUE_CLASS +// LANGUAGE: +ValueClasses + +@JvmInline +value class DPoint(val x: Double, val y: Double) { + val opposite: DPoint + get() = DPoint(-x, -y) +} + +class DSegment(var p1: DPoint, var p2: DPoint) { + + val center: DPoint + get() = DPoint(p1.x / 2 + p2.x / 2, p1.y / 2 + p2.y / 2) + + var notImplemented: DPoint + get() = TODO() + set(_) = TODO() + + var point1WithBackingFieldAndDefaultGetter: DPoint = p1 + var point2WithBackingFieldAndDefaultGetter: DPoint = p1 + get() = field + set(value) { + field = value + require("${2 + 2}" == "4") + } + + var pointWithBackingFieldAndCustomGetter: DPoint = p1 + get() = field.also { require("${2 + 2}" == "4") } + set(value) { + field = value + require("${2 + 2}" == "4") + } + + init { + p1 = p1 + } +} + +fun tryGetSegment(segment: DSegment) { + segment.p1 + segment.p1.x + segment.p1.y + segment.p2 + segment.p2.x + segment.p2.y + segment.center + segment.center.x + segment.center.y + segment.notImplemented + segment.notImplemented.x + segment.notImplemented.y + segment.point1WithBackingFieldAndDefaultGetter + segment.point1WithBackingFieldAndDefaultGetter.x + segment.point1WithBackingFieldAndDefaultGetter.y + segment.point2WithBackingFieldAndDefaultGetter + segment.point2WithBackingFieldAndDefaultGetter.x + segment.point2WithBackingFieldAndDefaultGetter.y + segment.pointWithBackingFieldAndCustomGetter + segment.pointWithBackingFieldAndCustomGetter.x + segment.pointWithBackingFieldAndCustomGetter.y +} + +fun trySetSegment(segment: DSegment) { + segment.notImplemented = segment.p1 + segment.point1WithBackingFieldAndDefaultGetter = segment.p1 + segment.point2WithBackingFieldAndDefaultGetter = segment.p1 + segment.pointWithBackingFieldAndCustomGetter = segment.p1 + segment.p1 = segment.p1 + segment.p2 = segment.p2 +} + +// 0 public final getOpposite\(\)LDPoint; +// 1 public final static getOpposite-impl\(DD\)LDPoint; +// 1 private D p1-0 +// 1 private D p1-1 +// 0 private DPoint; p1 +// 1 private D p2-0 +// 1 private D p2-1 +// 0 private DPoint; p2 +// 1 private D point1WithBackingFieldAndDefaultGetter-0 +// 1 private D point1WithBackingFieldAndDefaultGetter-1 +// 0 private DPoint; point1WithBackingFieldAndDefaultGetter +// 1 private D point2WithBackingFieldAndDefaultGetter-0 +// 1 private D point2WithBackingFieldAndDefaultGetter-1 +// 0 private DPoint; point2WithBackingFieldAndDefaultGetter +// 1 private D pointWithBackingFieldAndCustomGetter-0 +// 1 private D pointWithBackingFieldAndCustomGetter-1 +// 0 private DPoint; pointWithBackingFieldAndCustomGetter +// 0 private DPoint; notImplemented +// 0 private D notImplemented +// 0 private DPoint; center +// 0 private D center +// 1 public \(DDDD\)V +// 0 public \(DDDD\)V.*(\n {3}.*)*(\n {4}.*box) +// 1 public final getP1\(\)LDPoint; +// 1 public final setP1-sUp7gFk\(DD\)V +// 1 public final getP2\(\)LDPoint; +// 1 public final setP2-sUp7gFk\(DD\)V +// 1 public final getCenter\(\)LDPoint; +// 1 public final getNotImplemented\(\)LDPoint; +// 1 public final setNotImplemented-sUp7gFk\(DD\)V +// 1 public final getPoint1WithBackingFieldAndDefaultGetter\(\)LDPoint; +// 1 public final setPoint1WithBackingFieldAndDefaultGetter-sUp7gFk\(DD\)V +// 1 public final getPoint2WithBackingFieldAndDefaultGetter\(\)LDPoint; +// 1 public final setPoint2WithBackingFieldAndDefaultGetter-sUp7gFk\(DD\)V +// 1 public final getPointWithBackingFieldAndCustomGetter\(\)LDPoint; +// 1 public final setPointWithBackingFieldAndCustomGetter-sUp7gFk\(DD\)V +// 1 public final synthetic getP1-0\(\)D +// 1 public final synthetic getP1-1\(\)D +// 1 public final synthetic getP2-0\(\)D +// 1 public final synthetic getP2-1\(\)D +// 1 public final synthetic getPoint1WithBackingFieldAndDefaultGetter-0\(\)D +// 1 public final synthetic getPoint1WithBackingFieldAndDefaultGetter-1\(\)D +// 1 public final synthetic getPoint2WithBackingFieldAndDefaultGetter-0\(\)D +// 1 public final synthetic getPoint2WithBackingFieldAndDefaultGetter-1\(\)D +// 0 public final getCenter\$ +// 0 public final getNotImplemented\$ +// 0 public final getPointWithBackingFieldAndCustomGetter\$ +// 0 ^ {2}\b.*get.*\$.*(\n {3}.*)*(\n {4}.*\.box) +// 1 tryGetSegment\(LDSegment;\)V +// 0 try[GS]etSegment\(LDSegment;\)V.*(\n {3}.*)*(\n {4}.*\.box) +// 1 tryGetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}.*LDPoint;)){7} +// 0 tryGetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}.*LDPoint;)){8} +// 0 trySetSegment\(LDSegment;\)V.*(\n {3}.*)*(\n {4}.*LDPoint;) +// 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-sUp7gFk \(DD\)V)){2} +// 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-sUp7gFk \(DD\)V)){2} +// 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-sUp7gFk \(DD\)V)){2} +// 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-sUp7gFk \(DD\)V)){2} +// 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-sUp7gFk \(DD\)V)){2} +// 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-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.*-[01] \(\)D)){14} +// 0 tryGetSegment\(LDSegment;\)V.*((\n {3}.*)*?(\n {4}INVOKEVIRTUAL DSegment\.get.*-[01] \(\)D)){15} +// 1 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*?(\n {4}INVOKEVIRTUAL DSegment\.get.*-[01] \(\)D)){12} +// 0 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*?(\n {4}INVOKEVIRTUAL DSegment\.get.*-[01] \(\)D)){13} diff --git a/compiler/testData/codegen/bytecodeText/valueClasses/tryExpressions.kt b/compiler/testData/codegen/bytecodeText/valueClasses/tryExpressions.kt new file mode 100644 index 00000000000..dca322fc7a7 --- /dev/null +++ b/compiler/testData/codegen/bytecodeText/valueClasses/tryExpressions.kt @@ -0,0 +1,38 @@ +// CHECK_BYTECODE_LISTING +// WITH_STDLIB +// TARGET_BACKEND: JVM_IR +// WORKS_WHEN_VALUE_CLASS +// LANGUAGE: +ValueClasses + +@JvmInline +value class DPoint(val x: Double, val y: Double) + +fun tryExpr() = try { + DPoint(0.0, 1.0) +} catch(_: Throwable) { + DPoint(2.0, 3.0) +} finally { + DPoint(4.0, 5.0) +} + +fun tryBody() { + try { + DPoint(0.0, 1.0) + } catch(_: Throwable) { + DPoint(2.0, 3.0) + } finally { + DPoint(4.0, 5.0) + } + val x: DPoint = try { + DPoint(0.0, 1.0) + } catch(_: Throwable) { + DPoint(2.0, 3.0) + } finally { + DPoint(4.0, 5.0) + } +} + + +// 1 tryExpr.*(\n .*)(\n .*)*(\n .*box-impl.*)(\n .*)*(\n .*box-impl.*) +// 0 tryExpr.*(\n .*)(\n .*)*(\n .*box-impl.*)(\n .*)*(\n .*box-impl.*)(\n .*)*(\n .*box-impl.*) +// 0 tryBody.*(\n .*)*(\n .*box-impl.*) diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BytecodeTextTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BytecodeTextTestGenerated.java index 20c86bb9889..74cd55233c3 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BytecodeTextTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BytecodeTextTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.test.runners.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.utils.TransformersFunctions; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; @@ -5455,6 +5456,16 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } } + @Nested + @TestMetadata("compiler/testData/codegen/bytecodeText/valueClasses") + @TestDataPath("$PROJECT_ROOT") + public class ValueClasses { + @Test + public void testAllFilesPresentInValueClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + } + } + @Nested @TestMetadata("compiler/testData/codegen/bytecodeText/varargs") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java index 8ac5d4bf3a9..947d788795e 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java @@ -50171,11 +50171,71 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/valueClasses/classFlattening.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } + @Test + @TestMetadata("complex.kt") + public void testComplex() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/complex.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("conditionalExpressions.kt") + public void testConditionalExpressions() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/conditionalExpressions.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + @Test @TestMetadata("equality.kt") public void testEquality() throws Exception { runTest("compiler/testData/codegen/box/valueClasses/equality.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } + + @Test + @TestMetadata("forStatement.kt") + public void testForStatement() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/forStatement.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("mfvcFieldInitializationOrder.kt") + public void testMfvcFieldInitializationOrder() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/mfvcFieldInitializationOrder.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("overrides.kt") + public void testOverrides() throws Exception { + 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("overrides_typeParameters.kt") + public void testOverrides_typeParameters() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/overrides_typeParameters.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("throwingMFVCReassignments.kt") + public void testThrowingMFVCReassignments() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/throwingMFVCReassignments.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("tryExpressions.kt") + public void testTryExpressions() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/tryExpressions.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("visibility.kt") + public void testVisibility() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/visibility.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } } @Nested diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBytecodeTextTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBytecodeTextTestGenerated.java index b4079bee42e..8050b901bc0 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBytecodeTextTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBytecodeTextTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.test.runners.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.utils.TransformersFunctions; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; @@ -5779,6 +5780,58 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } } + @Nested + @TestMetadata("compiler/testData/codegen/bytecodeText/valueClasses") + @TestDataPath("$PROJECT_ROOT") + public class ValueClasses { + @Test + public void testAllFilesPresentInValueClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("conditionalExpressions.kt") + public void testConditionalExpressions() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/valueClasses/conditionalExpressions.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("equalsBoxTest.kt") + public void testEqualsBoxTest() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/valueClasses/equalsBoxTest.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("mfvcDeclaration.kt") + public void testMfvcDeclaration() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/valueClasses/mfvcDeclaration.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("mfvcReassignments.kt") + public void testMfvcReassignments() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/valueClasses/mfvcReassignments.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("passingMFVC2Functions.kt") + public void testPassingMFVC2Functions() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/valueClasses/passingMFVC2Functions.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("regularClassWithMFVC.kt") + public void testRegularClassWithMFVC() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/valueClasses/regularClassWithMFVC.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + + @Test + @TestMetadata("tryExpressions.kt") + public void testTryExpressions() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/valueClasses/tryExpressions.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + } + } + @Nested @TestMetadata("compiler/testData/codegen/bytecodeText/varargs") @TestDataPath("$PROJECT_ROOT")