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 816ac95141a..5b18f7bd2bb 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,16 +301,14 @@ private fun MethodInsnNode.isInlineClassBoxingMethodDescriptor(state: Generation if (name != KotlinTypeMapper.BOX_JVM_METHOD_NAME) return false val ownerType = Type.getObjectType(owner) - val unboxedType = unboxedTypeOfInlineClass(ownerType, state) ?: return false - return desc == Type.getMethodDescriptor(ownerType, unboxedType) + return desc == Type.getMethodDescriptor(ownerType, unboxedTypeOfInlineClass(ownerType, state)) } private fun MethodInsnNode.isInlineClassUnboxingMethodDescriptor(state: GenerationState): Boolean { if (name != KotlinTypeMapper.UNBOX_JVM_METHOD_NAME) return false val ownerType = Type.getObjectType(owner) - val unboxedType = unboxedTypeOfInlineClass(ownerType, state) ?: return false - return desc == Type.getMethodDescriptor(unboxedType) + return desc == Type.getMethodDescriptor(unboxedTypeOfInlineClass(ownerType, state)) } 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 d21690b5ffa..54b8e74715c 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 @@ -50189,71 +50189,11 @@ 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 c4bd88a01fa..ce3303b8985 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,7 +8,6 @@ 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; @@ -5780,58 +5779,6 @@ 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 caf15c4b8f7..b3a89cfc0dd 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,7 +346,6 @@ 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 cae3d0ae2b8..3e2253e62bd 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,7 +294,6 @@ 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 1333b221491..4233c25df5f 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,10 +37,9 @@ 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 / value class 'hashCode'? + // TODO generate or lower IR for data class / inline 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 ca0fbf7d257..d7ffe0f2f25 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,7 +309,6 @@ 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 a1cd62c548e..eb099727bfe 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.* -import org.jetbrains.kotlin.backend.jvm.MemoizedMultiFieldValueClassReplacements.RemappedParameter.MultiFieldValueClassMapping -import org.jetbrains.kotlin.backend.jvm.MemoizedMultiFieldValueClassReplacements.RemappedParameter.RegularMapping +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.ir.* import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.descriptors.DescriptorVisibilities @@ -32,7 +32,6 @@ 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 @@ -113,7 +112,7 @@ internal val bridgePhase = makeIrFilePhase( ::BridgeLowering, name = "Bridge", description = "Generate bridges", - prerequisite = setOf(jvmInlineClassPhase, jvmMultiFieldValueClassPhase, inheritedDefaultMethodsOnClassesPhase) + prerequisite = setOf(jvmInlineClassPhase) ) internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass, IrElementTransformerVoid() { @@ -235,7 +234,6 @@ 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. @@ -264,7 +262,6 @@ 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. @@ -434,11 +431,6 @@ 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. @@ -494,11 +486,6 @@ 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 -> @@ -623,132 +610,22 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass target: IrSimpleFunction, superQualifierSymbol: IrClassSymbol? = null ) = - 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) + 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) + } + ) } - }) - }.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) - } + }, + bridge.returnType.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 c82836a7760..120cae230f1 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,11 +12,7 @@ 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 @@ -95,7 +91,6 @@ 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( @@ -105,50 +100,15 @@ private class InheritedDefaultMethodsOnClassesLowering(val context: JvmBackendCo } passTypeArgumentsFrom(irFunction, offset = superMethod.parentAsClass.typeParameters.size) + var offset = 0 irFunction.dispatchReceiverParameter?.let { - 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++])) - } - } + putValueArgument( + offset++, + irGet(it).reinterpretAsDispatchReceiverOfType(superClassType) + ) } + 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 75f87f0a1e7..f7abcb4d358 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 78552284b1d..500a8c65f83 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,6 +9,8 @@ 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 @@ -22,7 +24,6 @@ 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 @@ -30,6 +31,7 @@ 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 @@ -41,9 +43,7 @@ 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, jvmMultiFieldValueClassPhase - ), + prerequisite = setOf(forLoopsPhase, jvmBuiltInsPhase, collectionStubMethodLowering, singleAbstractMethodPhase), ) /** @@ -58,15 +58,73 @@ private class JvmInlineClassLowering(context: JvmBackendContext) : JvmValueClass override val replacements: MemoizedValueClassAbstractReplacements get() = context.inlineClassReplacements - private val valueMap = mutableMapOf() + override fun IrClass.isSpecificLoweringLogicApplicable(): Boolean = isSingleFieldValueClass - override fun addBindingsFor(original: IrFunction, replacement: IrFunction) { - for ((param, newParam) in original.explicitParameters.zip(replacement.explicitParameters)) { - valueMap[param.symbol] = newParam - } + 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 createBridgeDeclaration(source: IrSimpleFunction, replacement: IrSimpleFunction, mangledName: Name): IrSimpleFunction = + 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) = context.irFactory.buildFun { updateFrom(source) name = mangledName @@ -81,59 +139,7 @@ private class JvmInlineClassLowering(context: JvmBackendContext) : JvmValueClass copyAttributes(source) } - 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) { + private fun createBridgeBody(source: IrSimpleFunction, target: IrSimpleFunction) { source.body = context.createIrBuilder(source.symbol, source.startOffset, source.endOffset).run { irExprBody(irCall(target).apply { passTypeArgumentsFrom(source) @@ -147,7 +153,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 transformSecondaryConstructorFlat(constructor: IrConstructor, replacement: IrSimpleFunction): List { + override fun transformConstructorFlat(constructor: IrConstructor, replacement: IrSimpleFunction): List { replacement.valueParameters.forEach { it.transformChildrenVoid() } replacement.body = context.createIrBuilder(replacement.symbol, replacement.startOffset, replacement.endOffset).irBlockBody( replacement @@ -205,6 +211,12 @@ 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<*>, @@ -275,8 +287,6 @@ 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. @@ -353,7 +363,6 @@ private class JvmInlineClassLowering(context: JvmBackendContext) : JvmValueClass .specializeEqualsCall(expression.getValueArgument(0)!!, expression.getValueArgument(1)!!) ?: expression } - else -> super.visitCall(expression) } @@ -411,7 +420,7 @@ private class JvmInlineClassLowering(context: JvmBackendContext) : JvmValueClass return super.visitSetValue(expression) } - fun buildPrimaryInlineClassConstructor(valueClass: IrClass, irConstructor: IrConstructor) { + override fun buildPrimaryValueClassConstructor(valueClass: IrClass, irConstructor: IrConstructor) { // Add the default primary constructor valueClass.addConstructor { updateFrom(irConstructor) @@ -456,7 +465,7 @@ private class JvmInlineClassLowering(context: JvmBackendContext) : JvmValueClass valueClass.declarations += function } - fun buildBoxFunction(valueClass: IrClass) { + override fun buildBoxFunction(valueClass: IrClass) { val function = context.inlineClassReplacements.getBoxFunction(valueClass) with(context.createIrBuilder(function.symbol)) { function.body = irExprBody( @@ -469,6 +478,10 @@ 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) @@ -481,7 +494,7 @@ private class JvmInlineClassLowering(context: JvmBackendContext) : JvmValueClass irClass.declarations += function } - fun buildSpecializedEqualsMethod(valueClass: IrClass) { + override 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 28d7122f7a4..3342d36be91 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,646 +5,45 @@ package org.jetbrains.kotlin.backend.jvm.lower -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.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.MemoizedValueClassAbstractReplacements +import org.jetbrains.kotlin.backend.jvm.isMultiFieldValueClassFieldGetter 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) { - 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 + override val replacements: MemoizedValueClassAbstractReplacements get() = context.multiFieldValueClassReplacements override fun IrClass.isSpecificLoweringLogicApplicable(): Boolean = isMultiFieldValueClass - override val specificMangle: SpecificMangle - get() = SpecificMangle.MultiField + override fun IrFunction.isSpecificFieldGetter(): Boolean = isMultiFieldValueClassFieldGetter - 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 transformSimpleFunctionFlat(function: IrSimpleFunction, replacement: IrSimpleFunction): List { + TODO() } - 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 buildPrimaryValueClassConstructor(valueClass: IrClass, irConstructor: IrConstructor) { + 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 buildBoxFunction(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 buildUnboxFunctions(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 buildSpecializedEqualsMethod(valueClass: IrClass) { + TODO("Not yet implemented") } - override fun transformSecondaryConstructorFlat(constructor: IrConstructor, replacement: IrSimpleFunction): List { - for (param in replacement.valueParameters) { - param.transformChildrenVoid() - } + override fun addJvmInlineAnnotation(valueClass: IrClass) = Unit - 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 } + @Suppress("UNUSED_PARAMETER") + override fun transformConstructorFlat(constructor: IrConstructor, replacement: IrSimpleFunction): List { + TODO() } override fun visitFunctionReference(expression: IrFunctionReference): IrExpression { @@ -653,675 +52,27 @@ private class JvmMultiFieldValueClassLowering(context: JvmBackendContext) : JvmV } override fun visitFunctionAccess(expression: IrFunctionAccessExpression): IrExpression { - 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) - } - } - } + // todo implement + return super.visitFunctionAccess(expression) } override fun visitCall(expression: IrCall): IrExpression { - 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) - } - } - } + // todo implement 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 { - expression.receiver = expression.receiver?.transform(this, null) - with(valueDeclarationsRemapper) { - return context.createIrBuilder(expression.symbol).irBlock { - addReplacement(expression) ?: return expression - } - } + // todo implement + return super.visitGetField(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 visitGetValue(expression: IrGetValue): IrExpression { + // todo implement + return super.visitGetValue(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) - } + override fun visitSetValue(expression: IrSetValue): IrExpression { + // todo implement + return super.visitSetValue(expression) } - - 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) -} +} \ No newline at end of file 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 04acfabadee..71f054ba1ba 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?.getRequiresMangling(includeInline = true, includeMFVC = false) == true || + getter.extensionReceiverParameter?.type?.requiresMangling == 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 7f7e6fb3324..9a0453c82ed 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,32 +8,70 @@ 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.common.pop -import org.jetbrains.kotlin.backend.common.push -import org.jetbrains.kotlin.backend.jvm.* +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.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 override fun visitClassNew(declaration: IrClass): IrStatement + abstract fun IrFunction.isSpecificFieldGetter(): Boolean - abstract fun handleSpecificNewClass(declaration: IrClass) + 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 + } protected fun transformFunctionFlat(function: IrFunction): List? { if (function is IrConstructor && function.isPrimary && function.constructedClass.isSpecificLoweringLogicApplicable()) { @@ -41,21 +79,7 @@ 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 @@ -82,50 +106,30 @@ internal abstract class JvmValueClassAbstractLowering(val context: JvmBackendCon addBindingsFor(function, replacement) return when (function) { is IrSimpleFunction -> transformSimpleFunctionFlat(function, replacement) - is IrConstructor -> transformSecondaryConstructorFlat(function, replacement) + is IrConstructor -> transformConstructorFlat(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 transformSecondaryConstructorFlat(constructor: IrConstructor, replacement: IrSimpleFunction): List + protected abstract fun transformConstructorFlat(constructor: IrConstructor, 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 transformSimpleFunctionFlat(function: IrSimpleFunction, replacement: IrSimpleFunction): List - // 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 buildPrimaryValueClassConstructor(valueClass: IrClass, irConstructor: IrConstructor) - val bridgeFunction = createBridgeFunction(function, replacement) + protected abstract fun buildBoxFunction(valueClass: IrClass) - return listOf(replacement, bridgeFunction) - } + protected abstract fun buildUnboxFunctions(valueClass: IrClass) - abstract fun keepOldFunctionInsteadOfNew(function: IrFunction): Boolean + protected abstract fun buildSpecializedEqualsMethod(valueClass: IrClass) // todo hashCode + + protected abstract fun addJvmInlineAnnotation(valueClass: IrClass) final override fun visitReturn(expression: IrReturn): IrExpression { expression.returnTargetSymbol.owner.safeAs()?.let { target -> @@ -133,10 +137,7 @@ internal abstract class JvmValueClassAbstractLowering(val context: JvmBackendCon if (suffix != null && target.name.asString().endsWith(suffix)) return super.visitReturn(expression) - replacements.run { - if (keepOldFunctionInsteadOfNew(target)) return@run null - getReplacementFunction(target) ?: if (target is IrConstructor) getReplacementForRegularClassConstructor(target) else null - }?.let { + replacements.getReplacementFunction(target)?.let { return context.createIrBuilder(it.symbol, expression.startOffset, expression.endOffset).irReturn( expression.value.transform(this, null) ) @@ -171,65 +172,4 @@ 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 b3f5ae9776d..95fb7ccdf76 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.isValue && hasMangledParameters() && + if (!DescriptorVisibilities.isPrivate(visibility) && !constructedClass.isSingleFieldValueClass && 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 72ecec9d46a..3f4c48ab267 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.isValue) { + assert(irFunction.constructedClass.isSingleFieldValueClass) { "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)?.isValue != true || irFunction.origin == IrDeclarationOrigin.IR_BUILTINS_STUB)) { + if (suffix == null && ((irFunction.parent as? IrClass)?.isSingleFieldValueClass != true || irFunction.origin == IrDeclarationOrigin.IR_BUILTINS_STUB)) { return irFunction.name } @@ -101,7 +101,7 @@ object InlineClassAbi { ): String? = collectFunctionSignatureForManglingSuffix( useOldMangleRules, - valueParameters.any { it.getRequiresMangling() }, + valueParameters.any { it.requiresMangling }, // 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,28 +124,19 @@ object InlineClassAbi { get() = (this as IrSimpleFunction).correspondingPropertySymbol!!.owner.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 IrType.requiresMangling: Boolean + get() { + val irClass = erasedUpperBound + return irClass.isSingleFieldValueClass && irClass.fqNameWhenAvailable != StandardNames.RESULT_FQ_NAME } -} val IrFunction.fullValueParameterList: List get() = listOfNotNull(extensionReceiverParameter) + valueParameters -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.hasMangledParameters: Boolean + get() = dispatchReceiverParameter != null && parentAsClass.isSingleFieldValueClass || + fullValueParameterList.any { it.type.requiresMangling } || + (this is IrConstructor && constructedClass.isSingleFieldValueClass) val IrFunction.hasMangledReturnType: Boolean get() = returnType.isInlineClassType() && parentClassOrNull?.isFileClass != true @@ -155,12 +146,10 @@ 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 cf56f48a706..fa58f3b88f9 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,8 +143,7 @@ class JvmBackendContext( val inlineClassReplacements = MemoizedInlineClassReplacements(state.functionsWithInlineClassReturnTypesMangled, irFactory, this) - val multiFieldValueClassReplacements = - MemoizedMultiFieldValueClassReplacements(irFactory, this) + val multiFieldValueClassReplacements = MemoizedMultiFieldValueClassReplacements(irFactory, this) val continuationClassesVarsCountByType: MutableMap> = hashMapOf() @@ -198,20 +197,6 @@ 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 b3f88dae703..0ee749810f4 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,8 +251,7 @@ class JvmCachedDeclarations( defaultImplsRedirections.getOrPut(fakeOverride) { assert(fakeOverride.isFakeOverride) val irClass = fakeOverride.parentAsClass - val mfvcReplacementStructure = context.multiFieldValueClassReplacements.bindingNewFunctionToParameterTemplateStructure - val redirectFunction = context.irFactory.buildFun { + context.irFactory.buildFun { origin = JvmLoweredDeclarationOrigin.SUPER_INTERFACE_METHOD_BRIDGE name = fakeOverride.name visibility = fakeOverride.visibility @@ -276,8 +275,6 @@ 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 42a27c6a9ed..fa74ad9706a 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,14 +29,9 @@ 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 0e5d339bbd9..1060c6c1cac 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,26 +5,25 @@ package org.jetbrains.kotlin.backend.jvm -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.backend.jvm.ir.* 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 /** @@ -36,9 +35,10 @@ class MemoizedInlineClassReplacements( context: JvmBackendContext ) : MemoizedValueClassAbstractReplacements(irFactory, context) { private val storageManager = LockBasedStorageManager("inline-class-replacements") + private val propertyMap = ConcurrentHashMap() - val originalFunctionForStaticReplacement: MutableMap = ConcurrentHashMap() - val originalFunctionForMethodReplacement: MutableMap = ConcurrentHashMap() + override val originalFunctionForStaticReplacement: MutableMap = ConcurrentHashMap() + internal val originalFunctionForMethodReplacement: MutableMap = ConcurrentHashMap() /** * Get a replacement for a function or a constructor. @@ -49,9 +49,7 @@ 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.isStaticValueClassReplacement || - it in context.multiFieldValueClassReplacements.bindingNewFunctionToParameterTemplateStructure || - it.origin == JvmLoweredDeclarationOrigin.MULTI_FIELD_VALUE_CLASS_GENERATED_IMPL_METHOD || + it.isStaticInlineClassReplacement || it.origin.isSynthetic && it.origin != IrDeclarationOrigin.SYNTHETIC_GENERATED_SAM_IMPLEMENTATION -> null @@ -66,7 +64,7 @@ class MemoizedInlineClassReplacements( when { it.isRemoveAtSpecialBuiltinStub() -> null - it.isValueClassMemberFakeOverriddenFromJvmDefaultInterfaceMethod() || + it.isInlineClassMemberFakeOverriddenFromJvmDefaultInterfaceMethod() || it.origin == IrDeclarationOrigin.IR_BUILTINS_STUB -> createMethodReplacement(it) else -> @@ -74,8 +72,7 @@ class MemoizedInlineClassReplacements( } // Otherwise, mangle functions with mangled parameters, ignoring constructors - it is IrSimpleFunction && !it.isFromJava() && - (it.hasMangledParameters(includeMFVC = false) || mangleReturnTypes && it.hasMangledReturnType) -> + it is IrSimpleFunction && !it.isFromJava() && (it.hasMangledParameters || mangleReturnTypes && it.hasMangledReturnType) -> createMethodReplacement(it) else -> @@ -83,6 +80,29 @@ 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 @@ -128,7 +148,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/multi-field value classes. + // TODO: Revisit this once we allow user defined equals methods in inline classes. origin = JvmLoweredDeclarationOrigin.INLINE_CLASS_GENERATED_IMPL_METHOD returnType = irBuiltIns.booleanType }.apply { @@ -148,7 +168,7 @@ class MemoizedInlineClassReplacements( } } - override fun createMethodReplacement(function: IrFunction): IrSimpleFunction = + private fun createMethodReplacement(function: IrFunction): IrSimpleFunction = buildReplacement(function, function.origin) { originalFunctionForMethodReplacement[this] = function dispatchReceiverParameter = function.dispatchReceiverParameter?.copyTo(this, index = -1) @@ -164,14 +184,9 @@ class MemoizedInlineClassReplacements( it.defaultValue = parameter.defaultValue?.patchDeclarationParents(this) } } - context.multiFieldValueClassReplacements.run { - bindingNewFunctionToParameterTemplateStructure[function]?.also { - bindingNewFunctionToParameterTemplateStructure[this@buildReplacement] = it - } - } } - override fun createStaticReplacement(function: IrFunction): IrSimpleFunction = + private fun createStaticReplacement(function: IrFunction): IrSimpleFunction = buildReplacement(function, JvmLoweredDeclarationOrigin.STATIC_INLINE_CLASS_REPLACEMENT, noFakeOverride = true) { originalFunctionForStaticReplacement[this] = function @@ -204,11 +219,6 @@ class MemoizedInlineClassReplacements( } } valueParameters = newValueParameters - context.multiFieldValueClassReplacements.run { - bindingNewFunctionToParameterTemplateStructure[function]?.also { - bindingNewFunctionToParameterTemplateStructure[this@buildReplacement] = it - } - } } private fun buildReplacement( @@ -236,7 +246,8 @@ class MemoizedInlineClassReplacements( noFakeOverride: Boolean, useOldManglingScheme: Boolean, body: IrFunction.() -> Unit, - ): IrSimpleFunction = commonBuildReplacementInner(function, noFakeOverride, body) { + ): IrSimpleFunction = irFactory.buildFun { + updateFrom(function) 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 @@ -249,10 +260,52 @@ 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) - override val getReplacementForRegularClassConstructor: (IrConstructor) -> IrConstructor? = alwaysNull() + 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 replaceOverriddenSymbols: (IrSimpleFunction) -> List = storageManager.createMemoizedFunction { irSimpleFunction -> @@ -260,4 +313,9 @@ class MemoizedInlineClassReplacements( 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 08950704183..bac2f39420b 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,24 +5,11 @@ package org.jetbrains.kotlin.backend.jvm -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.declarations.IrFactory +import org.jetbrains.kotlin.ir.declarations.IrFunction +import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction 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 /** @@ -34,281 +21,17 @@ class MemoizedMultiFieldValueClassReplacements( ) : MemoizedValueClassAbstractReplacements(irFactory, context) { private val storageManager = LockBasedStorageManager("multi-field-value-class-replacements") - 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 - } + override val originalFunctionForStaticReplacement: MutableMap = ConcurrentHashMap() + internal val originalFunctionForMethodReplacement: MutableMap = ConcurrentHashMap() /** - * Get a function replacement for a function or a constructor. + * Get a replacement for a function or a constructor. */ - 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 getReplacementFunction: (IrFunction) -> IrSimpleFunction? = storageManager.createMemoizedFunctionWithNullableValues { + 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 + override val replaceOverriddenSymbols: (IrSimpleFunction) -> List = storageManager.createMemoizedFunction { + TODO() } - - 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 1c7536e77cf..e94c6cd2088 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,113 +5,18 @@ package org.jetbrains.kotlin.backend.jvm -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.declarations.IrFactory +import org.jetbrains.kotlin.ir.declarations.IrFunction +import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction 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? - 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 originalFunctionForStaticReplacement: MutableMap 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 deleted file mode 100644 index 2af2d73dff2..00000000000 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNode.kt +++ /dev/null @@ -1,457 +0,0 @@ -/* - * 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 deleted file mode 100644 index c4de0207f1b..00000000000 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNodeFactory.kt +++ /dev/null @@ -1,487 +0,0 @@ -/* - * 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 deleted file mode 100644 index 9ec29027a12..00000000000 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNodeInstance.kt +++ /dev/null @@ -1,279 +0,0 @@ -/* - * 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 3aa08ae8b7a..900520f5633 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,11 +117,8 @@ fun IrType.defaultValue(startOffset: Int, endOffset: Int, context: JvmBackendCon } } -fun IrType.isInlineClassType(): Boolean = erasedUpperBound.isSingleFieldValueClass - -fun IrType.isMultiFieldValueClassType(): Boolean = erasedUpperBound.isMultiFieldValueClass - -fun IrType.isValueClassType(): Boolean = erasedUpperBound.isValue +fun IrType.isInlineClassType(): Boolean = + erasedUpperBound.isSingleFieldValueClass 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 a4a995f224f..1dbbb512852 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,7 +8,10 @@ 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.* +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.builtins.StandardNames import org.jetbrains.kotlin.codegen.ASSERTIONS_DISABLED_FIELD_NAME import org.jetbrains.kotlin.codegen.AsmUtil @@ -243,9 +246,6 @@ 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,13 +256,6 @@ 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() = @@ -312,7 +305,7 @@ val IrClass.isSyntheticSingleton: Boolean fun IrSimpleFunction.suspendFunctionOriginal(): IrSimpleFunction = if (isSuspend && - !isStaticValueClassReplacement && + !isStaticInlineClassReplacement && !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 ce08efd6bbc..71cad44385f 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.isStaticValueClassReplacement) return null + if (callee.isStaticInlineClassReplacement) 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 297b57d41d9..f3f13fb9785 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,13 +53,11 @@ 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, - origin = origin, + endOffset = endOffset ) 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 91d5b647d0c..cd00046c221 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,9 +43,6 @@ 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 9b5714b54bf..c071eb2180d 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.isValue) { + if (!irClass.isSingleFieldValueClass) { +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 4d7a6aa0d15..46d2026ed44 100644 --- a/compiler/testData/codegen/box/valueClasses/classFlattening.kt +++ b/compiler/testData/codegen/box/valueClasses/classFlattening.kt @@ -1,9 +1,7 @@ -// IGNORE_BACKEND_FIR: JVM_IR // WITH_STDLIB // TARGET_BACKEND: JVM_IR // WORKS_WHEN_VALUE_CLASS -// LANGUAGE: +ValueClasses +ContextReceivers -// CHECK_BYTECODE_LISTING +// LANGUAGE: +ValueClasses @JvmInline value class IC(val x: UInt) @@ -11,148 +9,13 @@ 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) { - companion object { - val SimpleMfvc.a1: SimpleMfvc - get() = this +value class SimpleMFVC(val x: UInt, val y: IC, val z: String) - @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 +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) -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" -} +fun box() = "OK" // todo real test \ No newline at end of file diff --git a/compiler/testData/codegen/box/valueClasses/classFlattening.txt b/compiler/testData/codegen/box/valueClasses/classFlattening.txt deleted file mode 100644 index 1c2e57cb34f..00000000000 --- a/compiler/testData/codegen/box/valueClasses/classFlattening.txt +++ /dev/null @@ -1,175 +0,0 @@ -@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 deleted file mode 100644 index aeee82468a7..00000000000 --- a/compiler/testData/codegen/box/valueClasses/complex.kt +++ /dev/null @@ -1,304 +0,0 @@ -// 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 deleted file mode 100644 index 0d7ed9bc934..00000000000 --- a/compiler/testData/codegen/box/valueClasses/complex.txt +++ /dev/null @@ -1,317 +0,0 @@ -@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 deleted file mode 100644 index 23a8dda02bf..00000000000 --- a/compiler/testData/codegen/box/valueClasses/conditionalExpressions.kt +++ /dev/null @@ -1,53 +0,0 @@ -// 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 deleted file mode 100644 index 9fc5090a38b..00000000000 --- a/compiler/testData/codegen/box/valueClasses/conditionalExpressions.txt +++ /dev/null @@ -1,49 +0,0 @@ -@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 220a66ec0e1..39353481dc2 100644 --- a/compiler/testData/codegen/box/valueClasses/equality.kt +++ b/compiler/testData/codegen/box/valueClasses/equality.kt @@ -1,10 +1,7 @@ -// 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 deleted file mode 100644 index 9cab488617f..00000000000 --- a/compiler/testData/codegen/box/valueClasses/equality.txt +++ /dev/null @@ -1,217 +0,0 @@ -@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 deleted file mode 100644 index 3c0b96b410e..00000000000 --- a/compiler/testData/codegen/box/valueClasses/forStatement.kt +++ /dev/null @@ -1,16 +0,0 @@ -// 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 deleted file mode 100644 index 21a92ef38ea..00000000000 --- a/compiler/testData/codegen/box/valueClasses/mfvcFieldInitializationOrder.kt +++ /dev/null @@ -1,27 +0,0 @@ -// 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 deleted file mode 100644 index fe8f71ee204..00000000000 --- a/compiler/testData/codegen/box/valueClasses/mfvcFieldInitializationOrder.txt +++ /dev/null @@ -1,59 +0,0 @@ -@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 deleted file mode 100644 index 828a385921d..00000000000 --- a/compiler/testData/codegen/box/valueClasses/overrides.kt +++ /dev/null @@ -1,311 +0,0 @@ -// 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 deleted file mode 100644 index 2cba3ebcf09..00000000000 --- a/compiler/testData/codegen/box/valueClasses/overrides.txt +++ /dev/null @@ -1,2586 +0,0 @@ -@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 deleted file mode 100644 index 90c73961f86..00000000000 --- a/compiler/testData/codegen/box/valueClasses/overrides_inlineClass.kt +++ /dev/null @@ -1,317 +0,0 @@ -// 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 deleted file mode 100644 index 697dc295fb2..00000000000 --- a/compiler/testData/codegen/box/valueClasses/overrides_inlineClass.txt +++ /dev/null @@ -1,2603 +0,0 @@ -@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 deleted file mode 100644 index ecb515cdfbd..00000000000 --- a/compiler/testData/codegen/box/valueClasses/overrides_typeParameters.kt +++ /dev/null @@ -1,327 +0,0 @@ -// 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 deleted file mode 100644 index de1c92111f2..00000000000 --- a/compiler/testData/codegen/box/valueClasses/overrides_typeParameters.txt +++ /dev/null @@ -1,2625 +0,0 @@ -@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 deleted file mode 100644 index 0e2f8992ceb..00000000000 --- a/compiler/testData/codegen/box/valueClasses/throwingMFVCReassignments.kt +++ /dev/null @@ -1,34 +0,0 @@ -// 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 deleted file mode 100644 index a644d185f32..00000000000 --- a/compiler/testData/codegen/box/valueClasses/throwingMFVCReassignments.txt +++ /dev/null @@ -1,37 +0,0 @@ -@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 deleted file mode 100644 index 7447986239a..00000000000 --- a/compiler/testData/codegen/box/valueClasses/tryExpressions.kt +++ /dev/null @@ -1,43 +0,0 @@ -// 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 deleted file mode 100644 index eb2ecb04ed3..00000000000 --- a/compiler/testData/codegen/box/valueClasses/tryExpressions.txt +++ /dev/null @@ -1,29 +0,0 @@ -@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 deleted file mode 100644 index 14272fd1063..00000000000 --- a/compiler/testData/codegen/box/valueClasses/visibility.kt +++ /dev/null @@ -1,296 +0,0 @@ -// 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 deleted file mode 100644 index 8189433e5f7..00000000000 --- a/compiler/testData/codegen/box/valueClasses/visibility.txt +++ /dev/null @@ -1,780 +0,0 @@ -@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 deleted file mode 100644 index 8cadc8dbba8..00000000000 --- a/compiler/testData/codegen/bytecodeText/valueClasses/conditionalExpressions.kt +++ /dev/null @@ -1,41 +0,0 @@ -// 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 deleted file mode 100644 index 939d65ebd3b..00000000000 --- a/compiler/testData/codegen/bytecodeText/valueClasses/equalsBoxTest.kt +++ /dev/null @@ -1,67 +0,0 @@ -// 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 deleted file mode 100644 index dbb658f8223..00000000000 --- a/compiler/testData/codegen/bytecodeText/valueClasses/mfvcDeclaration.kt +++ /dev/null @@ -1,76 +0,0 @@ -// 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 deleted file mode 100644 index 13430de8ad9..00000000000 --- a/compiler/testData/codegen/bytecodeText/valueClasses/mfvcReassignments.kt +++ /dev/null @@ -1,71 +0,0 @@ -// 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 deleted file mode 100644 index 1bb0077f41b..00000000000 --- a/compiler/testData/codegen/bytecodeText/valueClasses/passingMFVC2Functions.kt +++ /dev/null @@ -1,49 +0,0 @@ -// 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 deleted file mode 100644 index 548ecf738bb..00000000000 --- a/compiler/testData/codegen/bytecodeText/valueClasses/regularClassWithMFVC.kt +++ /dev/null @@ -1,144 +0,0 @@ -// 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 deleted file mode 100644 index dca322fc7a7..00000000000 --- a/compiler/testData/codegen/bytecodeText/valueClasses/tryExpressions.kt +++ /dev/null @@ -1,38 +0,0 @@ -// 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 74cd55233c3..20c86bb9889 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,7 +8,6 @@ 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; @@ -5456,16 +5455,6 @@ 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 354a4323361..794159fe5cb 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 @@ -50189,71 +50189,11 @@ 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 8050b901bc0..b4079bee42e 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,7 +8,6 @@ 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; @@ -5780,58 +5779,6 @@ 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")