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 4b0bd725384..58492832aa1 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 @@ -50202,9 +50202,9 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } @Test - @TestMetadata("MFVCFieldInitializationOrder.kt") - public void testMFVCFieldInitializationOrder() throws Exception { - runTest("compiler/testData/codegen/box/valueClasses/MFVCFieldInitializationOrder.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + @TestMetadata("MfvcFieldInitializationOrder.kt") + public void testMfvcFieldInitializationOrder() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/MfvcFieldInitializationOrder.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } @Test 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 68cfe35fb24..a83b50b2d03 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,11 +11,9 @@ import org.jetbrains.kotlin.backend.common.lower.VariableRemapper import org.jetbrains.kotlin.backend.common.lower.createIrBuilder import org.jetbrains.kotlin.backend.common.lower.irNot import org.jetbrains.kotlin.backend.common.phaser.makeIrFilePhase -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext -import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin +import org.jetbrains.kotlin.backend.jvm.* import org.jetbrains.kotlin.backend.jvm.MemoizedMultiFieldValueClassReplacements.RemappedParameter.MultiFieldValueClassMapping import org.jetbrains.kotlin.backend.jvm.MemoizedMultiFieldValueClassReplacements.RemappedParameter.RegularMapping -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 @@ -623,8 +621,8 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass target: IrSimpleFunction, superQualifierSymbol: IrClassSymbol? = null ) = - irCastIfNeeded( - irCall(target, origin = IrStatementOrigin.BRIDGE_DELEGATION, superQualifierSymbol = superQualifierSymbol).apply { + irCastIfNeeded(irBlock { + +irReturn(irCall(target, origin = IrStatementOrigin.BRIDGE_DELEGATION, superQualifierSymbol = superQualifierSymbol).apply { val targetStructure = run { val mfvcOrOriginal = @@ -656,7 +654,7 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass bridgeStructure.size == targetStructure.size && (targetStructure zip bridgeStructure).none { (targetParameter, bridgeParameter) -> targetParameter is MultiFieldValueClassMapping && bridgeParameter is MultiFieldValueClassMapping && - targetParameter.declarations != bridgeParameter.declarations + targetParameter.rootMfvcNode != bridgeParameter.rootMfvcNode }) { "Incompatible structures: $bridgeStructure and $targetStructure" } fun irGetOrCast(bridgeParameter: IrValueParameter, targetParameter: IrValueParameter) = @@ -678,7 +676,7 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass when (targetRemappedParameter) { is MultiFieldValueClassMapping -> when (bridgeRemappedParameter) { is MultiFieldValueClassMapping -> { - require(bridgeRemappedParameter.declarations == targetRemappedParameter.declarations) { + require(bridgeRemappedParameter.rootMfvcNode == targetRemappedParameter.rootMfvcNode) { "Incompatible parameters: $bridgeRemappedParameter, $targetRemappedParameter" } repeat(bridgeRemappedParameter.valueParameters.size) { @@ -687,34 +685,35 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass putArgument(targetParameter, irGetOrCast(bridgeParameter, targetParameter)) } } + is RegularMapping, null -> { val bridgeParameter = bridgeExplicitParameters[bridgeIndex++] - val newArguments = targetRemappedParameter.declarations.unboxMethods.map { unboxFunction -> - irCall(unboxFunction).apply { - val targetParameterType = targetRemappedParameter.declarations.valueClass.defaultType - dispatchReceiver = irCastIfNeeded(irGet(bridgeParameter), targetParameterType) - } - } + val targetParameterType = targetRemappedParameter.rootMfvcNode.mfvc.defaultType + val instance = targetRemappedParameter.rootMfvcNode.createInstanceFromBox( + this@irBlock, + irCastIfNeeded(irGet(bridgeParameter), targetParameterType), + hasAccessToPrivateMembersOf(target, targetRemappedParameter.rootMfvcNode.mfvc) + ) { error("Not applicable") } + val newArguments = instance.makeFlattenedGetterExpressions() for (newArgument in newArguments) { putArgument(targetExplicitParameters[targetIndex++], newArgument) } } } + is RegularMapping, null -> { val targetParameter = targetExplicitParameters[targetIndex] when (bridgeRemappedParameter) { is MultiFieldValueClassMapping -> { - val count = bridgeRemappedParameter.declarations.fields.size - val boxCall = irCall(bridgeRemappedParameter.declarations.boxMethod).apply { - bridgeRemappedParameter.boxedType.arguments.forEachIndexed { index, argument -> - putTypeArgument(index, argument.typeOrNull) - } - for (i in 0 until count) { - putValueArgument(i, irGet(bridgeExplicitParameters[bridgeIndex++])) - } + val valueArguments = List(bridgeRemappedParameter.rootMfvcNode.leavesCount) { + irGet(bridgeExplicitParameters[bridgeIndex++]) } + val boxCall = bridgeRemappedParameter.rootMfvcNode.makeBoxedExpression( + this@irBlock, bridgeRemappedParameter.typeArguments, valueArguments + ) putArgument(targetParameter, irCastIfNeeded(boxCall, targetParameter.type.upperBound)) } + is RegularMapping, null -> { val bridgeParameter = bridgeExplicitParameters[bridgeIndex++] putArgument(targetParameter, irGetOrCast(bridgeParameter, targetParameter)) @@ -734,9 +733,8 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass require((bridgeStructure == null || structureIndex == bridgeStructure.size)) { "Invalid structure index $structureIndex for $bridgeStructure" } - }, - bridge.returnType.upperBound - ) + }) + }.unwrap(), 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 00208a60e16..44d0b0ceebb 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 @@ -16,6 +16,7 @@ import org.jetbrains.kotlin.backend.jvm.MemoizedMultiFieldValueClassReplacements 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 @@ -32,7 +33,6 @@ import org.jetbrains.kotlin.ir.expressions.IrExpression import org.jetbrains.kotlin.ir.expressions.IrTypeOperator import org.jetbrains.kotlin.ir.expressions.impl.IrTypeOperatorCallImpl import org.jetbrains.kotlin.ir.types.IrType -import org.jetbrains.kotlin.ir.types.typeOrNull import org.jetbrains.kotlin.ir.util.* import org.jetbrains.kotlin.ir.visitors.* import org.jetbrains.kotlin.utils.addToStdlib.safeAs @@ -134,16 +134,16 @@ private class InheritedDefaultMethodsOnClassesLowering(val context: JvmBackendCo var flattenedIndex = 0 for (i in 1 until structure.size) { when (val remappedParameter = structure[i]) { - is MultiFieldValueClassMapping -> - putValueArgument(i, irCall(remappedParameter.declarations.boxMethod).apply { - remappedParameter.boxedType.arguments.forEachIndexed { index, argument -> - putTypeArgument(index, argument.typeOrNull) - } - val boxArgumentsCount = remappedParameter.valueParameters.size - for (boxArgumentIndex in 0 until boxArgumentsCount) { - putValueArgument(boxArgumentIndex, irGet(sourceFullValueParameterList[flattenedIndex++])) - } - }) + is MultiFieldValueClassMapping -> { + val valueArguments = (0 until remappedParameter.valueParameters.size).map { + irGet(sourceFullValueParameterList[flattenedIndex++]) + } + val boxedExpression = remappedParameter.rootMfvcNode.makeBoxedExpression( + this@irBlockBody, remappedParameter.typeArguments, valueArguments + ) + putValueArgument(i, boxedExpression) + } + is RegularMapping -> putValueArgument(i, irGet(sourceFullValueParameterList[flattenedIndex++])) } } 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 dfc239d8e5f..dce1555c165 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 @@ -83,7 +83,9 @@ private class JvmInlineClassLowering(context: JvmBackendContext) : JvmValueClass override fun IrClass.isSpecificLoweringLogicApplicable(): Boolean = isSingleFieldValueClass - override fun IrFunction.isFieldGetterToRemove(): Boolean = isInlineClassFieldGetter + 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. @@ -113,7 +115,7 @@ private class JvmInlineClassLowering(context: JvmBackendContext) : JvmValueClass 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.isFieldGetterToRemove() && !it.visibility.isPublicAPI) + it == irConstructor || (it is IrFunction && it.isInlineClassFieldGetter && !it.visibility.isPublicAPI) } buildPrimaryInlineClassConstructor(declaration, irConstructor) buildBoxFunction(declaration) 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 189627e1c47..65c721cf376 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,7 +5,6 @@ package org.jetbrains.kotlin.backend.jvm.lower -import org.jetbrains.kotlin.backend.common.ir.* import org.jetbrains.kotlin.backend.common.lower.createIrBuilder import org.jetbrains.kotlin.backend.common.phaser.makeIrFilePhase import org.jetbrains.kotlin.backend.common.pop @@ -14,34 +13,24 @@ 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.MemoizedMultiFieldValueClassReplacements.ValueParameterTemplate -import org.jetbrains.kotlin.backend.jvm.MultiFieldValueClassSpecificDeclarations.ImplementationAgnostic -import org.jetbrains.kotlin.backend.jvm.MultiFieldValueClassSpecificDeclarations.VirtualProperty -import org.jetbrains.kotlin.backend.jvm.MultiFieldValueClassTree.InternalNode -import org.jetbrains.kotlin.backend.jvm.MultiFieldValueClassTree.Leaf +import org.jetbrains.kotlin.backend.jvm.ir.createJvmIrBuilder import org.jetbrains.kotlin.backend.jvm.ir.erasedUpperBound -import org.jetbrains.kotlin.backend.jvm.ir.isMultiFieldValueClassType -import org.jetbrains.kotlin.descriptors.DescriptorVisibilities +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.addGetter -import org.jetbrains.kotlin.ir.builders.declarations.buildField 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.expressions.* -import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl +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.IrElementTransformerVoid -import org.jetbrains.kotlin.ir.visitors.IrElementVisitor +import org.jetbrains.kotlin.ir.visitors.* import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.utils.addToStdlib.popLast val jvmMultiFieldValueClassPhase = makeIrFilePhase( ::JvmMultiFieldValueClassLowering, @@ -53,67 +42,181 @@ val jvmMultiFieldValueClassPhase = makeIrFilePhase( ) private class JvmMultiFieldValueClassLowering(context: JvmBackendContext) : JvmValueClassAbstractLowering(context) { - - private open inner class ValueDeclarationsRemapper { - private val symbol2getter = mutableMapOf() - private val symbol2setters = mutableMapOf>() - private val knownExpressions = mutableMapOf() - - fun remapSymbol(original: IrValueSymbol, replacement: IrValueDeclaration) { - symbol2getter[original] = { irGet(replacement) } - symbol2setters[original] = if (replacement.isAssignable) listOf { value -> irSet(replacement, value) } else listOf(null) + /** + * The class is used to get replacing expression and MFVC instance if present for the given old value declaration. + */ + 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) } } - fun remapSymbol( - original: IrValueSymbol, - unboxed: List, - declarations: MultiFieldValueClassSpecificDeclarations - ): Unit = - remapSymbol(original, declarations.ImplementationAgnostic(original.owner.type as IrSimpleType, unboxed)) - - fun remapSymbol(original: IrValueSymbol, unboxed: ImplementationAgnostic) { - symbol2getter[original] = { - unboxed.boxedExpression(this).also { irExpression -> knownExpressions[irExpression] = unboxed } + 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)) } - symbol2setters[original] = unboxed.virtualFields.map { it.assigner } - } - - fun IrBuilderWithScope.getter(original: IrValueSymbol): IrExpression? = - symbol2getter[original]?.invoke(this) - - fun setter(original: IrValueSymbol): List? = symbol2setters[original] - - fun implementationAgnostic(expression: IrExpression): ImplementationAgnostic? = knownExpressions[expression] - - fun IrBuilderWithScope.subfield(expression: IrExpression, name: Name): IrExpression? = - implementationAgnostic(expression)?.get(name)?.let { (expressionGenerator, representation) -> - val res = expressionGenerator(this) - representation?.let { knownExpressions[res] = it } - res - } - - /** - * Register value declaration instead of singular expressions when possible - */ - fun registerExpression(getter: IrExpression, representation: ImplementationAgnostic) { - knownExpressions[getter] = representation } } - private val valueDeclarationsRemapper = ValueDeclarationsRemapper() + private inner class ValueDeclarationRemapper { - private val regularClassMFVCPropertyMainGetters: MutableMap> = mutableMapOf() - private val regularClassMFVCPropertyNextGetters: MutableMap> = mutableMapOf() - private val regularClassMFVCPropertyFieldsMapping: MutableMap> = mutableMapOf() - private val regularClassMFVCPropertyNodes: MutableMap = mutableMapOf() - private val regularClassMFVCPropertyAllPrimitiveGetters: MutableSet = mutableSetOf() + 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 makeReplacement(scope: IrBuilderWithScope, expression: IrGetValue): IrExpression? = with(scope) { + oldValueSymbol2NewValueSymbol[expression.symbol]?.let { return irGet(it.owner) } + val instance = oldSymbol2MfvcNodeInstance[expression.symbol] ?: return@with null + val res = instance.makeGetterExpression() + expression2MfvcNodeInstanceAccessor[res] = MfvcNodeInstanceAccessor.Getter(instance) + return res + } + + private fun separateExpressions(expressions: List): Pair, List> { + val repeatable = expressions.takeLastWhile { it.isRepeatableGetter() } + return expressions.subList(0, expressions.size - repeatable.size) to repeatable + } + + fun makeReplacement(scope: IrBuilderWithScope, expression: IrSetValue, safe: Boolean): IrExpression? = with(scope) { + oldValueSymbol2NewValueSymbol[expression.symbol]?.let { return irSet(it.owner, expression.value) } + val instance = oldSymbol2MfvcNodeInstance[expression.symbol] ?: return@with null + var values: List? = null + return irBlock { + values = makeFlattenedExpressionsWithGivenSafety(instance.node, safe, expression.value) + instance.addSetterStatements(this, values!!) + }.also { expression2MfvcNodeInstanceAccessor[it] = MfvcNodeInstanceAccessor.Setter(instance, values!!) } + } + + private fun IrBlockBuilder.makeFlattenedExpressionsWithGivenSafety( + node: MfvcNode, safe: Boolean, expression: IrExpression + ) = if (safe) { + val (forVariables, rest) = separateExpressions(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 makeReplacement(scope: IrBuilderWithScope, expression: IrGetField): IrExpression? { + val property = expression.field.property ?: return null + expression.receiver?.get(property.name)?.let { return it } + val node = replacements.getMfvcPropertyNode(property) ?: return null + val typeArguments = makeTypeArgumentsFromField(expression) + var instance: ReceiverBasedMfvcNodeInstance? = null + return scope.irBlock { + instance = node.createInstanceFromBox(this, typeArguments, expression.receiver, true, ::variablesSaver) + +instance!!.makeGetterExpression() + }.also { expression2MfvcNodeInstanceAccessor[it] = MfvcNodeInstanceAccessor.Getter(instance!!) } + } + + fun makeReplacement(scope: IrBuilderWithScope, expression: IrSetField, safe: Boolean): IrExpression? { + val property = expression.field.property ?: return null + expression.receiver?.get(property.name)?.let { return it } + val node = replacements.getMfvcPropertyNode(property) ?: return null + val typeArguments = makeTypeArgumentsFromField(expression) + var instance: ReceiverBasedMfvcNodeInstance? = null + var values: List? = null + return scope.irBlock { + instance = node.createInstanceFromBox(this, typeArguments, expression.receiver, true, ::variablesSaver) + values = makeFlattenedExpressionsWithGivenSafety(node, safe, expression.value) + instance!!.addSetterStatements(this, values!!) + }.also { expression2MfvcNodeInstanceAccessor[it] = MfvcNodeInstanceAccessor.Setter(instance!!, values!!) } + } + + fun makeReplacement(scope: IrBuilderWithScope, expression: IrCall): IrExpression? { + val function = expression.symbol.owner + val property = function.property?.takeIf { function.isGetter } ?: return null + expression.dispatchReceiver?.get(property.name)?.let { return it } + val node = replacements.getMfvcPropertyNode(property) ?: return null + val typeArguments = makeTypeArgumentsFromFunction(expression) + var instance: ReceiverBasedMfvcNodeInstance? = null + return scope.irBlock { + instance = node.createInstanceFromBox(this, typeArguments, expression.dispatchReceiver, false, ::variablesSaver) + +instance!!.makeGetterExpression() + }.also { expression2MfvcNodeInstanceAccessor[it] = MfvcNodeInstanceAccessor.Getter(instance!!) } + } + + private val IrField.property + get() = correspondingPropertySymbol?.owner + private val IrSimpleFunction.property + get() = correspondingPropertySymbol?.owner + + 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)) } + } + + operator fun IrExpression.get(name: Name): IrExpression? { + val accessor = getMfvcNodeInstanceAccessor(this) ?: return null + val newAccessor = accessor[name] ?: return null + val expression = when (newAccessor) { + is MfvcNodeInstanceAccessor.Getter -> newAccessor.instance.makeGetterExpression() + is MfvcNodeInstanceAccessor.Setter -> newAccessor.instance.makeSetterExpressions(newAccessor.values) + } + expression2MfvcNodeInstanceAccessor[expression] = newAccessor + return expression + } + + fun getMfvcNodeInstanceAccessor(expression: IrExpression): MfvcNodeInstanceAccessor? = + expression2MfvcNodeInstanceAccessor[expression] + + fun getMfvcNodeInstanceIfIsGetter(expression: IrExpression): MfvcNodeInstance? = + getMfvcNodeInstanceAccessor(expression)?.takeIf { it is MfvcNodeInstanceAccessor.Getter }?.instance + + fun getMfvcNodeInstanceIfIsSetter(expression: IrExpression): MfvcNodeInstance? = + getMfvcNodeInstanceAccessor(expression)?.takeIf { it is MfvcNodeInstanceAccessor.Setter }?.instance + + fun registerReplacement(expression: IrExpression, instance: MfvcNodeInstance) { + expression2MfvcNodeInstanceAccessor[expression] = MfvcNodeInstanceAccessor.Getter(instance) + } + } + + private val valueDeclarationsRemapper = ValueDeclarationRemapper() override val replacements get() = context.multiFieldValueClassReplacements override fun IrClass.isSpecificLoweringLogicApplicable(): Boolean = isMultiFieldValueClass - override fun IrFunction.isFieldGetterToRemove(): Boolean = isMultiFieldValueClassOriginalFieldGetter + override val specificMangle: SpecificMangle + get() = SpecificMangle.MultiField + + private val variablesToAdd = mutableMapOf>() + + private fun variablesSaver(variable: IrVariable) { + variablesToAdd.getOrPut(variable.parent) { mutableSetOf() }.add(variable) + } override fun visitClassNew(declaration: IrClass): IrStatement { @@ -124,147 +227,101 @@ private class JvmMultiFieldValueClassLowering(context: JvmBackendContext) : JvmV } declaration.transformDeclarationsFlat { memberDeclaration -> - if (memberDeclaration is IrFunction) { - withinScope(memberDeclaration) { - transformFunctionFlat(memberDeclaration) - } + (if (memberDeclaration is IrFunction) withinScope(memberDeclaration) { + transformFunctionFlat(memberDeclaration) } else { memberDeclaration.accept(this, null) null + }).apply { + for (replacingDeclaration in this ?: 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 } - private fun handleNonSpecificNewClass(declaration: IrClass) { - declaration.primaryConstructor?.let { - replacements.getReplacementRegularClassConstructor(it)?.let { replacement -> addBindingsFor(it, replacement) } + private fun handleNonSpecificNewClass(irClass: IrClass) { + irClass.primaryConstructor?.let { + replacements.getReplacementForRegularClassConstructor(it)?.let { replacement -> addBindingsFor(it, replacement) } } - val fieldsToReplace = declaration.fields.filter { !it.type.isNullable() && it.type.isMultiFieldValueClassType() }.toList() + val properties = collectPropertiesAfterLowering(irClass) + val oldBackingFields = properties.mapNotNull { property -> property.backingField?.let { property to it } }.toMap() + val propertiesReplacement = collectRegularClassMfvcPropertiesReplacement(properties) // resets backing fields - val oldFieldToInitializers: MutableMap = mutableMapOf() - // we need to preserve order of initializations - val newFields: List> = fieldsToReplace.map { oldField -> - val declarations = replacements.getDeclarations(oldField.type.erasedUpperBound)!! - val newFields = declarations.fields.map { sourceField -> - context.irFactory.buildField { - name = Name.guessByFirstCharacter("${oldField.name.asString()}$${sourceField.name.asString()}") - type = sourceField.type - origin = IrDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_MEMBER - visibility = DescriptorVisibilities.PRIVATE - }.apply { - parent = declaration - initializer = null - } - } - regularClassMFVCPropertyFieldsMapping[oldField] = newFields - val nodes2getters = declarations.makeNodes2FieldExpressions(newFields) + val fieldsToRemove = LinkedHashSet(propertiesReplacement.keys.mapNotNull { oldBackingFields[it] }) - val property = oldField.correspondingPropertySymbol?.owner - val mainGetter = property?.getter - val mainSetter = property?.setter - property?.backingField = null - if (mainGetter != null) { - if (!property.isDelegated && mainGetter.isDefaultGetter(oldField)) { - mainGetter.origin = IrDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_MEMBER - regularClassMFVCPropertyMainGetters.getOrPut(declaration) { mutableMapOf() }[oldField.name] = mainGetter - val nodesToGetters = nodes2getters.mapValues { (node, exprGen) -> - if (node == declarations.loweringRepresentation) mainGetter else { - context.irFactory.buildProperty { - val nameAsString = "${oldField.name.asString()}$${declarations.nodeFullNames[node]!!.asString()}" - name = Name.guessByFirstCharacter(nameAsString) - origin = IrDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_MEMBER - visibility = oldField.visibility - }.apply { - parent = declaration - addGetter { - returnType = node.type - origin = IrDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_MEMBER - }.apply { - createDispatchReceiverParameter() - val function = this - body = with(context.createIrBuilder(this.symbol)) { - irExprBody(exprGen(this, function)) - } - } - }.getter!!.also { - declaration.declarations.add(it) - } - } - } - regularClassMFVCPropertyNodes.putAll(nodesToGetters.map { (node, getter) -> getter to node }) - for ((node, getter) in nodesToGetters) { - if (node is InternalNode) { - regularClassMFVCPropertyNextGetters[getter] = node.fields.associate { it.name to nodesToGetters[it.node]!! } - } - } - regularClassMFVCPropertyAllPrimitiveGetters.addAll(nodesToGetters.values) - } - } - for (accessor in listOfNotNull(mainGetter, mainSetter)) - accessor.body?.transform(object : IrElementTransformerVoid() { - override fun visitGetField(expression: IrGetField): IrExpression { - if (expression.symbol.owner == oldField) { - require(expression.receiver.let { - it is IrGetValue && it.symbol.owner == accessor.dispatchReceiverParameter || - it == null && oldField.origin == JvmLoweredDeclarationOrigin.COMPANION_PROPERTY_BACKING_FIELD - }) { "Unexpected receiver for IrGetField: ${expression.receiver}" } - val gettersAndSetters = - newFields.toGettersAndSetters(accessor.dispatchReceiverParameter, transformReceiver = true) - val representation = newFields.zip(gettersAndSetters) { newField, (getter, setter) -> - VirtualProperty(newField.type, getter, setter, null) - } - val fieldRepresentation = declarations.ImplementationAgnostic(oldField.type as IrSimpleType, representation) - val boxed = fieldRepresentation.boxedExpression( - context.createIrBuilder((currentScope!!.irElement as IrSymbolOwner).symbol) - ) - valueDeclarationsRemapper.registerExpression(boxed, fieldRepresentation) - return boxed - } - return super.visitGetField(expression) - } - }, null) - oldField.initializer?.let { initializer -> - context.irFactory.createAnonymousInitializer( - startOffset = UNDEFINED_OFFSET, - endOffset = UNDEFINED_OFFSET, origin = IrDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_MEMBER, - symbol = IrAnonymousInitializerSymbolImpl() - ).apply { - parent = declaration - body = context.createIrBuilder(this.symbol).irBlockBody { - +irBlock { - flattenExpressionTo(initializer.expression, newFields.toGettersAndSetters(declaration.thisReceiver)) - } - } - oldFieldToInitializers[oldField] = this - } - } - newFields - } - for (i in declaration.declarations.indices) { - oldFieldToInitializers[declaration.declarations[i]]?.let { initializer -> - declaration.declarations[i] = initializer - } - } - declaration.declarations.addAll(newFields.flatten()) - declaration.declarations.removeAll(fieldsToReplace) + val newDeclarations = makeNewDeclarationsForRegularClass(fieldsToRemove, propertiesReplacement, irClass) + irClass.declarations.replaceAll(newDeclarations) } + private fun collectRegularClassMfvcPropertiesReplacement(properties: LinkedHashSet) = + LinkedHashMap().apply { + for (property in properties) { + val node = replacements.getRegularClassMfvcPropertyNode(property) ?: continue + put(property, node) + } + } + + private fun makeNewDeclarationsForRegularClass( + fieldsToRemove: LinkedHashSet, + propertiesReplacement: LinkedHashMap, + irClass: IrClass, + ) = buildList { + for (element in irClass.declarations) { + when (element) { + !is IrField, !in fieldsToRemove -> add(element) + else -> { + val replacement = propertiesReplacement[element.correspondingPropertySymbol!!.owner]!! + addAll(replacement.fields!!) + element.initializer?.let { initializer -> add(makeInitializerReplacement(irClass, element, initializer)) } + } + } + } + + for (node in propertiesReplacement.values) { + addAll(node.allInnerUnboxMethods.filter { it.parent == irClass }) + } + } + + 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) { - replacements.commitMFVCOldProperties(declaration) - val newDeclarations = replacements.getDeclarations(declaration)!! - if (newDeclarations.valueClass != declaration) error("Unexpected IrClass ${newDeclarations.valueClass} instead of $declaration") - newDeclarations.replaceFields() - newDeclarations.replaceProperties() - newDeclarations.buildPrimaryMultiFieldValueClassConstructor() - newDeclarations.buildBoxFunction() - newDeclarations.buildUnboxFunctions() - newDeclarations.buildSpecializedEqualsMethod() + val rootNode = replacements.getRootMfvcNode(declaration)!! + rootNode.replaceFields() + declaration.declarations += rootNode.run { allUnboxMethods + listOf(boxMethod, specializedEqualsMethod) } + rootNode.replacePrimaryMultiFieldValueClassConstructor() } override fun transformSecondaryConstructorFlat(constructor: IrConstructor, replacement: IrSimpleFunction): List { replacement.valueParameters.forEach { it.transformChildrenVoid() } + + allScopes.push(createScope(replacement)) replacement.body = context.createIrBuilder(replacement.symbol).irBlockBody { val thisVar = irTemporary(irType = replacement.returnType, nameHint = "\$this") constructor.body?.statements?.forEach { statement -> @@ -272,7 +329,7 @@ private class JvmMultiFieldValueClassLowering(context: JvmBackendContext) : JvmV override fun visitClass(declaration: IrClass): IrStatement = declaration override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall): IrExpression { - val oldPrimaryConstructor = replacements.getDeclarations(constructor.constructedClass)!!.oldPrimaryConstructor + val oldPrimaryConstructor = replacements.getRootMfvcNode(constructor.constructedClass)!!.oldPrimaryConstructor thisVar.initializer = irCall(oldPrimaryConstructor).apply { copyTypeAndValueArgumentsFrom(expression) } @@ -301,17 +358,15 @@ private class JvmMultiFieldValueClassLowering(context: JvmBackendContext) : JvmV .also { addBindingsFor(constructor, replacement) } .transform(this@JvmMultiFieldValueClassLowering, null) .patchDeclarationParents(replacement) + allScopes.pop() return listOf(replacement) } - private fun MultiFieldValueClassSpecificDeclarations.replaceFields() { - valueClass.declarations.removeIf { it is IrField } - valueClass.declarations += fields - } + private object UNSAFE_MFVC_SET_ORIGIN : IrStatementOrigin - private fun MultiFieldValueClassSpecificDeclarations.replaceProperties() { - valueClass.declarations.removeAll(oldProperties.values.mapNotNull { it.getter }) - valueClass.declarations += properties.values.map { it.getter!! } + private fun RootMfvcNode.replaceFields() { + mfvc.declarations.removeIf { it is IrField } + mfvc.declarations += fields } override fun createBridgeDeclaration(source: IrSimpleFunction, replacement: IrSimpleFunction, mangledName: Name): IrSimpleFunction = @@ -320,10 +375,10 @@ private class JvmMultiFieldValueClassLowering(context: JvmBackendContext) : JvmV name = mangledName returnType = source.returnType }.apply { - val anyOverriddenReplaced = replacement.overriddenSymbols.any { + val isAnyOverriddenReplaced = replacement.overriddenSymbols.any { it.owner in replacements.bindingNewFunctionToParameterTemplateStructure } - if (source.parentAsClass.isMultiFieldValueClass && anyOverriddenReplaced) { + if (source.parentAsClass.isMultiFieldValueClass && isAnyOverriddenReplaced) { copyTypeParametersFrom(source) // without static type parameters val substitutionMap = makeTypeParameterSubstitutionMap(source, this) dispatchReceiverParameter = source.dispatchReceiverParameter!!.let { // source!!! @@ -346,7 +401,7 @@ private class JvmMultiFieldValueClassLowering(context: JvmBackendContext) : JvmV } val bridgeStructure = replacementStructure.toMutableList().apply { - set(0, RegularMapping(ValueParameterTemplate(dispatchReceiverParameter!!, dispatchReceiverParameter!!.origin))) + set(0, RegularMapping(dispatchReceiverParameter!!)) } replacements.bindingNewFunctionToParameterTemplateStructure[this] = bridgeStructure } else { @@ -366,95 +421,104 @@ private class JvmMultiFieldValueClassLowering(context: JvmBackendContext) : JvmV source.body = context.createIrBuilder(source.symbol, source.startOffset, source.endOffset).run { val sourceExplicitParameters = source.explicitParameters val targetExplicitParameters = target.explicitParameters - irExprBody(irCall(target).apply { - passTypeArgumentsWithOffsets(target, source) { source.typeParameters[it].defaultType } - val sourceStructure: List? = replacements.bindingNewFunctionToParameterTemplateStructure[source] - val targetStructure: List? = replacements.bindingNewFunctionToParameterTemplateStructure[target] - val errorMessage = { - """ + 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.declarations != s.declarations - }, errorMessage) - } - } - } - val structuresSizes = sourceStructure?.size ?: targetStructure?.size ?: targetExplicitParameters.size - var flattenedSourceIndex = 0 - var flattenedTargetIndex = 0 - for (i in 0 until structuresSizes) { - val remappedSourceParameter = sourceStructure?.get(i) - val remappedTargetParameter = targetStructure?.get(i) - when (remappedSourceParameter) { - is MultiFieldValueClassMapping -> { - when (remappedTargetParameter) { - is MultiFieldValueClassMapping -> { - require(remappedTargetParameter.valueParameters.size == remappedSourceParameter.valueParameters.size) { - "Incompatible structures: $remappedTargetParameter, $remappedSourceParameter" - } - repeat(remappedTargetParameter.valueParameters.size) { - putArgument( - targetExplicitParameters[flattenedTargetIndex++], - irGet(sourceExplicitParameters[flattenedSourceIndex++]) - ) - } - } - is RegularMapping, null -> putArgument( - targetExplicitParameters[flattenedTargetIndex++], - irCall(remappedSourceParameter.declarations.boxMethod).apply { - remappedSourceParameter.boxedType.arguments.forEachIndexed { index, argument -> - putTypeArgument(index, argument.typeOrNull) - } - sourceExplicitParameters - .slice(flattenedSourceIndex until flattenedSourceIndex + remappedSourceParameter.valueParameters.size) - .forEachIndexed { index, boxParameter -> putValueArgument(index, irGet(boxParameter)) } - .also { flattenedSourceIndex += remappedSourceParameter.valueParameters.size } - }) + 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) } } - is RegularMapping, null -> when (remappedTargetParameter) { + + 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 -> { - val receiver = sourceExplicitParameters[flattenedSourceIndex++] - for (unboxMethod in remappedTargetParameter.declarations.unboxMethods) { - putArgument( - targetExplicitParameters[flattenedTargetIndex++], - irCall(unboxMethod).apply { dispatchReceiver = irGet(receiver) } - ) + 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 } + } } } - else -> putArgument( - targetExplicitParameters[flattenedTargetIndex++], - irGet(sourceExplicitParameters[flattenedSourceIndex++]) - ) + + is RegularMapping, null -> when (remappedTargetParameter) { + is MultiFieldValueClassMapping -> { + val receiver = sourceExplicitParameters[flattenedSourceIndex++] + val rootNode = remappedTargetParameter.rootMfvcNode + val instance = rootNode.createInstanceFromBox( + this@irBlock, irGet(receiver), hasAccessToPrivateMembersOf(rootNode.mfvc), ::variablesSaver + ) + val flattenedExpressions = instance.makeFlattenedGetterExpressions() + 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()}" - } + require(flattenedTargetIndex == targetExplicitParameters.size && flattenedSourceIndex == sourceExplicitParameters.size) { + "Incorrect source:\n${source.dump()}\n\nfor target\n${target.dump()}" + } + }) }) } allScopes.pop() @@ -470,14 +534,14 @@ private class JvmMultiFieldValueClassLowering(context: JvmBackendContext) : JvmV // static fun calls method val dispatchReceiverType = source.parentAsClass.defaultType require(dispatchReceiverType.let { - it.isMultiFieldValueClassType() && !it.isNullable() && it.erasedUpperBound.typeParameters.size == sourceOffset + 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.isMultiFieldValueClassType() && !it.isNullable() && it.erasedUpperBound.typeParameters.size == targetOffset + it.needsMfvcFlattening() && it.erasedUpperBound.typeParameters.size == targetOffset }) { "Unexpected dispatcher receiver type: ${dispatchReceiverType.render()}" } dispatchReceiverType.erasedUpperBound.typeParameters.forEachIndexed { index, typeParameter -> putTypeArgument(index, typeParameter.defaultType) @@ -500,67 +564,45 @@ private class JvmMultiFieldValueClassLowering(context: JvmBackendContext) : JvmV parametersStructure.scan(0) { partial: Int, templates: RemappedParameter -> partial + templates.valueParameters.size } .zipWithNext { start: Int, finish: Int -> replacement.explicitParameters.slice(start until finish) } ) + val scope = context.createIrBuilder(replacement.symbol) for (i in old2newList.indices) { val (param, newParamList) = old2newList[i] when (val structure = parametersStructure[i]) { - is MultiFieldValueClassMapping -> - valueDeclarationsRemapper.remapSymbol(param.symbol, newParamList.map { VirtualProperty(it) }, structure.declarations) - is RegularMapping -> valueDeclarationsRemapper.remapSymbol(param.symbol, newParamList.single()) + is MultiFieldValueClassMapping -> { + val mfvcNodeInstance = structure.rootMfvcNode.createInstanceFromValueDeclarationsAndBoxType( + scope, structure.boxedType, newParamList, listOf() + ) + valueDeclarationsRemapper.registerReplacement(param, mfvcNodeInstance) + } + + is RegularMapping -> valueDeclarationsRemapper.registerReplacement(param, newParamList.single()) } } } - fun MultiFieldValueClassSpecificDeclarations.buildPrimaryMultiFieldValueClassConstructor() { - valueClass.declarations.removeIf { it is IrConstructor && it.isPrimary } - val primaryConstructorReplacements = listOf(primaryConstructor, primaryConstructorImpl) - valueClass.declarations += primaryConstructorReplacements + fun RootMfvcNode.replacePrimaryMultiFieldValueClassConstructor() { + val rootMfvcNode = this + mfvc.declarations.removeIf { it is IrConstructor && it.isPrimary } + mfvc.declarations += listOf(newPrimaryConstructor, primaryConstructorImpl) - val initializersStatements = valueClass.declarations.filterIsInstance().flatMap { it.body.statements } - valueDeclarationsRemapper.remapSymbol( - oldPrimaryConstructor.constructedClass.thisReceiver!!.symbol, - primaryConstructorImpl.valueParameters.map { VirtualProperty(it) }, - this, - ) + val initializersStatements = mfvc.declarations.filterIsInstance() + val typeArguments = makeTypeParameterSubstitutionMap(mfvc, primaryConstructorImpl) primaryConstructorImpl.body = context.createIrBuilder(primaryConstructorImpl.symbol).irBlockBody { - for (stmt in initializersStatements) { - +stmt.transformStatement(this@JvmMultiFieldValueClassLowering).patchDeclarationParents(primaryConstructorImpl) + val mfvcNodeInstance = + ValueDeclarationMfvcNodeInstance(this, rootMfvcNode, typeArguments, primaryConstructorImpl.valueParameters, listOf()) + valueDeclarationsRemapper.registerReplacement( + oldPrimaryConstructor.constructedClass.thisReceiver!!, + mfvcNodeInstance + ) + for (initializer in initializersStatements) { + +irBlock { + for (stmt in initializer.body.statements) { + +stmt.patchDeclarationParents(primaryConstructorImpl) // transformation is done later + } + } } } - valueClass.declarations.removeIf { it is IrAnonymousInitializer } - } - - fun MultiFieldValueClassSpecificDeclarations.buildBoxFunction() { - boxMethod.body = with(context.createIrBuilder(boxMethod.symbol)) { - irExprBody(irCall(primaryConstructor.symbol).apply { - for (i in leaves.indices) { - putValueArgument(i, irGet(boxMethod.valueParameters[i])) - } - }) - } - valueClass.declarations += boxMethod - } - - fun MultiFieldValueClassSpecificDeclarations.buildUnboxFunctions() { - valueClass.declarations += unboxMethods - } - - @Suppress("unused") - fun MultiFieldValueClassSpecificDeclarations.buildSpecializedEqualsMethod() { - // todo defaults - specializedEqualsMethod.body = with(context.createIrBuilder(specializedEqualsMethod.symbol)) { - // TODO: Revisit this once we allow user defined equals methods in inline/multi-field value classes. - leaves.indices.map { - val left = irGet(specializedEqualsMethod.valueParameters[it]) - val right = irGet(specializedEqualsMethod.valueParameters[it + leaves.size]) - irEquals(left, right) - }.reduce { acc, current -> - irCall(context.irBuiltIns.andandSymbol).apply { - putValueArgument(0, acc) - putValueArgument(1, current) - } - }.let { irExprBody(it) } - } - valueClass.declarations += specializedEqualsMethod + mfvc.declarations.removeIf { it is IrAnonymousInitializer } } override fun visitFunctionReference(expression: IrFunctionReference): IrExpression { @@ -575,16 +617,24 @@ private class JvmMultiFieldValueClassLowering(context: JvmBackendContext) : JvmV return when { function is IrConstructor && function.isPrimary && function.constructedClass.isMultiFieldValueClass && currentScope.origin != JvmLoweredDeclarationOrigin.SYNTHETIC_MULTI_FIELD_VALUE_CLASS_MEMBER -> { + var instance: MfvcNodeInstance? = null context.createIrBuilder(currentScope.symbol).irBlock { - val thisReplacement = irTemporary(expression) - +irGet(thisReplacement) - }.transform(this, null) // transform with visitVariable + val rootNode = replacements.getRootMfvcNode(function.constructedClass)!! + instance = rootNode.createInstanceFromValueDeclarationsAndBoxType( + this, function.constructedClassType as IrSimpleType, Name.identifier("constructor_tmp"), ::variablesSaver + ) + flattenExpressionTo(expression, instance!!) + +instance!!.makeGetterExpression() + }.also { valueDeclarationsRemapper.registerReplacement(it, instance!!) } } + replacement != null -> context.createIrBuilder(currentScope.symbol).irBlock { buildReplacement(function, expression, replacement) } + else -> - when (val newConstructor = (function as? IrConstructor)?.let { replacements.getReplacementRegularClassConstructor(it) }) { + when (val newConstructor = + (function as? IrConstructor)?.let { replacements.getReplacementForRegularClassConstructor(it) }) { null -> return super.visitFunctionAccess(expression) else -> context.createIrBuilder(currentScope.symbol).irBlock { buildReplacement(function, expression, newConstructor) @@ -595,95 +645,90 @@ private class JvmMultiFieldValueClassLowering(context: JvmBackendContext) : JvmV override fun visitCall(expression: IrCall): IrExpression { val callee = expression.symbol.owner - val oldReceiver = expression.dispatchReceiver - val name = callee.correspondingPropertySymbol?.owner?.name - if (callee.isMultiFieldValueClassOriginalFieldGetter && oldReceiver != null) { - with(valueDeclarationsRemapper) { - with(context.createIrBuilder(expression.symbol)) { - val newReceiver = oldReceiver.transform(this@JvmMultiFieldValueClassLowering, null) - if (newReceiver is IrCall) { - val nextFunction = regularClassMFVCPropertyNextGetters[newReceiver.symbol.owner]?.get(name) - if (nextFunction != null) { - require(nextFunction.typeParameters.isEmpty()) { "Subgetter with type parameters: ${nextFunction.render()}" } - return irCall(nextFunction).apply { - this.dispatchReceiver = newReceiver.dispatchReceiver - } - } - } - subfield(newReceiver, name!!)?.let { return it } - return expression.apply { - dispatchReceiver = newReceiver - extensionReceiver = extensionReceiver?.transform(this@JvmMultiFieldValueClassLowering, null) - for (i in 0 until valueArgumentsCount) { - putValueArgument(i, getValueArgument(i)?.transform(this@JvmMultiFieldValueClassLowering, null)) - } - } - } - } + val property = callee.correspondingPropertySymbol?.owner + if ( + property != null && + callee.extensionReceiverParameter == null && + 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 valueDeclarationsRemapper.makeReplacement(context.createIrBuilder(getCurrentScopeSymbol()), expression) ?: expression } if (expression.isSpecializedMFVCEqEq) { - val leftArgument = expression.getValueArgument(0)!!.transform(this, null) - val rightArgument = expression.getValueArgument(1)!!.transform(this, null) - val leftImplementation = valueDeclarationsRemapper.implementationAgnostic(leftArgument) - val rightImplementation = valueDeclarationsRemapper.implementationAgnostic(rightArgument) - if (leftImplementation != null) { - val leftClass = leftImplementation.regularDeclarations.valueClass - if (rightImplementation != null) { - val rightClass = rightImplementation.regularDeclarations.valueClass - require(leftClass == rightClass) { "Equals for different classes: $leftClass and $rightClass called" } - return context.createIrBuilder(expression.symbol).run { - irCall(leftImplementation.regularDeclarations.specializedEqualsMethod).apply { - (leftImplementation.type.arguments + rightImplementation.type.arguments).forEachIndexed { index, argument -> + 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) { + 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 = - (leftImplementation.virtualFields + rightImplementation.virtualFields).map { it.makeGetter(this@run) } + val arguments = leftExpressions + rightExpressions arguments.forEachIndexed { index, argument -> putValueArgument(index, argument) } } - } - } else { - val equals = leftClass.functions.single { it.name.asString() == "equals" && it.overriddenSymbols.isNotEmpty() } - return super.visitCall(context.createIrBuilder(expression.symbol).run { - irCall(equals).apply { + } else { + val equals = leftClass.functions.single { it.name.asString() == "equals" && it.overriddenSymbols.isNotEmpty() } + +irCall(equals).apply { copyTypeArgumentsFrom(expression) dispatchReceiver = leftArgument putValueArgument(0, rightArgument) - } as IrCall - }) - } - } else if (rightImplementation != null) { - if (leftArgument.isNullConst()) { - return context.createIrBuilder(expression.symbol).irBlock { - +rightArgument - +irFalse() - }.transform(this, null) - } - if (leftArgument.type.erasedUpperBound == rightArgument.type.erasedUpperBound && leftArgument.type.isNullable()) { - return context.createIrBuilder(expression.symbol).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 if (rightNode != null) { + if (leftArgument.isNullConst()) { + 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() }}" } - }) - }.transform(this@JvmMultiFieldValueClassLowering, null) + rightExpressions.filterNot { it.isRepeatableGetter() }.forEach { +it } + } else { + +rightArgument.transform(this@JvmMultiFieldValueClassLowering, null) + } + +irFalse() + } else if (leftArgument.type.erasedUpperBound == rightArgument.type.erasedUpperBound && leftArgument.type.isNullable()) { + +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 { + return super.visitCall(expression) + } + } else { + return super.visitCall(expression) } } } return super.visitCall(expression) } - private fun makeLeavesGetters(currentGetter: IrSimpleFunction): List? = - when (val node = regularClassMFVCPropertyNodes[currentGetter]) { - null -> null - is Leaf -> listOf(currentGetter) - is InternalNode -> node.fields.flatMap { makeLeavesGetters(regularClassMFVCPropertyNextGetters[currentGetter]!![it.name]!!)!! } - } - private fun IrBlockBuilder.buildReplacement( originalFunction: IrFunction, original: IrMemberAccessExpression<*>, @@ -707,8 +752,8 @@ private class JvmMultiFieldValueClassLowering(context: JvmBackendContext) : JvmV override fun visitStringConcatenation(expression: IrStringConcatenation): IrExpression { for (i in expression.arguments.indices) { val argument = expression.arguments[i] - if (!argument.type.isNullable() && argument.type.isMultiFieldValueClassType()) { - expression.arguments[i] = context.createIrBuilder((currentScope!!.irElement as IrSymbolOwner).symbol).run { + if (argument.type.needsMfvcFlattening()) { + expression.arguments[i] = context.createIrBuilder(getCurrentScopeSymbol()).run { val toString = argument.type.erasedUpperBound.functions.single { it.name.asString() == "toString" && it.valueParameters.isEmpty() } @@ -724,359 +769,419 @@ private class JvmMultiFieldValueClassLowering(context: JvmBackendContext) : JvmV private fun IrBlockBuilder.makeNewArguments( oldArguments: List, - structure: List> + structure: List> ): List { - - var variables: List = listOf() - var subVariables: List> = listOf() - val declareVariables = irComposite { - variables = structure.flatMap { argTemplate -> argTemplate.map { irTemporary(irType = it.type) } } - subVariables = structure.scan(0) { acc: Int, templates: List -> acc + templates.size } - .zipWithNext().map { (start, finish) -> variables.slice(start until finish) } - } - val initializeVariables = irBlock { - (oldArguments zip subVariables).forEach { (oldArgument, curSubVariables) -> - when { - oldArgument == null -> Unit - curSubVariables.size == 1 -> { - val curSubVariable = curSubVariables.single() - +irSet(curSubVariable, oldArgument.transform(this@JvmMultiFieldValueClassLowering, null)) + 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}" } } - else -> flattenExpressionTo(oldArgument, curSubVariables.toGettersAndSetters()) } } } - val variablesSymbols2Index = variables.mapIndexed { index, variable -> variable.symbol to index }.toMap() - val inlinedArguments = run { - val result = mutableMapOf() - var lastIndex = -1 // we need to assign them in the same order - for (statement in initializeVariables.statements) { - if (statement !is IrSetValue) return@run null - val index = variablesSymbols2Index[statement.symbol] ?: return@run null - if (lastIndex >= index) return@run null - lastIndex = index - result[statement.symbol] = statement.value - } - result - } - if (inlinedArguments != null) { - return variables.map { inlinedArguments[it.symbol] } - } - +declareVariables - +initializeVariables - val newArguments: List = (oldArguments zip subVariables).flatMap { (oldArgument, curSubVariables) -> - when (oldArgument) { - null -> List(curSubVariables.size) { null } - else -> curSubVariables.map { irGet(it) } - } - } return newArguments } + fun IrBuilderWithScope.removeExtraSetVariablesFromExpressionList( + block: IrContainerExpression, + variables: List + ): List { + val forbiddenVariables = mutableSetOf() + val variablesSet = variables.toSet() + val standaloneExpressions = mutableListOf() + for ((expression, variable) in block.statements.asReversed() zip variables.asReversed()) { + when { + expression !is IrSetValue -> break + expression.symbol.owner != variable -> break + expression.symbol.owner in forbiddenVariables -> break + else -> { + standaloneExpressions.add(expression.value) + expression.value.acceptVoid(object : IrElementVisitorVoid { + override fun visitExpression(expression: IrExpression) { + expression.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) + } + }) + } + } + } + repeat(standaloneExpressions.size) { block.statements.removeLast() } + return variables.dropLast(standaloneExpressions.size).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.takeIf { it.isMultiFieldValueClass } != null } + .any { argument -> argument.type.erasedUpperBound.takeIf { it.isMultiFieldValueClass } != null } override fun visitGetField(expression: IrGetField): IrExpression { - val field = expression.symbol.owner - val parent = field.parent - return when { - field.origin == IrDeclarationOrigin.PROPERTY_BACKING_FIELD && - parent is IrClass && - parent.multiFieldValueClassRepresentation?.containsPropertyWithName(field.name) == true -> { - val receiver = expression.receiver?.transform(this, null) - with(valueDeclarationsRemapper) { - with(context.createIrBuilder(expression.symbol)) { - receiver?.let { subfield(it, field.name) } ?: run { - expression.receiver = receiver - expression - } - } - } - } - field.origin == IrDeclarationOrigin.PROPERTY_BACKING_FIELD && !field.type.isNullable() && field.type.isMultiFieldValueClassType() -> { - val getter = regularClassMFVCPropertyMainGetters[expression.receiver!!.type.erasedUpperBound]?.get(field.name) - ?: return super.visitGetField(expression) - with(context.createIrBuilder(expression.symbol)) { - irCall(getter).apply { - require(getter.typeParameters.isEmpty()) { "Getter with type parameters: ${getter.render()}" } - dispatchReceiver = expression.receiver!!.transform(this@JvmMultiFieldValueClassLowering, null) - } - } - } - else -> super.visitGetField(expression) - } + expression.receiver = expression.receiver?.transform(this, null) + return valueDeclarationsRemapper.makeReplacement(context.createIrBuilder(expression.symbol), expression) + ?: expression } override fun visitSetField(expression: IrSetField): IrExpression { - val field = expression.symbol.owner - val replacementFields = regularClassMFVCPropertyFieldsMapping[field] ?: return super.visitSetField(expression) - return context.createIrBuilder(expression.symbol).irBlock { - val thisVar = expression.receiver?.let { irTemporary(it.transform(this@JvmMultiFieldValueClassLowering, null)) } - // We flatten to temp variables because code can throw an exception otherwise and partially update variables - val subValues = flattenExpressionToGetters( - expression = expression.value, // not modified - types = replacementFields.map { it.type }, - additionalConditionForValue = { (_, value) -> value is IrGetValue } - ) - for ((replacementField, subValue) in replacementFields zip subValues) { - +irSetField(thisVar?.let { irGet(it) }, replacementField, subValue) - } - } + expression.receiver = expression.receiver?.transform(this, null) + return valueDeclarationsRemapper.makeReplacement( + context.createIrBuilder(getCurrentScopeSymbol()), expression, safe = expression.origin != UNSAFE_MFVC_SET_ORIGIN + ) ?: expression.also { it.value = it.value.transform(this, null) } } - override fun visitGetValue(expression: IrGetValue): IrExpression = with(context.createIrBuilder(expression.symbol)) { + override fun visitGetValue(expression: IrGetValue): IrExpression = with(context.createIrBuilder(getCurrentScopeSymbol())) b@{ with(valueDeclarationsRemapper) { - getter(expression.symbol) ?: super.visitGetValue(expression) + this.makeReplacement(this@b, expression) ?: super.visitGetValue(expression) } } - override fun visitSetValue(expression: IrSetValue): IrExpression { - val setters = valueDeclarationsRemapper.setter(expression.symbol) ?: return super.visitSetValue(expression) - return context.createIrBuilder(expression.symbol).irBlock { - val declarations = replacements.getDeclarations(expression.symbol.owner.type.erasedUpperBound)!! - // We flatten to temp variables because code can throw an exception otherwise and partially update variables - val modifiedExpression = expression.value.transform(this@JvmMultiFieldValueClassLowering, null) - val currentDeclarationReplacementSymbols = valueDeclarationsRemapper.implementationAgnostic(modifiedExpression)?.symbols - ?.mapIndexedNotNull { index, symbol -> symbol?.to(index) }?.toMap() ?: emptyMap() - val subValues = flattenExpressionToGetters( - expression = expression.value, // not modified - types = declarations.leaves.map { it.type }, - additionalConditionForValue = { (index, value) -> - value is IrGetValue && currentDeclarationReplacementSymbols[value.symbol].let { it == null || it <= index } - } - ) - for ((setter, subValue) in setters zip subValues) { - setter?.invoke(this, subValue)?.let { +it } - } - } + override fun visitSetValue(expression: IrSetValue): IrExpression = with(context.createIrBuilder(getCurrentScopeSymbol())) b@{ + with(valueDeclarationsRemapper) { + this.makeReplacement(this@b, expression, safe = expression.origin != UNSAFE_MFVC_SET_ORIGIN) + } ?: super.visitSetValue(expression) } override fun visitVariable(declaration: IrVariable): IrStatement { val initializer = declaration.initializer - if (declaration.type.isMultiFieldValueClassType() && !declaration.type.isNullable()) { + if (declaration.type.needsMfvcFlattening()) { val irClass = declaration.type.erasedUpperBound - val declarations = replacements.getDeclarations(irClass)!! - return context.createIrBuilder((currentScope!!.irElement as IrSymbolOwner).symbol).irComposite { - val variables = declarations.leaves.map { leaf -> - irTemporary( - nameHint = "${declaration.name.asString()}$${declarations.nodeFullNames[leaf]!!.asString()}", - irType = leaf.type, - isMutable = declaration.isVar - ) - } + 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, variables.toGettersAndSetters()) + flattenExpressionTo(it, instance) } - valueDeclarationsRemapper.remapSymbol(declaration.symbol, variables.map { VirtualProperty(it) }, declarations) } } return super.visitVariable(declaration) } - private fun List.toGettersAndSetters() = map { variable -> - Pair( - { irGet(variable) }, - { value: IrExpression -> irSet(variable, value) } - ) - } - - private fun List.toGettersAndSetters(receiver: IrValueParameter?, transformReceiver: Boolean = false) = map { field -> - Pair( - { - val initialGetReceiver = receiver?.let { irGet(it) } - val resultReceiver = - if (transformReceiver) initialGetReceiver?.transform(this@JvmMultiFieldValueClassLowering, null) - else initialGetReceiver - irGetField(resultReceiver, field) - }, - { value: IrExpression -> - val initialGetReceiver = receiver?.let { irGet(it) } - val resultReceiver = - if (transformReceiver) initialGetReceiver?.transform(this@JvmMultiFieldValueClassLowering, null) - else initialGetReceiver - irSetField(resultReceiver, field, value) - }, - ) - } + private fun getCurrentScopeSymbol() = (currentScope!!.irElement as IrSymbolOwner).symbol // expression takes not transformed first argument - private fun IrBlockBuilder.flattenExpressionToGetters( - expression: IrExpression, - types: List, - additionalConditionForValue: (IndexedValue) -> Boolean, - ): List { - val variables = types.map { irTemporary(irType = it) } - val temporaryBlock = irBlock { - flattenExpressionTo(expression, variables.toGettersAndSetters()) + fun IrBlockBuilder.flattenExpression(expression: IrExpression): List { + if (!expression.type.needsMfvcFlattening()) { + return listOf(expression.transform(this@JvmMultiFieldValueClassLowering, null)) } - val satisfyingSetVariableSymbols = temporaryBlock.statements.mapIndexed { index, blockStatement -> - (blockStatement as? IrSetValue)?.takeIf { additionalConditionForValue(IndexedValue(index, it.value)) }?.symbol + 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 + ) } - return if (variables.map { it.symbol } == satisfyingSetVariableSymbols) { - temporaryBlock.statements.map { (it as IrSetValue).value } - } else { - +temporaryBlock - variables.map { irGet(it) } + val instance = ValueDeclarationMfvcNodeInstance(this, rootMfvcNode, typeArguments, variables, listOf()) + val block = irBlock { + flattenExpressionTo(expression, instance) } + val expressions = removeExtraSetVariablesFromExpressionList(block, variables) + if (block.statements.isNotEmpty()) { + +block + } + return expressions } - fun IrBlockBuilder.flattenExpressionTo( - expression: IrExpression, variables: List> - ) { - val declarations = replacements.getDeclarations(expression.type.erasedUpperBound) ?: run { - val constructor = (expression as? IrConstructorCall)?.symbol?.owner ?: return@run null - replacements.getDeclarations(constructor.constructedClass) - } - - if (expression.type.isNullable() || declarations == null) { - require(variables.size == 1) - +variables.single().second(this, expression.transform(this@JvmMultiFieldValueClassLowering, null)) + 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(variables.size == declarations.leaves.size) + require(rootNode.leavesCount == instance.size) { + "Required ${rootNode.leavesCount} variable/field to store regular value but got ${instance.size}" + } if (expression is IrConstructorCall) { val constructor = expression.symbol.owner - if (constructor.isPrimary && constructor.constructedClass.isMultiFieldValueClass) { + if (constructor.isPrimary && constructor.constructedClass.isMultiFieldValueClass && + constructor.origin != JvmLoweredDeclarationOrigin.STATIC_MULTI_FIELD_VALUE_CLASS_CONSTRUCTOR + ) { val oldArguments = List(expression.valueArgumentsCount) { expression.getValueArgument(it) } - val root = declarations.loweringRepresentation - require(root.fields.size == oldArguments.size) { - "$constructor must have ${root.fields.size} arguments but got ${oldArguments.size}" + require(rootNode.subnodes.size == oldArguments.size) { + "Old ${constructor.render()} must have ${rootNode.subnodes.size} arguments but got ${oldArguments.size}" } - var curOffset = 0 - for ((treeField, argument) in root.fields zip oldArguments) { - val size = when (treeField.node) { - is InternalNode -> replacements.getDeclarations(treeField.node.irClass)!!.leaves.size - is Leaf -> 1 - } - val subVariables = variables.slice(curOffset until (curOffset + size)).also { curOffset += size } - argument?.let { flattenExpressionTo(it, subVariables) } + for ((subnode, argument) in rootNode.subnodes zip oldArguments) { + argument?.let { flattenExpressionTo(it, instance[subnode.name]!!) } } - +irCall(declarations.primaryConstructorImpl).apply { + +irCall(rootNode.primaryConstructorImpl).apply { copyTypeArgumentsFrom(expression) - variables.forEachIndexed { index, variable -> putValueArgument(index, variable.first(this@flattenExpressionTo)) } + for ((index, leafExpression) in instance.makeFlattenedGetterExpressions().withIndex()) { + putValueArgument(index, leafExpression) + } } return } } val transformedExpression = expression.transform(this@JvmMultiFieldValueClassLowering, null) - valueDeclarationsRemapper.implementationAgnostic(transformedExpression)?.virtualFields?.map { it.makeGetter(this) }?.let { - require(variables.size == it.size) - for ((variable, subExpression) in variables zip it) { - +variable.second(this, subExpression) - } - return - } - if (transformedExpression is IrCall) { - val callee = transformedExpression.symbol.owner - if (callee == declarations.boxMethod) { - require(transformedExpression.valueArgumentsCount == declarations.fields.size) { - "Bad arguments number for box-method: ${transformedExpression.valueArgumentsCount}" - } - for ((variable, argument) in variables zip List(transformedExpression.valueArgumentsCount) { - transformedExpression.getValueArgument(it) - }) { - if (argument != null) { - +variable.second(this, argument) - } - } - return - } - } - (transformedExpression as? IrCall)?.let { makeLeavesGetters(it.symbol.owner) }?.let { getters -> - val receiver = irTemporary(transformedExpression.dispatchReceiver) - require(getters.size == variables.size) { "Number of getters must be equal to number of variables" } - for ((variable, getter) in variables zip getters) { - require(getter.typeParameters.isEmpty()) { "Getter with type parameters: ${getter.render()}" } - +variable.second(this, irCall(getter).apply { dispatchReceiver = irGet(receiver) }) - } - return - } - if (transformedExpression is IrContainerExpression && transformedExpression.statements.isNotEmpty()) { - val last = transformedExpression.statements.popLast() + val flattenedExpressionInstance: MfvcNodeInstance? = valueDeclarationsRemapper.getMfvcNodeInstanceIfIsGetter(transformedExpression) + ?.also { flattenedInstance -> flattenedInstance.initializationStatements.forEach { +it } } + if (flattenedExpressionInstance == null && transformedExpression is IrContainerExpression && transformedExpression.statements.isNotEmpty()) { + val last = transformedExpression.statements.last() if (last is IrExpression) { - transformedExpression.statements.forEach { +it } - flattenExpressionTo(last, variables) + fun irContainer(builder: IrBlockBuilder.() -> Unit) = + if (transformedExpression.isTransparentScope) irComposite { builder() } else irBlock { builder() } + + +irContainer { + for (statement in transformedExpression.statements.dropLast(1)) { + +statement + } + flattenExpressionTo(last, instance) + } return } } - val boxed = irTemporary(transformedExpression) - for ((variable, unboxMethod) in variables zip declarations.unboxMethods) { - +variable.second(this, irCall(unboxMethod).apply { dispatchReceiver = irGet(boxed) }) - } + val expressionInstance = flattenedExpressionInstance ?: rootNode.createInstanceFromBox( + this, + transformedExpression, + hasAccessToPrivateMembersOf(rootNode.mfvc), + ::variablesSaver, + ) + require(expressionInstance.size == instance.size) { "Incompatible assignment sizes: ${expressionInstance.size}, ${instance.size}" } + instance.addSetterStatements(this, expressionInstance.makeFlattenedGetterExpressions()) } - override fun visitContainerExpression(expression: IrContainerExpression): IrExpression { - return super.visitContainerExpression(expression).apply { expression.accept(ExtraBoxesRemover(), false) } - } + private fun hasAccessToPrivateMembersOf(parent: IrClass): Boolean = + currentScope?.irElement?.let { hasAccessToPrivateMembersOf(it, parent) } == true - override fun visitBlockBody(body: IrBlockBody): IrBody { - return super.visitBlockBody(body).apply { body.accept(ExtraBoxesRemover(), true) } - } - - private val visitedContainersLastStatement = mutableMapOf() - - private inner class ExtraBoxesRemover : IrElementVisitor { - - // Removing box-impl's but not getters because they are auto-generated - private fun IrExpression.isBoxCallStatement() = this is IrCall && valueDeclarationsRemapper.implementationAgnostic(this) != null && - List(valueArgumentsCount) { getValueArgument(it) }.all { it == null || it is IrGetField || it is IrGetValue } - - private fun IrStatement.coercionToUnitArgument() = - (this as? IrTypeOperatorCall)?.takeIf { it.operator == IrTypeOperator.IMPLICIT_COERCION_TO_UNIT }?.argument - - private fun IrStatement.isBoxCallStatement(): Boolean { - val coercionToUnitArgument = coercionToUnitArgument() - if (coercionToUnitArgument?.isBoxCallStatement() == true || this is IrExpression && this.isBoxCallStatement()) { - return true + fun IrBody.removeAllExtraBoxes() { + accept(object : IrElementVisitor { + override fun visitElement(element: IrElement, data: Boolean) { + element.acceptChildren(this, true) } - if (coercionToUnitArgument is IrStatementContainer) { - coercionToUnitArgument.accept(this@ExtraBoxesRemover, true) + + override fun visitTypeOperator(expression: IrTypeOperatorCall, data: Boolean) { + expression.acceptChildren(this, data) } - return false - } - override fun visitElement(element: IrElement, data: Boolean) = Unit + private tailrec fun getFunctionCallOrNull(statement: IrStatement): IrCall? = when (statement) { + is IrTypeOperatorCall -> getFunctionCallOrNull(statement.argument) + is IrCall -> statement + else -> null + } - override fun visitContainerExpression(expression: IrContainerExpression, data: Boolean) { - visitStatementContainer(expression, data) - } + override fun visitFunction(declaration: IrFunction, data: Boolean) = Unit - override fun visitBlockBody(body: IrBlockBody, data: Boolean) { - visitStatementContainer(body, true) // we last body statement is always not used. - } + override fun visitClass(declaration: IrClass, data: Boolean) = Unit - private fun visitStatementContainer(expression: IrStatementContainer, isInnerContainer: Boolean) { - visitedContainersLastStatement[expression]?.let { visitedLastStatement -> - if (!visitedLastStatement && isInnerContainer) { - visitedContainersLastStatement[expression] = true - expression.statements.lastOrNull()?.let { - if (it.isBoxCallStatement()) { - expression.statements.popLast() - } else { - it.accept(this, true) - } + override fun visitContainerExpression(expression: IrContainerExpression, data: Boolean) { + handleStatementContainer(expression, data) + } + + override fun visitBlockBody(body: IrBlockBody, data: Boolean) { + handleStatementContainer(body, data) + } + + private fun handleStatementContainer(expression: IrStatementContainer, resultIsUsed: Boolean) { + expression.statements.dropLast(1).forEach { it.accept(this, false) } + expression.statements.lastOrNull()?.accept(this, resultIsUsed) + val indexesToRemove = mutableListOf() + for (i in 0 until (expression.statements.size - if (resultIsUsed) 1 else 0)) { + val call = getFunctionCallOrNull(expression.statements[i]) ?: continue + val node = replacements.getRootMfvcNode(call.type.erasedUpperBound) ?: continue + if (node.boxMethod == call.symbol.owner && List(call.valueArgumentsCount) { call.getValueArgument(it) }.all { it.isRepeatableGetter() }) { + indexesToRemove.add(i) } } - return - } - visitedContainersLastStatement[expression] = isInnerContainer - val statementsToRemove = mutableListOf() - for (i in 0 until expression.statements.size) { - val isInnerStatement = isInnerContainer || i < expression.statements.lastIndex - if (isInnerStatement && expression.statements[i].isBoxCallStatement()) { - statementsToRemove.add(expression.statements[i]) - } else { - expression.statements[i].accept(this, isInnerStatement) + if (indexesToRemove.isNotEmpty()) { + expression.statements.replaceAll(expression.statements.filterIndexed { index, _ -> index !in indexesToRemove }) } } - expression.statements.removeAll(statementsToRemove) + }, false) + } +} + +private sealed class BlockOrBody { + data class Body(val body: IrBody) : BlockOrBody() + data class Block(val block: IrBlock) : BlockOrBody() +} + +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 } } - private fun IrSimpleFunction.isDefaultGetter(field: IrField): Boolean = - ((body?.statements?.singleOrNull() as? IrReturn)?.value as? IrGetField)?.symbol?.owner == field + return variables.associateWith { dfs(BlockOrBody.Body(body), it) } +} + +private fun IrStatement.containsUsagesOf(variablesSet: Set): Boolean { + var used = false + acceptVoid(object : IrElementVisitorVoid { + override fun visitExpression(expression: IrExpression) { + if (!used) { + expression.acceptChildrenVoid(this) + } + } + + override fun visitValueAccess(expression: IrValueAccessExpression) { + if (expression.symbol.owner in variablesSet) { + used = true + } + super.visitValueAccess(expression) + } + }) + return used +} + +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 = sequence { + for ((variable, statement) in variables.asSequence() zip getFlattenedStatements(container)) { + when { + variable.initializer != null -> break + statement !is IrSetValue -> break + statement.symbol.owner != variable -> break + else -> yield(statement.value) + } + } + }.toList() + + for ((variable, value) in variables zip values) { + variable.initializer = value + } + removeFlattenedStatements(container, values.size) + container.statements.addAll(0, statementsWithoutUsages + variables) + } + + override fun visitBlock(expression: IrBlock): IrExpression { + containingVariables[Block(expression)]?.let { + expression.transformChildrenVoid() + replaceSetVariableWithInitialization(it, expression) + return expression + } + return super.visitBlock(expression) + } + + override fun visitBlockBody(body: IrBlockBody): IrBody { + containingVariables[BlockOrBody.Body(body)]?.let { + body.transformChildrenVoid() + replaceSetVariableWithInitialization(it, body) + return body + } + return super.visitBlockBody(body) + } + + override fun visitExpressionBody(body: IrExpressionBody): IrBody { + val lowering = this + containingVariables[BlockOrBody.Body(body)]?.takeIf { it.isNotEmpty() }?.let { bodyVars -> + val blockBody = context.createJvmIrBuilder(symbol).irBlockBody { + +irReturn(body.expression.transform(lowering, null)) + } + blockBody.transformChildrenVoid() + replaceSetVariableWithInitialization(bodyVars, blockBody) + return blockBody + } + return super.visitExpressionBody(body) + } + }, null) +} + +private fun MutableList.replaceAll(replacement: List) { + clear() + addAll(replacement) } diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmValueClassAbstractLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmValueClassAbstractLowering.kt index 40e8064b5b8..0d97298e627 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 @@ -31,8 +31,6 @@ internal abstract class JvmValueClassAbstractLowering(val context: JvmBackendCon abstract fun IrClass.isSpecificLoweringLogicApplicable(): Boolean - abstract fun IrFunction.isFieldGetterToRemove(): Boolean - abstract override fun visitClassNew(declaration: IrClass): IrStatement abstract fun handleSpecificNewClass(declaration: IrClass) @@ -46,7 +44,7 @@ internal abstract class JvmValueClassAbstractLowering(val context: JvmBackendCon if (replacement == null) { if (function is IrConstructor) { - val constructorReplacement = replacements.getReplacementRegularClassConstructor(function) + val constructorReplacement = replacements.getReplacementForRegularClassConstructor(function) if (constructorReplacement != null) { addBindingsFor(function, constructorReplacement) return transformFlattenedConstructor(function, constructorReplacement) @@ -107,7 +105,7 @@ internal abstract class JvmValueClassAbstractLowering(val context: JvmBackendCon it.transformChildrenVoid() it.defaultValue?.patchDeclarationParents(replacement) } - allScopes.push(createScope(function)) + allScopes.push(createScope(replacement)) replacement.body = function.body?.transform(this, null)?.patchDeclarationParents(replacement) allScopes.pop() replacement.copyAttributes(function) @@ -127,7 +125,9 @@ internal abstract class JvmValueClassAbstractLowering(val context: JvmBackendCon if (suffix != null && target.name.asString().endsWith(suffix)) return super.visitReturn(expression) - replacements.getReplacementFunction(target)?.let { + replacements.run { + getReplacementFunction(target) ?: if (target is IrConstructor) getReplacementForRegularClassConstructor(target) else null + }?.let { return context.createIrBuilder(it.symbol, expression.startOffset, expression.endOffset).irReturn( expression.value.transform(this, null) ) @@ -145,12 +145,12 @@ internal abstract class JvmValueClassAbstractLowering(val context: JvmBackendCon } } - override fun visitContainerExpression(expression: IrContainerExpression): IrExpression { + final override fun visitContainerExpression(expression: IrContainerExpression): IrExpression { visitStatementContainer(expression) return expression } - override fun visitBlockBody(body: IrBlockBody): IrBody { + final override fun visitBlockBody(body: IrBlockBody): IrBody { visitStatementContainer(body) return body } @@ -164,6 +164,8 @@ internal abstract class JvmValueClassAbstractLowering(val context: JvmBackendCon 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 @@ -173,9 +175,10 @@ internal abstract class JvmValueClassAbstractLowering(val context: JvmBackendCon 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) && - function.signatureRequiresMangling() -> - replacement.name + (!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 -> diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/MultiFieldValueClassRepresentations.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/MultiFieldValueClassRepresentations.kt deleted file mode 100644 index 3409c2824fb..00000000000 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/MultiFieldValueClassRepresentations.kt +++ /dev/null @@ -1,202 +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.lower - -import org.jetbrains.kotlin.backend.jvm.MultiFieldValueClassSpecificDeclarations -import org.jetbrains.kotlin.backend.jvm.MultiFieldValueClassTree -import org.jetbrains.kotlin.backend.jvm.ir.erasedUpperBound -import org.jetbrains.kotlin.ir.builders.* -import org.jetbrains.kotlin.ir.declarations.* -import org.jetbrains.kotlin.ir.expressions.IrExpression -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.typeOrNull -import org.jetbrains.kotlin.ir.util.defaultType -import org.jetbrains.kotlin.ir.util.render -import org.jetbrains.kotlin.ir.util.substitute -import org.jetbrains.kotlin.name.Name - -typealias TypeArguments = Map - -sealed interface MFVCRepresentation { - operator fun get(name: Name): MFVCRepresentation? - fun IrBuilderWithScope.makeGetter(): IrExpression - val type: IrSimpleType - val children: List>> - val leaves: List -} - -sealed interface MutableMFVCRepresentation : MFVCRepresentation -sealed interface RecursivelyMutableMFVCRepresentation : MutableMFVCRepresentation - -interface MFVCLeafRepresentation : MFVCRepresentation { - override fun get(name: Name): Nothing? = null - override val children: List>> - get() = emptyList() - override val leaves: List - get() = emptyList() -} - -interface MutableMFVCLeafRepresentation : MFVCLeafRepresentation, RecursivelyMutableMFVCRepresentation { - fun IrBuilderWithScope.makeSetter(value: IrExpression): IrExpression -} - -sealed class ValueDeclarationLeafRepresentation(open val valueDeclaration: IrValueDeclaration) : MFVCLeafRepresentation { - override fun IrBuilderWithScope.makeGetter(): IrExpression = irGet(valueDeclaration) - override val type: IrSimpleType - get() = valueDeclaration.type as IrSimpleType -} - -data class VariableLeafRepresentation(override val valueDeclaration: IrVariable) : ValueDeclarationLeafRepresentation(valueDeclaration), - MutableMFVCLeafRepresentation { - override fun IrBuilderWithScope.makeSetter(value: IrExpression): IrExpression = irSet(valueDeclaration, value) -} - -data class ValueParameterLeafRepresentation(override val valueDeclaration: IrValueParameter) : - ValueDeclarationLeafRepresentation(valueDeclaration) - -sealed class ReceiverBasedLeafRepresentation(open val receiver: IrValueDeclaration) : MFVCLeafRepresentation { - protected fun makeTypeParametersMapping(): Map { - val type = receiver.type as IrSimpleType - return (type.erasedUpperBound.typeParameters zip type.arguments) - .mapNotNull { (parameter, argument) -> argument.typeOrNull?.let { parameter.symbol to it } }.toMap() - } -} - -data class FieldAccessLeafRepresentation(override val receiver: IrValueDeclaration, val field: IrField) : - ReceiverBasedLeafRepresentation(receiver), MutableMFVCLeafRepresentation { - override fun IrBuilderWithScope.makeGetter(): IrExpression = irGetField(irGet(receiver), field) - override fun IrBuilderWithScope.makeSetter(value: IrExpression): IrExpression = irSetField(irGet(receiver), field, value) - override val type: IrSimpleType = field.type.substitute(makeTypeParametersMapping()) as IrSimpleType -} - -data class GetterLeafRepresentation(override val receiver: IrValueDeclaration, val getter: IrFunction) : - ReceiverBasedLeafRepresentation(receiver) { - init { - require(getter.typeParameters.isEmpty()) { "Getter ${getter.render()} must have no type parameters" } - } - - override fun IrBuilderWithScope.makeGetter(): IrExpression = irCall(getter).apply { - dispatchReceiver = irGet(receiver) - } - - override val type: IrSimpleType = getter.returnType.substitute(makeTypeParametersMapping()) as IrSimpleType -} - -private fun getChildType( - declarations: MultiFieldValueClassSpecificDeclarations, - typeMapping: Map, - name: Name, -): IrSimpleType? = declarations.loweringRepresentation[name]?.type?.substitute(typeMapping) as IrSimpleType? - - -private fun , Leaf : T, InternalNode : T> makeTree( - node: MultiFieldValueClassTree, - typeArguments: TypeArguments, - createInternalNode: (type: IrSimpleType, typeArguments: TypeArguments, node: MultiFieldValueClassTree, children: List>) -> InternalNode, - createLeaf: (type: IrType, node: MultiFieldValueClassTree) -> Leaf, -): T = when (node) { - is MultiFieldValueClassTree.InternalNode -> { - val type = node.type.substitute(typeArguments) as IrSimpleType - val children = node.fields.map { it.name to makeTree(it.node, typeArguments, createInternalNode, createLeaf) } - createInternalNode(type, typeArguments, node, children) - } - is MultiFieldValueClassTree.Leaf -> createLeaf(node.type.substitute(typeArguments), node) -} - -sealed interface InternalNodeRepresentation : MFVCRepresentation - -abstract class InternalNodeRepresentationImpl( - val declarations: MultiFieldValueClassSpecificDeclarations, - val typeArguments: TypeArguments, - final override val children: List>>, -) : InternalNodeRepresentation { - final override val type: IrSimpleType = declarations.valueClass.defaultType.substitute(typeArguments) as IrSimpleType - - final override val leaves: List = children.flatMap { (_, node) -> node.leaves } - - private val childrenMap = children.toMap() - - final override fun get(name: Name): MFVCRepresentation? = childrenMap[name] - - final override fun IrBuilderWithScope.makeGetter(): IrExpression = irCall(declarations.boxMethod).apply { - declarations.valueClass.typeParameters.forEachIndexed { index, typeParameter -> - typeArguments[typeParameter.symbol]?.let { putTypeArgument(index, it) } - } - leaves.forEachIndexed { index, leaf -> putValueArgument(index, leaf.run { makeGetter() }) } - } -} - -abstract class MutableInternalNodeRepresentation( - declarations: MultiFieldValueClassSpecificDeclarations, - typeArguments: TypeArguments, - children: List>> -) : InternalNodeRepresentationImpl(declarations, typeArguments, children), MutableMFVCRepresentation { - abstract fun IrBuilderWithScope.makeSetter(values: List): IrExpression -} - -abstract class RecursivelyMutableInternalNodeRepresentation( - declarations: MultiFieldValueClassSpecificDeclarations, - typeArguments: TypeArguments, - children: List>>, -) : MutableInternalNodeRepresentation(declarations, typeArguments, children), RecursivelyMutableMFVCRepresentation { - final override fun IrBuilderWithScope.makeSetter(values: List): IrExpression { - require(values.size == leaves.size) { "Expected ${leaves.size} expressions but found ${values.size} of them" } - return irComposite { - for ((leaf, value) in leaves zip values) { - +leaf.run { makeSetter(value) } - } - } - } -} - -sealed interface ValueDeclarationInternalNodeRepresentation : InternalNodeRepresentation - -class MutableValueDeclarationInternalNodeRepresentation( - declarations: MultiFieldValueClassSpecificDeclarations, - typeArguments: TypeArguments, - children: List>>, -) : ValueDeclarationInternalNodeRepresentation, - RecursivelyMutableInternalNodeRepresentation(declarations, typeArguments, children) - -class FieldAccessInternalNodeRepresentation( - declarations: MultiFieldValueClassSpecificDeclarations, - typeArguments: TypeArguments, - children: List>>, -) : RecursivelyMutableInternalNodeRepresentation(declarations, typeArguments, children) - -class RegularClassMFVCInternalNodeRepresentation( - declarations: MultiFieldValueClassSpecificDeclarations, - typeArguments: TypeArguments, - children: List>>, -) : InternalNodeRepresentationImpl(declarations, typeArguments, children) { - init { - leaves.verifyEqualReceivers() - } -} - -private fun List.verifyEqualReceivers() { - val receiver = this[0].receiver - require(all { it.receiver == receiver }) { "Different receivers found in leaves" } -} - -class MutableRegularClassMFVCInternalNodeRepresentation( - declarations: MultiFieldValueClassSpecificDeclarations, - val setter: IrFunction, - typeArguments: TypeArguments, - children: List>>, -) : MutableInternalNodeRepresentation(declarations, typeArguments, children) { - init { - leaves.verifyEqualReceivers() - require(setter.typeParameters.isEmpty()) { "No type parameters are expected for ${setter.render()}" } - } - - override fun IrBuilderWithScope.makeSetter(values: List): IrExpression = irCall(setter).apply { - dispatchReceiver = irGet(leaves[0].receiver) - values.forEachIndexed { index, value -> putValueArgument(index, value) } - } -} 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 e0c73ec613c..bef2254aa76 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 @@ -157,7 +157,7 @@ val IrFunction.isInlineClassFieldGetter: Boolean get() = (parent as? IrClass)?.isSingleFieldValueClass == true && this is IrSimpleFunction && extensionReceiverParameter == null && correspondingPropertySymbol?.let { it.owner.getter == this && it.owner.name == parentAsClass.inlineClassFieldName } == true -val IrFunction.isMultiFieldValueClassOriginalFieldGetter: Boolean +val IrFunction.isMultiFieldValueClassFieldGetter: Boolean get() = (parent as? IrClass)?.isMultiFieldValueClass == true && this is IrSimpleFunction && extensionReceiverParameter == null && correspondingPropertySymbol?.let { val multiFieldValueClassRepresentation = parentAsClass.multiFieldValueClassRepresentation 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 26ced1a787c..cf56f48a706 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt @@ -31,7 +31,6 @@ import org.jetbrains.kotlin.ir.expressions.IrStatementOrigin import org.jetbrains.kotlin.ir.symbols.* import org.jetbrains.kotlin.ir.types.IrType import org.jetbrains.kotlin.ir.types.IrTypeSystemContext -import org.jetbrains.kotlin.ir.types.IrTypeSystemContextImpl import org.jetbrains.kotlin.ir.types.defaultType import org.jetbrains.kotlin.ir.util.SymbolTable import org.jetbrains.kotlin.name.FqName @@ -145,7 +144,7 @@ class JvmBackendContext( val inlineClassReplacements = MemoizedInlineClassReplacements(state.functionsWithInlineClassReturnTypesMangled, irFactory, this) val multiFieldValueClassReplacements = - MemoizedMultiFieldValueClassReplacements(irFactory, this, IrTypeSystemContextImpl(irBuiltIns)) + MemoizedMultiFieldValueClassReplacements(irFactory, this) val continuationClassesVarsCountByType: MutableMap> = hashMapOf() 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 8992a910d32..0e5d339bbd9 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedInlineClassReplacements.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedInlineClassReplacements.kt @@ -252,7 +252,7 @@ class MemoizedInlineClassReplacements( name = InlineClassAbi.mangledNameFor(function, mangleReturnTypes, useOldManglingScheme) } - override val getReplacementRegularClassConstructor: (IrConstructor) -> IrConstructor? = alwaysNull() + override val getReplacementForRegularClassConstructor: (IrConstructor) -> IrConstructor? = alwaysNull() override val replaceOverriddenSymbols: (IrSimpleFunction) -> List = storageManager.createMemoizedFunction { irSimpleFunction -> 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 1768d087c05..51559f23ae8 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 @@ -6,14 +6,19 @@ package org.jetbrains.kotlin.backend.jvm import org.jetbrains.kotlin.backend.jvm.MemoizedMultiFieldValueClassReplacements.RemappedParameter.MultiFieldValueClassMapping -import org.jetbrains.kotlin.backend.jvm.ir.* +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.expressions.IrExpressionBody import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol -import org.jetbrains.kotlin.ir.types.* +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 @@ -25,8 +30,7 @@ import java.util.concurrent.ConcurrentHashMap */ class MemoizedMultiFieldValueClassReplacements( irFactory: IrFactory, - context: JvmBackendContext, - private val typeSystemContext: IrTypeSystemContext + context: JvmBackendContext ) : MemoizedValueClassAbstractReplacements(irFactory, context) { private val storageManager = LockBasedStorageManager("multi-field-value-class-replacements") @@ -34,78 +38,47 @@ class MemoizedMultiFieldValueClassReplacements( val originalFunctionForMethodReplacement: MutableMap = ConcurrentHashMap() private val originalConstructorForConstructorReplacement: MutableMap = ConcurrentHashMap() - val getDeclarations: (IrClass) -> MultiFieldValueClassSpecificDeclarations? = - storageManager.createMemoizedFunctionWithNullableValues { - if (it.isMultiFieldValueClass) - MultiFieldValueClassSpecificDeclarations(it, typeSystemContext, irFactory, context, this) - else - null - } - - val getOldMFVCProperties: (IrClass) -> List = storageManager.createMemoizedFunction { irClass -> - require(irClass.isMultiFieldValueClass) { "No need to save data for non MFVC" } - (irClass.properties.toList().filter { it.getter?.isMultiFieldValueClassOriginalFieldGetter == true }.takeIf { it.isNotEmpty() } - ?: irClass.fields.mapNotNull { it.correspondingPropertySymbol?.owner }.toList().takeIf { it.isNotEmpty() } - ?: error("No properties found: ${irClass.render()}")) - } - - fun commitMFVCOldProperties(irClass: IrClass) { - getOldMFVCProperties(irClass) - } - - class ValueParameterTemplate( - val name: String, - val type: IrType, - val origin: IrDeclarationOrigin?, - val defaultValue: IrExpressionBody?, - val original: IrValueParameter, // todo don't use it as it is not always correct - ) { - - constructor(valueParameter: IrValueParameter, origin: IrDeclarationOrigin?) : this( - name = valueParameter.name.asString(), - type = valueParameter.type, - origin = origin, - defaultValue = valueParameter.defaultValue, - original = valueParameter, - ) - - fun toParameter(irFunction: IrFunction, index: Int): IrValueParameter = original.copyTo( - irFunction = irFunction, - index = index, - name = Name.guessByFirstCharacter(name), - origin = origin ?: original.origin, - defaultValue = null, - type = type, - ).also { - // Assuming that constructors and non-override functions are always replaced with the unboxed - // equivalent, deep-copying the value here is unnecessary. - it.defaultValue = defaultValue?.patchDeclarationParents(irFunction) - } - } - - private fun IrFunction.makeValueParametersFromTemplate(newFlattenedParameters: List) = newFlattenedParameters - .flatMap { it.valueParameters }.mapIndexed { index: Int, template -> template.toParameter(this, index) } - - private fun List.grouped( + private fun IrValueParameter.grouped( + name: String?, substitutionMap: Map, - originWhenFlattenedAndNotSpecified: IrDeclarationOrigin? = IrDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_PARAMETER - ): List = map { parameter -> - val declarations = parameter.type.takeIf { !it.isNullable() }?.erasedUpperBound?.let { getDeclarations(it) } - ?: return@map RemappedParameter.RegularMapping(parameter) - require(!parameter.original.hasDefaultValue()) { "Default parameters values are not supported for multi-field value classes" } - val localSubstitutionMap = declarations.valueClass.typeParameters.zip((parameter.type as IrSimpleType).arguments) - .mapNotNull { (parameter, argument) -> if (argument is IrSimpleType) parameter.symbol to argument.type else null}.toMap() - MultiFieldValueClassMapping(declarations, parameter.type.substitute(substitutionMap) as IrSimpleType, declarations.leaves.map { leaf -> - ValueParameterTemplate( - name = "${parameter.name}$${declarations.nodeFullNames[leaf]!!}", - type = leaf.type.substitute(localSubstitutionMap), - origin = parameter.origin ?: originWhenFlattenedAndNotSpecified, - defaultValue = null, - original = parameter.original, - ) - }) + 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, @@ -115,71 +88,78 @@ class MemoizedMultiFieldValueClassReplacements( 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 makeGroupedValueParametersFrom( - function: IrFunction, includeDispatcherReceiver: Boolean, substitutionMap: Map + private fun makeAndAddGroupedValueParametersFrom( + sourceFunction: IrFunction, + includeDispatcherReceiver: Boolean, + substitutionMap: Map, + targetFunction: IrFunction, ): List { val newFlattenedParameters = mutableListOf() - if (function.dispatchReceiverParameter != null && includeDispatcherReceiver) { - val template = ValueParameterTemplate( - name = "\$dispatchReceiver", - type = function.parentAsClass.defaultType, - origin = IrDeclarationOrigin.MOVED_DISPATCH_RECEIVER, - defaultValue = null, - original = function.parentAsClass.thisReceiver!!, + if (sourceFunction.dispatchReceiverParameter != null && includeDispatcherReceiver) { + newFlattenedParameters.add( + sourceFunction.parentAsClass.thisReceiver!!.grouped( + "\$dispatchReceiver", + substitutionMap, + targetFunction, + IrDeclarationOrigin.MOVED_DISPATCH_RECEIVER, + ) ) - newFlattenedParameters.addAll(listOf(template).grouped(substitutionMap)) } - val contextReceivers = function.valueParameters.take(function.contextReceiverParametersCount) + val contextReceivers = sourceFunction.valueParameters.take(sourceFunction.contextReceiverParametersCount) .mapIndexed { index: Int, valueParameter: IrValueParameter -> - ValueParameterTemplate( - name = "contextReceiver$index", - origin = IrDeclarationOrigin.MOVED_CONTEXT_RECEIVER, - type = valueParameter.type, - defaultValue = valueParameter.defaultValue, - original = valueParameter, + valueParameter.grouped( + "contextReceiver$index", + substitutionMap, + targetFunction, + IrDeclarationOrigin.MOVED_CONTEXT_RECEIVER, ) } - .grouped(substitutionMap) newFlattenedParameters.addAll(contextReceivers) - function.extensionReceiverParameter?.let { - val template = ValueParameterTemplate( - name = Name.identifier(function.extensionReceiverName(context.state)).asString(), - origin = IrDeclarationOrigin.MOVED_EXTENSION_RECEIVER, - type = it.type, - defaultValue = it.defaultValue, - original = it, + sourceFunction.extensionReceiverParameter?.let { + val newParameters = it.grouped( + sourceFunction.extensionReceiverName(context.state), + substitutionMap, + targetFunction, + IrDeclarationOrigin.MOVED_EXTENSION_RECEIVER, ) - newFlattenedParameters.addAll(listOf(template).grouped(substitutionMap)) + newFlattenedParameters.add(newParameters) } - newFlattenedParameters += function.valueParameters.drop(function.contextReceiverParametersCount).map { - ValueParameterTemplate(it, origin = null) - }.grouped(substitutionMap) + newFlattenedParameters += sourceFunction.valueParameters.drop(sourceFunction.contextReceiverParametersCount) + .grouped(name = null, substitutionMap, targetFunction, IrDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_PARAMETER) return newFlattenedParameters } sealed class RemappedParameter { - data class RegularMapping(val valueParameter: ValueParameterTemplate) : RemappedParameter() { - override val valueParameters: List = listOf(valueParameter) + + abstract val valueParameters: List + + data class RegularMapping(val valueParameter: IrValueParameter) : RemappedParameter() { + override val valueParameters: List = listOf(valueParameter) } data class MultiFieldValueClassMapping( - val declarations: MultiFieldValueClassSpecificDeclarations, - val boxedType: IrSimpleType, - override val valueParameters: List, + val rootMfvcNode: RootMfvcNode, + val typeArguments: TypeArguments, + override val valueParameters: List, ) : RemappedParameter() { init { require(valueParameters.size > 1) { "MFVC must have > 1 fields" } } - } - abstract val valueParameters: List + 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() @@ -192,7 +172,7 @@ class MemoizedMultiFieldValueClassReplacements( return super.put(key, value) } } -// todo inline classes pass type arguments correctly + override fun createStaticReplacement(function: IrFunction): IrSimpleFunction = buildReplacement(function, JvmLoweredDeclarationOrigin.STATIC_MULTI_FIELD_VALUE_CLASS_REPLACEMENT, noFakeOverride = true) { originalFunctionForStaticReplacement[this] = function @@ -200,8 +180,8 @@ class MemoizedMultiFieldValueClassReplacements( 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 = makeGroupedValueParametersFrom(function, includeDispatcherReceiver = true, substitutionMap) - valueParameters = makeValueParametersFromTemplate(newFlattenedParameters) + val newFlattenedParameters = + makeAndAddGroupedValueParametersFrom(function, includeDispatcherReceiver = true, substitutionMap, this) bindingOldFunctionToParameterTemplateStructure[function] = newFlattenedParameters bindingNewFunctionToParameterTemplateStructure[this] = newFlattenedParameters } @@ -209,49 +189,32 @@ class MemoizedMultiFieldValueClassReplacements( override fun createMethodReplacement(function: IrFunction): IrSimpleFunction = buildReplacement(function, function.origin) { originalFunctionForMethodReplacement[this] = function dispatchReceiverParameter = function.dispatchReceiverParameter?.copyTo(this, index = -1) - val newFlattenedParameters = makeGroupedValueParametersFrom(function, includeDispatcherReceiver = false, mapOf()) + val newFlattenedParameters = makeAndAddGroupedValueParametersFrom(function, includeDispatcherReceiver = false, mapOf(), this) val receiver = dispatchReceiverParameter - val receiverTemplate = if (receiver != null) ValueParameterTemplate(receiver, origin = receiver.origin) else null val remappedParameters = - if (receiverTemplate != null) listOf(RemappedParameter.RegularMapping(receiverTemplate)) + newFlattenedParameters else newFlattenedParameters - valueParameters = makeValueParametersFromTemplate(newFlattenedParameters) + if (receiver != null) listOf(RemappedParameter.RegularMapping(receiver)) + newFlattenedParameters else newFlattenedParameters bindingOldFunctionToParameterTemplateStructure[function] = remappedParameters bindingNewFunctionToParameterTemplateStructure[this] = remappedParameters } - private fun createConstructorReplacement(@Suppress("UNUSED_PARAMETER") constructor: IrConstructor): IrConstructor { - val newFlattenedParameters = makeGroupedValueParametersFrom(constructor, includeDispatcherReceiver = false, mapOf()) - bindingOldFunctionToParameterTemplateStructure[constructor] = newFlattenedParameters + 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) - valueParameters = makeValueParametersFromTemplate(newFlattenedParameters) annotations = constructor.annotations originalConstructorForConstructorReplacement[this] = constructor + bindingNewFunctionToParameterTemplateStructure[this] = newFlattenedParameters } - bindingNewFunctionToParameterTemplateStructure[newConstructor] = newFlattenedParameters return newConstructor } - private fun createGetterReplacement(function: IrFunction): IrSimpleFunction { - val declarations = getDeclarations(function.parentAsClass)!! - val name = (function as IrSimpleFunction).correspondingPropertySymbol!!.owner.name - val node = declarations.loweringRepresentation[name]!!.node - val newGetter = declarations.properties[node]!!.getter!! - originalFunctionForMethodReplacement[newGetter] = function - val receiver = function.dispatchReceiverParameter!! - val receiverTemplate = ValueParameterTemplate(receiver, origin = receiver.origin) - val parameterRemapping = listOf(RemappedParameter.RegularMapping(receiverTemplate)) - bindingOldFunctionToParameterTemplateStructure[function] = parameterRemapping - bindingNewFunctionToParameterTemplateStructure[newGetter] = parameterRemapping - return newGetter - } - /** - * Get a replacement for a function or a constructor. + * Get a function replacement for a function or a constructor. */ override val getReplacementFunction: (IrFunction) -> IrSimpleFunction? = storageManager.createMemoizedFunctionWithNullableValues { function -> @@ -262,33 +225,38 @@ class MemoizedMultiFieldValueClassReplacements( 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 - function.isMultiFieldValueClassOriginalFieldGetter -> createGetterReplacement(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.isMultiFieldValueClassType() && !it.type.isNullable() } && + function.fullValueParameterList.any { it.type.needsMfvcFlattening() } && (!function.isFakeOverride || findSuperDeclaration(function, false, context.state.jvmDefaultMode) in bindingOldFunctionToParameterTemplateStructure) -> createMethodReplacement(function) + else -> null } } - override val getReplacementRegularClassConstructor: (IrConstructor) -> IrConstructor? = + override val getReplacementForRegularClassConstructor: (IrConstructor) -> IrConstructor? = storageManager.createMemoizedFunctionWithNullableValues { constructor -> when { constructor.constructedClass.isMultiFieldValueClass -> null constructor.isFromJava() -> null - constructor.fullValueParameterList.any { !it.type.isNullable() && it.type.isMultiFieldValueClassType() } -> + constructor.fullValueParameterList.any { it.type.needsMfvcFlattening() } -> createConstructorReplacement(constructor) + else -> null } } @@ -300,5 +268,34 @@ class MemoizedMultiFieldValueClassReplacements( computeOverrideReplacement(it.owner).symbol } } -} + val getRootMfvcNode: (IrClass) -> RootMfvcNode? = storageManager.createMemoizedFunctionWithNullableValues { + if (it.defaultType.needsMfvcFlattening()) getRootNode(context, it) else null + } + + val getRegularClassMfvcPropertyNode: (IrProperty) -> IntermediateMfvcNode? = + storageManager.createMemoizedFunctionWithNullableValues { property: IrProperty -> + val parent = property.parent + when { + parent !is IrClass -> null + property.isFakeOverride -> null + 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 eccdf71dd87..1c7536e77cf 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedValueClassAbstractReplacements.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MemoizedValueClassAbstractReplacements.kt @@ -108,7 +108,7 @@ abstract class MemoizedValueClassAbstractReplacements(protected val irFactory: I abstract val replaceOverriddenSymbols: (IrSimpleFunction) -> List - abstract val getReplacementRegularClassConstructor: (IrConstructor) -> IrConstructor? + abstract val getReplacementForRegularClassConstructor: (IrConstructor) -> IrConstructor? protected fun computeOverrideReplacement(function: IrSimpleFunction): IrSimpleFunction = getReplacementFunction(function) ?: function.also { diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNode.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNode.kt new file mode 100644 index 00000000000..75fa586b62b --- /dev/null +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNode.kt @@ -0,0 +1,474 @@ +/* + * 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.IrStatement +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?, + isPrivateAccess: Boolean, + saveVariable: (IrVariable) -> Unit, + ): ReceiverBasedMfvcNodeInstance +} + +fun MfvcNode.createInstanceFromBox( + scope: IrBlockBuilder, + receiver: IrExpression, + isPrivateAccess: Boolean, + saveVariable: (IrVariable) -> Unit +) = + createInstanceFromBox(scope, makeTypeArgumentsFromType(receiver.type as IrSimpleType), receiver, isPrivateAccess, 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(scope, this, typeArguments, valueDeclarations, listOf()) +} + +fun MfvcNode.createInstanceFromValueDeclarationsAndBoxType( + scope: IrBuilderWithScope, type: IrSimpleType, fieldValues: List, initializationStatements: List +): ValueDeclarationMfvcNodeInstance = + ValueDeclarationMfvcNodeInstance(scope, this, makeTypeArgumentsFromType(type), fieldValues, initializationStatements) + +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() + +} + +private fun MfvcNode.createInstanceFromBoxTypeImpl( + scope: Scope, + boxType: IrSimpleType, + fieldValues: List, + gen: (Scope, MfvcNode, TypeArguments, List) -> Instance +): Instance { + val typeArguments = makeTypeArgumentsFromType(boxType) + return gen(scope, this, typeArguments, fieldValues) +} + +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 requireSameTypes(vararg types: List) { + require(types.asList().zipWithNext { a, b -> a == b }.all { it }) { + "Found different types: ${types.joinToString("\n") { list -> list.map { it.render() }.toString() }}" + } +} + +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?, + isPrivateAccess: Boolean, + saveVariable: (IrVariable) -> Unit, + ) = ReceiverBasedMfvcNodeInstance( + scope, this, typeArguments, receiver, field?.let(::listOf), unboxMethod, isPrivateAccess, 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?, + isPrivateAccess: Boolean, + saveVariable: (IrVariable) -> Unit, + ) = ReceiverBasedMfvcNodeInstance( + scope, this, typeArguments, receiver, fields, unboxMethod, isPrivateAccess, 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?, + isPrivateAccess: Boolean, + saveVariable: (IrVariable) -> Unit, + ) = ReceiverBasedMfvcNodeInstance(scope, this, typeArguments, receiver, fields, null, isPrivateAccess, 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/MfvcNodeFabric.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNodeFabric.kt new file mode 100644 index 00000000000..94c3f25e38b --- /dev/null +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNodeFabric.kt @@ -0,0 +1,486 @@ +/* + * 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) + } + + return IntermediateMfvcNode( + type, rootPropertyName, nameParts, subnodes, unboxMethod, defaultMethodsImplementationSourceNode.isPure(), 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.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 hasAccessToPrivateMembersOf(currentElement: IrElement?, parent: IrClass): Boolean { + val declaration = currentElement as? IrDeclaration ?: return false + for (cur in declaration.parents.filterIsInstance()) { + return when { + cur == parent -> true + cur.isInner -> continue + else -> false + } + } + return false +} + +private fun IrProperty.getterIfDeclared(parent: IrDeclarationContainer): IrSimpleFunction? = getter?.takeIf { it in parent.declarations } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNodeInstance.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNodeInstance.kt new file mode 100644 index 00000000000..8d1de218d19 --- /dev/null +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MfvcNodeInstance.kt @@ -0,0 +1,270 @@ +/* + * 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 scope: IrBuilderWithScope + val node: MfvcNode + val typeArguments: TypeArguments + val type: IrSimpleType + val initializationStatements: List + + fun makeFlattenedGetterExpressions(): List + fun makeGetterExpression(): IrExpression + operator fun get(name: Name): MfvcNodeInstance? + fun makeStatements(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(values)) { + +statement + } +} + +fun MfvcNodeInstance.makeSetterExpressions(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 scope: IrBuilderWithScope, + override val node: MfvcNode, + override val typeArguments: TypeArguments, + val valueDeclarations: List, + override val initializationStatements: 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(): List = valueDeclarations.map { scope.irGet(it) } + + override fun makeGetterExpression(): IrExpression = when (node) { + is LeafMfvcNode -> makeFlattenedGetterExpressions().single() + is MfvcNodeWithSubnodes -> node.makeBoxedExpression(scope, typeArguments, makeFlattenedGetterExpressions()) + } + + override fun get(name: Name): ValueDeclarationMfvcNodeInstance? { + val (newNode, indices) = node.getSubnodeAndIndices(name) ?: return null + return ValueDeclarationMfvcNodeInstance(scope, newNode, typeArguments, valueDeclarations.slice(indices), initializationStatements) + } + + override fun makeStatements(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 val saveReceiverSetter: (IrSetValue) -> 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, + saveSetter = saveReceiverSetter, + ) + ) + + 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() + +class ReceiverBasedMfvcNodeInstance( + override val scope: IrBlockBuilder, + override val node: MfvcNode, + override val typeArguments: TypeArguments, + receiver: IrExpression?, + val fields: List?, + val unboxMethod: IrSimpleFunction?, + val isPrivateAccess: Boolean, + private val saveVariable: (IrVariable) -> Unit, +) : MfvcNodeInstance { + override val type: IrSimpleType = makeTypeFromMfvcNodeAndTypeArguments(node, typeArguments) + + override val initializationStatements: List = mutableListOf() + private val receiverCopier = ExpressionCopierImpl( + receiver, scope, saveVariable, saveReceiverSetter = { (initializationStatements as MutableList).add(it) } + ) + + 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(): List = when (node) { + is LeafMfvcNode -> listOf(makeGetterExpression()) + is MfvcNodeWithSubnodes -> when { + node is IntermediateMfvcNode && isPrivateAccess && fields != null -> fields.map { scope.irGetField(makeReceiverCopy(), it) } + node is IntermediateMfvcNode && !node.hasPureUnboxMethod -> { + val value = makeGetterExpression() + 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), isPrivateAccess = false, saveVariable) + variableInstance.makeFlattenedGetterExpressions() + } + + else -> node.subnodes.flatMap { get(it.name)!!.makeFlattenedGetterExpressions() } + } + } + + override fun makeGetterExpression(): IrExpression = with(scope) { + when { + node is LeafMfvcNode && isPrivateAccess && fields != null -> irGetField(makeReceiverCopy(), fields.single()) + node is IntermediateMfvcNode && isPrivateAccess && 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") + } + } + + override fun get(name: Name): ReceiverBasedMfvcNodeInstance? { + val (newNode, _) = node.getSubnodeAndIndices(name) ?: return null + return newNode.createInstanceFromBox(scope, typeArguments, makeReceiverCopy(), isPrivateAccess, saveVariable) + } + + override fun makeStatements(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.unwrap(): IrExpression = statements.singleOrNull() as? IrExpression ?: this + +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 +} + +fun IrStatementsBuilder.savableStandaloneVariableWithSetter( + expression: IrExpression, + name: String? = null, + isMutable: Boolean = false, + origin: IrDeclarationOrigin, + isTemporary: Boolean = origin == IrDeclarationOrigin.IR_TEMPORARY_VARIABLE, + saveSetter: (IrSetValue) -> Unit = {}, + saveVariable: (IrVariable) -> Unit, +) = savableStandaloneVariable(expression.type, name, isMutable, origin, isTemporary, saveVariable).also { + +irSet(it, expression).also(saveSetter) +} \ No newline at end of file diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MultiFieldValueClassSpecificDeclarations.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MultiFieldValueClassSpecificDeclarations.kt deleted file mode 100644 index 346be9e434e..00000000000 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/MultiFieldValueClassSpecificDeclarations.kt +++ /dev/null @@ -1,527 +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.pop -import org.jetbrains.kotlin.backend.jvm.MultiFieldValueClassTree.InternalNode -import org.jetbrains.kotlin.backend.jvm.MultiFieldValueClassTree.Leaf -import org.jetbrains.kotlin.backend.jvm.ir.erasedUpperBound -import org.jetbrains.kotlin.backend.jvm.ir.isMultiFieldValueClassType -import org.jetbrains.kotlin.backend.jvm.ir.upperBound -import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper -import org.jetbrains.kotlin.descriptors.DescriptorVisibilities -import org.jetbrains.kotlin.descriptors.DescriptorVisibility -import org.jetbrains.kotlin.descriptors.Modality -import org.jetbrains.kotlin.descriptors.MultiFieldValueClassRepresentation -import org.jetbrains.kotlin.ir.IrStatement -import org.jetbrains.kotlin.ir.builders.* -import org.jetbrains.kotlin.ir.builders.declarations.* -import org.jetbrains.kotlin.ir.declarations.* -import org.jetbrains.kotlin.ir.expressions.IrConstructorCall -import org.jetbrains.kotlin.ir.expressions.IrExpression -import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrGetField -import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol -import org.jetbrains.kotlin.ir.symbols.IrValueSymbol -import org.jetbrains.kotlin.ir.types.* -import org.jetbrains.kotlin.ir.util.* -import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.renderer.render -import org.jetbrains.kotlin.resolve.InlineClassDescriptorResolver - -sealed class MultiFieldValueClassTree { - abstract val type: IrType - val irClass: IrClass - get() = type.erasedUpperBound - - companion object { - @JvmStatic - fun create(type: IrSimpleType, replacements: MemoizedMultiFieldValueClassReplacements, descriptorVisibility: DescriptorVisibility) = - if (!type.isNullable() && type.isMultiFieldValueClassType()) InternalNode(type, descriptorVisibility, replacements) - else Leaf(type) - } - - class Leaf(override val type: IrType) : MultiFieldValueClassTree() { - init { - require(type.isNullable() || !type.isMultiFieldValueClassType()) - } - } - - class InternalNode internal constructor( - override val type: IrSimpleType, val fields: List - ) : MultiFieldValueClassTree() { - constructor( - type: IrSimpleType, visibility: DescriptorVisibility, - replacements: MemoizedMultiFieldValueClassReplacements - ) : this(type, 0.let { - val valueClassRepresentation = type.erasedUpperBound.valueClassRepresentation as MultiFieldValueClassRepresentation - val primaryConstructor = type.erasedUpperBound.primaryConstructor!! - val propertiesByName = replacements.getOldMFVCProperties(primaryConstructor.constructedClass).associateBy { it.name } - val typeArguments: List = type.arguments - val typeParameters = type.erasedUpperBound.typeParameters - val substitutionMap = typeParameters.map { it.symbol }.zip(typeArguments) - .mapNotNull { (param, arg) -> if (arg is IrSimpleType) param to arg else null }.toMap() - valueClassRepresentation.underlyingPropertyNamesToTypes.map { (name, representationType) -> - val property = propertiesByName[name]!! - val innerVisibility = property.visibility - val newVisibility = minVisibility(visibility, innerVisibility) - TreeField( - name, - representationType.substitute(substitutionMap) as IrSimpleType, - newVisibility, - property.annotations, - replacements - ) - } - }) - - class TreeField( - val name: Name, val type: IrType, val visibility: DescriptorVisibility, val annotations: List, - val node: MultiFieldValueClassTree - ) { - constructor( - name: Name, - type: IrSimpleType, - visibility: DescriptorVisibility, - annotations: List, - replacements: MemoizedMultiFieldValueClassReplacements - ) : this(name, type, visibility, annotations, create(type, replacements, visibility)) - } - - init { - require(!type.isNullable() && type.isMultiFieldValueClassType()) - } - - private val fieldByName = fields.associateBy { it.name } - - operator fun get(name: Name) = fieldByName[name] - } -} - -fun minVisibility( - visibility1: DescriptorVisibility, - visibility2: DescriptorVisibility -): DescriptorVisibility { - val comparison = visibility1.compareTo(visibility2) - ?: error("Expected comparable visibilities but got $visibility1 and $visibility2") - return if (comparison < 0) visibility1 else visibility2 -} - -fun MultiFieldValueClassTree.render(): String = type.render() + when (this) { - is InternalNode -> "\n" + fields.joinToString("\n") { "${it.name.render()}: ${it.node.render().prependIndent(" ")}" } - is Leaf -> "" -} - -class MultiFieldValueClassSpecificDeclarations( - val valueClass: IrClass, - private val typeSystemContext: IrTypeSystemContext, - private val irFactory: IrFactory, - private val context: JvmBackendContext, - private val replacements: MemoizedMultiFieldValueClassReplacements, -) { - init { - require(valueClass.isMultiFieldValueClass) { "Cannot build ${this::class.simpleName} for not multi-field value class: $valueClass" } - } - - val loweringRepresentation = - MultiFieldValueClassTree.create(valueClass.defaultType, replacements, DescriptorVisibilities.PUBLIC) as InternalNode - - val leaves: List = ArrayList().apply { - fun proceed(node: MultiFieldValueClassTree) { - when (node) { - is InternalNode -> node.fields.forEach { proceed(it.node) } - is Leaf -> add(node) - } - } - proceed(loweringRepresentation) - if (size <= 1) { - error("${this@MultiFieldValueClassSpecificDeclarations::class.qualifiedName} for $valueClass must have multiple leaves") - } - } - - val nodeFullNames: Map = - mutableMapOf().apply { - val parts = mutableListOf() - fun makeName() = Name.guessByFirstCharacter(parts.joinToString("$")) - fun proceed(node: MultiFieldValueClassTree) { - when (node) { - is InternalNode -> { - if (parts.isNotEmpty()) { - put(node, makeName()) - } - for (field in node.fields) { - parts.add(field.name.asString()) - proceed(field.node) - parts.removeLast() - } - } - is Leaf -> put(node, makeName()) - } - } - proceed(loweringRepresentation) - } - - init { - require(nodeFullNames.size == nodeFullNames.values.distinct().size) { "Ambiguous names found: ${nodeFullNames.values}" } - } - - val indexByLeaf = leaves.withIndex().associate { it.value to it.index } - val indexesByInternalNode = mutableMapOf().apply { - var index = 0 - fun proceed(node: MultiFieldValueClassTree) { - when (node) { - is InternalNode -> { - val start = index - node.fields.forEach { proceed(it.node) } - val finish = index - val range = start until finish - if (finish - start <= 1) { - error("Invalid multi-field value class indexes range for class $valueClass: ${range}") - } - put(node, range) - } - is Leaf -> index++ - } - } - proceed(loweringRepresentation) - } - - val oldPrimaryConstructor = valueClass.primaryConstructor ?: error("Value classes have primary constructors") - - val oldProperties = replacements.getOldMFVCProperties(valueClass).associateBy { it.name } - - val fields = leaves.map { leaf -> - irFactory.buildField { - this.name = nodeFullNames[leaf]!! - this.type = leaf.type - visibility = DescriptorVisibilities.PRIVATE - }.apply { - parent = valueClass - } - } - - val gettersVisibilities = mutableMapOf().apply { - val stack = mutableListOf() - fun proceed(node: MultiFieldValueClassTree) { - when (node) { - is InternalNode -> { - if (stack.isNotEmpty()) { - put(node, stack.last()) - } - for (field in node.fields) { - stack.add(field.visibility) - proceed(field.node) - stack.pop() - } - } - is Leaf -> put(node, stack.last()) - } - } - proceed(loweringRepresentation) - } - - private val gettersAnnotations = mutableMapOf>().apply { - val stack = mutableListOf>() - - fun proceed(node: MultiFieldValueClassTree) { - when (node) { - is InternalNode -> { - if (stack.isNotEmpty()) { - put(node, stack.last()) - } - for (field in node.fields) { - stack.add(field.annotations) - proceed(field.node) - stack.pop() - } - } - is Leaf -> put(node, stack.last()) - } - } - proceed(loweringRepresentation) - } - - private fun IrBuilderWithScope.fieldGetter(receiver: IrValueParameter, field: IrField): IrGetField = - irGetField(irGet(receiver), field) - - private fun IrFunction.fieldGetter(field: IrField): IrBuilderWithScope.() -> IrGetField = - { fieldGetter(dispatchReceiverParameter!!, field) } - - val primaryConstructor: IrConstructor = 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" - } - addFlattenedClassRepresentationToParameters(mapOf()) - val irConstructor = this@apply - parent = valueClass - body = context.createIrBuilder(irConstructor.symbol).irBlockBody(irConstructor) { - +irDelegatingConstructorCall(context.irBuiltIns.anyClass.owner.constructors.single()) - for (i in leaves.indices) { - +irSetField( - receiver = irGet(valueClass.thisReceiver!!), - field = fields[i], - value = irGet(irConstructor.valueParameters[i]) - ) - } - } - } - - val primaryConstructorImpl: IrSimpleFunction = 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 = valueClass - copyTypeParametersFrom(valueClass) - addFlattenedClassRepresentationToParameters(classToFunctionTypeParametersMapping()) - // body is added in Lowering file - } - - private fun IrSimpleFunction.classToFunctionTypeParametersMapping() = - valueClass.typeParameters.map { it.symbol }.zip(typeParameters.map { it.defaultType }).toMap() - - val boxMethod = irFactory.buildFun { - name = Name.identifier(KotlinTypeMapper.BOX_JVM_METHOD_NAME) - origin = JvmLoweredDeclarationOrigin.SYNTHETIC_MULTI_FIELD_VALUE_CLASS_MEMBER - returnType = valueClass.defaultType - }.apply { - parent = valueClass - copyTypeParametersFrom(valueClass) - addFlattenedClassRepresentationToParameters(classToFunctionTypeParametersMapping()) - // body is added in Lowering file - } - - private fun IrFunction.addFlattenedClassRepresentationToParameters(substitutionMap: Map) { - for (leaf in leaves) { - addValueParameter { - this.name = nodeFullNames[leaf]!! - this.type = leaf.type.substitute(substitutionMap) - } - } - } - - val specializedEqualsMethod = 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 = valueClass - copyTypeParametersFrom(valueClass) - val typeParametersHalf1 = typeParameters.apply { - for (it in this) { - it.name = Name.guessByFirstCharacter("${it.name.asString()}1") - } - } - val substitutionMapHalf1 = (valueClass.typeParameters.map { it.symbol } zip typeParametersHalf1.map { it.defaultType }).toMap() - copyTypeParametersFrom(valueClass) - val typeParametersHalf2 = typeParameters.drop(typeParametersHalf1.size).apply { - for (it in this) { - it.name = Name.guessByFirstCharacter("${it.name.asString()}2") - } - } - val substitutionMapHalf2 = (valueClass.typeParameters.map { it.symbol } zip typeParametersHalf2.map { it.defaultType }).toMap() - for (leaf in leaves) { - addValueParameter { - this.name = Name.guessByFirstCharacter( - "${InlineClassDescriptorResolver.SPECIALIZED_EQUALS_FIRST_PARAMETER_NAME}$${nodeFullNames[leaf]!!.asString()}" - ) - this.type = leaf.type.substitute(substitutionMapHalf1) - } - } - for (leaf in leaves) { - addValueParameter { - this.name = Name.guessByFirstCharacter( - "${InlineClassDescriptorResolver.SPECIALIZED_EQUALS_SECOND_PARAMETER_NAME}$${nodeFullNames[leaf]!!.asString()}" - ) - this.type = leaf.type.substitute(substitutionMapHalf2) - } - } - // body is added in Lowering file - } - - val unboxMethods = fields.mapIndexed { index: Int, field: IrField -> - irFactory.buildFun { - name = Name.identifier(KotlinTypeMapper.UNBOX_JVM_METHOD_NAME + index) - origin = JvmLoweredDeclarationOrigin.SYNTHETIC_MULTI_FIELD_VALUE_CLASS_MEMBER - returnType = field.type - }.apply { - parent = valueClass - createDispatchReceiverParameter() - body = with(context.createIrBuilder(this.symbol)) { - irExprBody(fieldGetter(field)()) - } - } - } - - val properties: Map = run { - val nodes2expressions: Map IrExpression> = - makeNodes2FieldExpressions(fields) - nodeFullNames.mapValues { (node, propertyName) -> - val overrideable = oldProperties[propertyName] - val descriptorVisibility = gettersVisibilities[node]!! - irFactory.buildProperty { - name = propertyName - origin = IrDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_MEMBER - visibility = descriptorVisibility - }.apply { - annotations = gettersAnnotations[node]!! - overrideable?.overriddenSymbols?.let { overriddenSymbols = it } - parent = valueClass - addGetter { - returnType = node.type - origin = IrDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_MEMBER - visibility = descriptorVisibility - }.apply { - val function = this - overrideable?.getter?.overriddenSymbols?.let { overriddenSymbols = it } - createDispatchReceiverParameter() - body = with(context.createIrBuilder(this.symbol)) { - irExprBody(nodes2expressions[node]!!.invoke(this, function)) - } - } - } - } - } - - companion object { - private fun IrFunctionAccessExpression.copyTypeArgumentsFromType( - type: IrSimpleType, valueClass: IrClass, substitutionMap: Map - ) { - require(type.erasedUpperBound == valueClass) { - "Illegal bound ${type.erasedUpperBound.render()} instead of ${valueClass.render()}" - } - require(type.arguments.size == valueClass.typeParameters.size) { - "Unexpected number of type arguments: ${type.arguments.size} for ${valueClass.typeParameters.size} parameters" - } - require(type.arguments.size == symbol.owner.typeParameters.size) { - "Unexpected number of type arguments: ${type.arguments.size} for ${symbol.owner.typeParameters.size} parameters" - } - for (i in valueClass.typeParameters.indices) { - putTypeArgument(i, type.arguments[i].typeOrNull?.substitute(substitutionMap)) - } - } - } - - fun makeNodes2FieldExpressions(fields: List): Map IrExpression> { - fun proceed(node: MultiFieldValueClassTree): Map IrExpression> = - when (node) { - is InternalNode -> buildMap { - val innerDeclarations = - if (node.irClass == valueClass) this@MultiFieldValueClassSpecificDeclarations - else replacements.getDeclarations(node.irClass)!! - put(node) { function -> - irCall(innerDeclarations.boxMethod).apply { - copyTypeArgumentsFromType(node.type, node.irClass, mapOf()) - indexesByInternalNode[node]!!.forEachIndexed { index, nodeIndex -> - putValueArgument(index, fieldGetter(function.dispatchReceiverParameter!!, fields[nodeIndex])) - } - } - } - node.fields.forEach { putAll(proceed(it.node)) } - } - is Leaf -> mapOf(node to { fieldGetter(it.dispatchReceiverParameter!!, fields[indexByLeaf[node]!!]) }) - } - return proceed(loweringRepresentation) - } - - data class VirtualProperty( - val type: IrType, - val makeGetter: ExpressionGenerator, - val assigner: ExpressionSupplier?, - val symbol: IrValueSymbol? - ) { - constructor(declaration: IrValueDeclaration) : this( - declaration.type, - { irGet(declaration) }, - if (declaration.isAssignable) { value -> irSet(declaration, value) } else null, - declaration.symbol, - ) - - val isAssignable: Boolean - get() = assigner != null - } - - /** - * Multi-field value class instance can be not only a standalone instance but also: - * 1. A slice of fields in another multi-field class instance; - * 2. A slice of fields in another regular class instance; - * 3. Virtual instance constructed with local variables; - * 4. Virtual instance constructed with local parameters; - * 5. Virtual instance constructed with local fields; - * 6. Some mix of the above ones. - */ - inner class ImplementationAgnostic constructor(val type: IrSimpleType, val virtualFields: List) { - val regularDeclarations = this@MultiFieldValueClassSpecificDeclarations - val symbols = virtualFields.map { it.symbol } - private val substitutionMap = valueClass.typeParameters.map { it.symbol }.zip(type.arguments.map { it.typeOrNull }) - .mapNotNull { (parameter, type) -> if (type != null) parameter to type else null }.toMap() - - init { - require(virtualFields.size == leaves.size) { "Wrong symbols number given for $leaves, got $virtualFields" } - for ((actual, expected) in virtualFields.map { it.type } zip leaves.map { it.type }) { - require(actual.upperBound.isSubtypeOf(expected.upperBound, typeSystemContext)) { - "${actual.render()} is not a subtype of ${expected.render()} for MFVC ${valueClass.render()}" - } - } - } - - private val nodeToSymbols = indexesByInternalNode.mapValues { (_, indexes) -> virtualFields.slice(indexes) } + - indexByLeaf.mapValues { (_, index) -> listOf(virtualFields[index]) } - - private val internalNodeToExpressionGetters: Map = - indexesByInternalNode.mapValues { (node, indexes) -> - { - val arguments = virtualFields.slice(indexes).map { it.makeGetter(this) } - val innerDeclarations = replacements.getDeclarations(node.irClass)!! - irCall(innerDeclarations.boxMethod).apply { - copyTypeArgumentsFromType(node.type, node.irClass, substitutionMap) - for (i in arguments.indices) { - putValueArgument(i, arguments[i]) - } - } - } - } - - private val leavesToExpressionGetters: Map = - indexByLeaf.mapValues { (_, index) -> { virtualFields[index].makeGetter(this) } } - - val nodeToExpressionGetters: Map = - internalNodeToExpressionGetters + leavesToExpressionGetters - - operator fun get(name: Name): Pair? = - when (val field = loweringRepresentation[name]) { - null -> null - else -> nodeToExpressionGetters[field.node]!! to when (field.node) { - is Leaf -> null - is InternalNode -> { - val irClass = field.node.irClass - val declarations = replacements.getDeclarations(irClass)!! - declarations.ImplementationAgnostic(field.type as IrSimpleType, nodeToSymbols[field.node]!!) - } - } - } - - val boxedExpression = nodeToExpressionGetters[loweringRepresentation]!! - - // todo default parameters - // todo annotations etc. - // todo visibilities etc. - // todo regenerate tests for not only jvm - } -} - -typealias ExpressionGenerator = IrBuilderWithScope.() -> IrExpression -typealias ExpressionSupplier = IrBuilderWithScope.(IrExpression) -> IrStatement \ No newline at end of file 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 b68ca90f2a4..d8b3ed2bc80 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrUtils.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrUtils.kt @@ -8,10 +8,7 @@ package org.jetbrains.kotlin.backend.jvm.ir import com.intellij.psi.PsiElement import org.jetbrains.kotlin.backend.common.lower.at import org.jetbrains.kotlin.backend.common.lower.irNot -import org.jetbrains.kotlin.backend.jvm.CachedFieldsForObjectInstances -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext -import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin -import org.jetbrains.kotlin.backend.jvm.JvmSymbols +import org.jetbrains.kotlin.backend.jvm.* import org.jetbrains.kotlin.builtins.StandardNames import org.jetbrains.kotlin.codegen.ASSERTIONS_DISABLED_FIELD_NAME import org.jetbrains.kotlin.codegen.AsmUtil @@ -246,6 +243,8 @@ 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.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 diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt index f3f13fb9785..297b57d41d9 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt @@ -53,11 +53,13 @@ fun IrStatementsBuilder.irTemporary( nameHint: String? = null, irType: IrType = value?.type!!, // either value or irType should be supplied at callsite isMutable: Boolean = false, + origin: IrDeclarationOrigin = IrDeclarationOrigin.IR_TEMPORARY_VARIABLE, ): IrVariable { val temporary = scope.createTemporaryVariableDeclaration( irType, nameHint, isMutable, startOffset = startOffset, - endOffset = endOffset + endOffset = endOffset, + origin = origin, ) value?.let { temporary.initializer = it } +temporary diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt index 28a15bf3af4..91d5b647d0c 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt @@ -44,6 +44,8 @@ interface IrDeclarationOrigin { 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/testData/codegen/box/valueClasses/MFVCFieldInitializationOrder.kt b/compiler/testData/codegen/box/valueClasses/MfvcFieldInitializationOrder.kt similarity index 100% rename from compiler/testData/codegen/box/valueClasses/MFVCFieldInitializationOrder.kt rename to compiler/testData/codegen/box/valueClasses/MfvcFieldInitializationOrder.kt diff --git a/compiler/testData/codegen/box/valueClasses/MFVCFieldInitializationOrder.txt b/compiler/testData/codegen/box/valueClasses/MfvcFieldInitializationOrder.txt similarity index 55% rename from compiler/testData/codegen/box/valueClasses/MFVCFieldInitializationOrder.txt rename to compiler/testData/codegen/box/valueClasses/MfvcFieldInitializationOrder.txt index f5351e8f264..985d1a648c6 100644 --- a/compiler/testData/codegen/box/valueClasses/MFVCFieldInitializationOrder.txt +++ b/compiler/testData/codegen/box/valueClasses/MfvcFieldInitializationOrder.txt @@ -1,61 +1,61 @@ @kotlin.Metadata public final class A { - // source: 'MFVCFieldInitializationOrder.kt' - private field x$x: double - private field x$y: double + // source: 'MfvcFieldInitializationOrder.kt' + private field x-0: double + private field x-1: double public method (p0: double, p1: double): void - public final method getX$x(): double - public final method getX$y(): double public final @org.jetbrains.annotations.NotNull method getX(): DPoint + public 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$x: double - private field a$y: double - private field b$x: double - private field b$y: double - private field c$x: double - private field c$y: double + // 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 method getA$x(): double - public final method getA$y(): double public final @org.jetbrains.annotations.NotNull method getA(): DPoint - public final method getB$x(): double - public final method getB$y(): double + public synthetic final method getA-0(): double + public synthetic final method getA-1(): double public final @org.jetbrains.annotations.NotNull method getB(): DPoint - public final method getC$x(): double - public final method getC$y(): double + 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 field x: double - private field y: double + // 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 final method getX(): double - public final method getY(): double + public final static method getX-impl(p0: double, p1: double): double + public final static method getY-impl(p0: double, p1: double): double public method hashCode(): int public static method hashCode-impl(p0: double, p1: double): int public @org.jetbrains.annotations.NotNull method toString(): java.lang.String public static method toString-impl(p0: double, p1: double): java.lang.String - public synthetic final method unbox-impl0(): double - public synthetic final method unbox-impl1(): double + 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 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/classFlattening.kt b/compiler/testData/codegen/box/valueClasses/classFlattening.kt index 46d2026ed44..5d9b6c188f8 100644 --- a/compiler/testData/codegen/box/valueClasses/classFlattening.kt +++ b/compiler/testData/codegen/box/valueClasses/classFlattening.kt @@ -2,6 +2,7 @@ // TARGET_BACKEND: JVM_IR // WORKS_WHEN_VALUE_CLASS // LANGUAGE: +ValueClasses +// CHECK_BYTECODE_LISTING @JvmInline value class IC(val x: UInt) @@ -18,4 +19,12 @@ 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 box() = "OK" // todo real test \ No newline at end of file +fun box(): String { + val o1 = IC(2U) + require(ic(o1) == 2U) + 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) + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/valueClasses/classFlattening.txt b/compiler/testData/codegen/box/valueClasses/classFlattening.txt new file mode 100644 index 00000000000..fd53ac61834 --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/classFlattening.txt @@ -0,0 +1,87 @@ +@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 method smfvc-Ket90g4(p0: int, p1: int, p2: int, @org.jetbrains.annotations.NotNull p3: java.lang.String, p4: int): int +} + +@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 final static @org.jetbrains.annotations.NotNull method getX-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): SimpleMFVC + public final static method getY-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): int + public final static @org.jetbrains.annotations.NotNull method getZ-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): SimpleMFVC + 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.jvm.JvmInline +@kotlin.Metadata +public final class SimpleMFVC { + // source: 'classFlattening.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): 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 method getX-impl(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): int + public final static method getY-impl(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): int + public final static @org.jetbrains.annotations.NotNull method getZ-impl(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): java.lang.String + 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 +} diff --git a/compiler/testData/codegen/box/valueClasses/complex.txt b/compiler/testData/codegen/box/valueClasses/complex.txt index c1da32e6cae..8049e2dec46 100644 --- a/compiler/testData/codegen/box/valueClasses/complex.txt +++ b/compiler/testData/codegen/box/valueClasses/complex.txt @@ -40,6 +40,15 @@ public final class B { 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 } @@ -48,6 +57,15 @@ public final class Base1$DefaultImpls { 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 } @@ -56,6 +74,15 @@ public interface Base1 { 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 } @@ -63,6 +90,11 @@ public interface Base2 { 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 @@ -76,25 +108,25 @@ public interface Base4 { @kotlin.Metadata public final class C { // source: 'complex.kt' - private field x: int - private field y: int - private @org.jetbrains.annotations.NotNull field z: java.lang.String + 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 final method getX(): int - public final method getY-GsR9Xnw(): int - public final @org.jetbrains.annotations.NotNull method getZ(): java.lang.String + public final static method getX-impl(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): int + public final static method getY-impl(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): int + public final static @org.jetbrains.annotations.NotNull method getZ-impl(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): java.lang.String 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-impl0(): int - public synthetic final method unbox-impl1(): int - public synthetic final method unbox-impl2(): 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 @@ -118,9 +150,9 @@ public final class ComplexKt { @kotlin.Metadata public final class D { // source: 'complex.kt' - private field x$x: int - private field x$y: int - private @org.jetbrains.annotations.NotNull field x$z: java.lang.String + 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 @@ -128,26 +160,24 @@ public final class 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 final method getX$x(): int - public final method getX$y-GsR9Xnw(): int - public final @org.jetbrains.annotations.NotNull method getX$z(): java.lang.String - public final @org.jetbrains.annotations.NotNull method getX(): C + public final static @org.jetbrains.annotations.NotNull method getX-impl(p0: int, p1: int, @org.jetbrains.annotations.NotNull p2: java.lang.String): C 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-impl0(): int - public synthetic final method unbox-impl1(): int - public synthetic final method unbox-impl2(): 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 field x$x$x: int - private field x$x$y: int - private @org.jetbrains.annotations.NotNull field x$x$z: java.lang.String + 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 @@ -155,61 +185,86 @@ public final class E { 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 final method getX$x$x(): int - public final method getX$x$y-GsR9Xnw(): int - public final @org.jetbrains.annotations.NotNull method getX$x$z(): java.lang.String - public final @org.jetbrains.annotations.NotNull method getX$x(): C - public final @org.jetbrains.annotations.NotNull method getX(): D + public final static @org.jetbrains.annotations.NotNull method getX-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-impl0(): int - public synthetic final method unbox-impl1(): int - public synthetic final method unbox-impl2(): 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 @org.jetbrains.annotations.NotNull field l$t: java.util.List - private field l$x: int - private field l$y: int - private field l$z$x$x$x: int - private field l$z$x$x$y: int - private @org.jetbrains.annotations.NotNull field l$z$x$x$z: java.lang.String - private @org.jetbrains.annotations.NotNull field withNonTrivialGettersWithBF$t: java.util.List - private field withNonTrivialGettersWithBF$x: int - private field withNonTrivialGettersWithBF$y: int - private field withNonTrivialGettersWithBF$z$x$x$x: int - private field withNonTrivialGettersWithBF$z$x$x$y: int - private @org.jetbrains.annotations.NotNull field withNonTrivialGettersWithBF$z$x$x$z: java.lang.String - private @org.jetbrains.annotations.NotNull field withNonTrivialSettersWithBF$t: java.util.List - private field withNonTrivialSettersWithBF$x: int - private field withNonTrivialSettersWithBF$y: int - private field withNonTrivialSettersWithBF$z$x$x$x: int - private field withNonTrivialSettersWithBF$z$x$x$y: int - private @org.jetbrains.annotations.NotNull field withNonTrivialSettersWithBF$z$x$x$z: java.lang.String + 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 final @org.jetbrains.annotations.NotNull method getL$t-GKOAj6k(): java.util.List - public final method getL$x(): int - public final method getL$y-pVg5ArA(): int - public final method getL$z$x$x$x(): int - public final method getL$z$x$x$y-GsR9Xnw(): int - public final @org.jetbrains.annotations.NotNull method getL$z$x$x$z(): java.lang.String - public final @org.jetbrains.annotations.NotNull method getL$z$x$x(): C - public final @org.jetbrains.annotations.NotNull method getL$z$x(): D - public final @org.jetbrains.annotations.NotNull method getL$z(): E 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 @@ -218,18 +273,19 @@ public final class NotInlined { 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 @org.jetbrains.annotations.NotNull field t: java.util.List - private field x: int - private field y: int - private field z$x$x$x: int - private field z$x$x$y: int - private @org.jetbrains.annotations.NotNull field z$x$x$z: java.lang.String + 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 @@ -240,23 +296,28 @@ public final class R { public static @org.jetbrains.annotations.NotNull method getFakeOverrideMFVC-impl(p0: int, p1: int, p2: int, p3: int, @org.jetbrains.annotations.NotNull p4: java.lang.String, @org.jetbrains.annotations.NotNull p5: java.util.List): R public method getFakeOverrideRegular(): int public static method getFakeOverrideRegular-impl(p0: int, p1: int, p2: int, p3: int, @org.jetbrains.annotations.NotNull p4: java.lang.String, @org.jetbrains.annotations.NotNull p5: java.util.List): int - public final @org.jetbrains.annotations.NotNull method getT-GKOAj6k(): java.util.List - public final method getX(): int - public final method getY-pVg5ArA(): int - public final method getZ$x$x$x(): int - public final method getZ$x$x$y-GsR9Xnw(): int - public final @org.jetbrains.annotations.NotNull method getZ$x$x$z(): java.lang.String - public final @org.jetbrains.annotations.NotNull method getZ$x$x(): C - public final @org.jetbrains.annotations.NotNull method getZ$x(): D - public final @org.jetbrains.annotations.NotNull method getZ(): E + public final static @org.jetbrains.annotations.NotNull method getT-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): java.util.List + public final static method getX-impl(p0: int, p1: int, p2: int, p3: int, @org.jetbrains.annotations.NotNull p4: java.lang.String, @org.jetbrains.annotations.NotNull p5: java.util.List): int + public final static method getY-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 static @org.jetbrains.annotations.NotNull method getZ-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): E 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-impl0(): int - public synthetic final method unbox-impl1(): int - public synthetic final method unbox-impl2(): int - public synthetic final method unbox-impl3(): int - public synthetic final method unbox-impl4(): java.lang.String - public synthetic final method unbox-impl5(): java.util.List + 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/equality.txt b/compiler/testData/codegen/box/valueClasses/equality.txt index 22b568cfb77..2f73be4acd0 100644 --- a/compiler/testData/codegen/box/valueClasses/equality.txt +++ b/compiler/testData/codegen/box/valueClasses/equality.txt @@ -2,127 +2,108 @@ @kotlin.Metadata public final class A { // source: 'equality.kt' - private field f1: int - private field f2: int - private field f3$x: int - private field f3$y: int - private field f4: int - private field f5: int - private @org.jetbrains.annotations.NotNull field f6: java.lang.String - private field f7: int - private field f8: int - private @org.jetbrains.annotations.NotNull field f9: java.lang.String + private 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 final method getF1-DbFnDB4(): int - public final method getF2-ejSTSP4(): int - public final method getF3$x-DbFnDB4(): int - public final method getF3$y-ejSTSP4(): int - public final @org.jetbrains.annotations.NotNull method getF3(): F3 - public final method getF4-4yoqybc(): int - public final method getF5-z3qHWqM(): int - public final @org.jetbrains.annotations.NotNull method getF6-OgMO970(): java.lang.String - public final method getF7(): int - public final method getF8-pVg5ArA(): int - public final @org.jetbrains.annotations.NotNull method getF9(): java.lang.String + public final static method getF1-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): int + public final static method getF2-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): int + public final static @org.jetbrains.annotations.NotNull method getF3-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): F3 + public final static method getF4-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): int + public final static method getF5-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): int + public final static @org.jetbrains.annotations.NotNull method getF6-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): java.lang.String + public final static method getF7-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): int + public final static method getF8-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): int + public final static @org.jetbrains.annotations.NotNull method getF9-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): java.lang.String public method hashCode(): int public static method hashCode-impl(p0: int, p1: int, p2: int, p3: int, p4: int, p5: int, p6: java.lang.String, p7: int, p8: int, p9: java.lang.String): int public @org.jetbrains.annotations.NotNull method toString(): java.lang.String public static method toString-impl(p0: int, p1: int, p2: int, p3: int, p4: int, p5: int, p6: java.lang.String, p7: int, p8: int, p9: java.lang.String): java.lang.String - public synthetic final method unbox-impl0(): int - public synthetic final method unbox-impl1(): int - public synthetic final method unbox-impl2(): int - public synthetic final method unbox-impl3(): int - public synthetic final method unbox-impl4(): int - public synthetic final method unbox-impl5(): int - public synthetic final method unbox-impl6(): java.lang.String - public synthetic final method unbox-impl7(): int - public synthetic final method unbox-impl8(): int - public synthetic final method unbox-impl9(): java.lang.String + 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 field a1$f1: int - private field a1$f2: int - private field a1$f3$x: int - private field a1$f3$y: int - private field a1$f4: int - private field a1$f5: int - private @org.jetbrains.annotations.NotNull field a1$f6: java.lang.String - private field a1$f7: int - private field a1$f8: int - private @org.jetbrains.annotations.NotNull field a1$f9: java.lang.String - private field a2$f1: int - private field a2$f2: int - private field a2$f3$x: int - private field a2$f3$y: int - private field a2$f4: int - private field a2$f5: int - private @org.jetbrains.annotations.NotNull field a2$f6: java.lang.String - private field a2$f7: int - private field a2$f8: int - private @org.jetbrains.annotations.NotNull field a2$f9: java.lang.String + private 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 final method getA1$f1-DbFnDB4(): int - public final method getA1$f2-ejSTSP4(): int - public final method getA1$f3$x-DbFnDB4(): int - public final method getA1$f3$y-ejSTSP4(): int - public final @org.jetbrains.annotations.NotNull method getA1$f3(): F3 - public final method getA1$f4-4yoqybc(): int - public final method getA1$f5-z3qHWqM(): int - public final @org.jetbrains.annotations.NotNull method getA1$f6-OgMO970(): java.lang.String - public final method getA1$f7(): int - public final method getA1$f8-pVg5ArA(): int - public final @org.jetbrains.annotations.NotNull method getA1$f9(): java.lang.String - public final @org.jetbrains.annotations.NotNull method getA1(): A - public final method getA2$f1-DbFnDB4(): int - public final method getA2$f2-ejSTSP4(): int - public final method getA2$f3$x-DbFnDB4(): int - public final method getA2$f3$y-ejSTSP4(): int - public final @org.jetbrains.annotations.NotNull method getA2$f3(): F3 - public final method getA2$f4-4yoqybc(): int - public final method getA2$f5-z3qHWqM(): int - public final @org.jetbrains.annotations.NotNull method getA2$f6-OgMO970(): java.lang.String - public final method getA2$f7(): int - public final method getA2$f8-pVg5ArA(): int - public final @org.jetbrains.annotations.NotNull method getA2$f9(): java.lang.String - public final @org.jetbrains.annotations.NotNull method getA2(): A + public final static @org.jetbrains.annotations.NotNull method getA1-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): A + public final static @org.jetbrains.annotations.NotNull method getA2-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): A public method hashCode(): int public static method hashCode-impl(p0: int, p1: int, p2: int, p3: int, p4: int, p5: int, p6: java.lang.String, p7: int, p8: int, p9: java.lang.String, p10: int, p11: int, p12: int, p13: int, p14: int, p15: int, p16: java.lang.String, p17: int, p18: int, p19: java.lang.String): int public @org.jetbrains.annotations.NotNull method toString(): java.lang.String public static @org.jetbrains.annotations.NotNull method toString-impl(p0: int, p1: int, p2: int, p3: int, p4: int, p5: int, @org.jetbrains.annotations.NotNull p6: java.lang.String, p7: int, p8: int, @org.jetbrains.annotations.NotNull p9: java.lang.String, p10: int, p11: int, p12: int, p13: int, p14: int, p15: int, @org.jetbrains.annotations.NotNull p16: java.lang.String, p17: int, p18: int, @org.jetbrains.annotations.NotNull p19: java.lang.String): java.lang.String - public synthetic final method unbox-impl0(): int - public synthetic final method unbox-impl1(): int - public synthetic final method unbox-impl10(): int - public synthetic final method unbox-impl11(): int - public synthetic final method unbox-impl12(): int - public synthetic final method unbox-impl13(): int - public synthetic final method unbox-impl14(): int - public synthetic final method unbox-impl15(): int - public synthetic final method unbox-impl16(): java.lang.String - public synthetic final method unbox-impl17(): int - public synthetic final method unbox-impl18(): int - public synthetic final method unbox-impl19(): java.lang.String - public synthetic final method unbox-impl2(): int - public synthetic final method unbox-impl3(): int - public synthetic final method unbox-impl4(): int - public synthetic final method unbox-impl5(): int - public synthetic final method unbox-impl6(): java.lang.String - public synthetic final method unbox-impl7(): int - public synthetic final method unbox-impl8(): int - public synthetic final method unbox-impl9(): java.lang.String + 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 @@ -173,22 +154,22 @@ public final class F2 { @kotlin.Metadata public final class F3 { // source: 'equality.kt' - private field x: int - private field y: int + 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 final method getX-DbFnDB4(): int - public final method getY-ejSTSP4(): int + public final static method getX-impl(p0: int, p1: int): int + public final static method getY-impl(p0: int, p1: int): int public method hashCode(): int public static method hashCode-impl(p0: int, p1: int): int public @org.jetbrains.annotations.NotNull method toString(): java.lang.String public static method toString-impl(p0: int, p1: int): java.lang.String - public synthetic final method unbox-impl0(): int - public synthetic final method unbox-impl1(): int + public synthetic final method unbox-impl-0(): int + public synthetic final method unbox-impl-1(): int } @kotlin.jvm.JvmInline diff --git a/compiler/testData/codegen/box/valueClasses/overrides.txt b/compiler/testData/codegen/box/valueClasses/overrides.txt index d93a693bcfd..046dd18ec82 100644 --- a/compiler/testData/codegen/box/valueClasses/overrides.txt +++ b/compiler/testData/codegen/box/valueClasses/overrides.txt @@ -16,32 +16,34 @@ public interface AbstractSegment { @kotlin.Metadata public final class DPoint { // source: 'overrides.kt' - private field x: double - private field y: double + 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 final @org.jetbrains.annotations.NotNull method getX(): java.lang.Double + public @org.jetbrains.annotations.NotNull method getX(): java.lang.Double public synthetic bridge method getX(): java.lang.Object - public final @org.jetbrains.annotations.NotNull method getY(): java.lang.Double + public static @org.jetbrains.annotations.NotNull method getX-impl(p0: double, p1: double): java.lang.Double + public @org.jetbrains.annotations.NotNull method getY(): java.lang.Double public synthetic bridge method getY(): java.lang.Object + public static @org.jetbrains.annotations.NotNull method getY-impl(p0: double, p1: double): java.lang.Double public method hashCode(): int public static method hashCode-impl(p0: double, p1: double): int public @org.jetbrains.annotations.NotNull method toString(): java.lang.String public static method toString-impl(p0: double, p1: double): java.lang.String - public synthetic final method unbox-impl0(): double - public synthetic final method unbox-impl1(): double + 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 field x: double - private field y: double + 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 @@ -55,8 +57,8 @@ public final class DPointWithInterface { 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 final method getX(): double - public final method getY(): double + public final static method getX-impl(p0: double, p1: double): double + public final static method getY-impl(p0: double, p1: double): double public method hashCode(): int public static method hashCode-impl(p0: double, p1: double): int public synthetic bridge method setSomethingGeneric(p0: java.lang.Object): void @@ -68,40 +70,40 @@ public final class DPointWithInterface { 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-impl0(): double - public synthetic final method unbox-impl1(): double + 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 field p1$x: double - private field p1$y: double - private field p2$x: double - private field p2$y: double + 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 final method getP1$x(): double - public final method getP1$y(): double - public final @org.jetbrains.annotations.NotNull method getP1(): DPoint + public @org.jetbrains.annotations.NotNull method getP1(): DPoint public synthetic bridge method getP1(): java.lang.Object - public final method getP2$x(): double - public final method getP2$y(): double - public final @org.jetbrains.annotations.NotNull method getP2(): DPoint + public static @org.jetbrains.annotations.NotNull method getP1-impl(p0: double, p1: double, p2: double, p3: double): DPoint + public @org.jetbrains.annotations.NotNull method getP2(): DPoint public synthetic bridge method getP2(): java.lang.Object + public static @org.jetbrains.annotations.NotNull method getP2-impl(p0: double, p1: double, p2: double, p3: double): DPoint 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-impl0(): double - public synthetic final method unbox-impl1(): double - public synthetic final method unbox-impl2(): double - public synthetic final method unbox-impl3(): double + 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 @@ -130,22 +132,23 @@ public final class GenericFakeOverride { 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 field field1: double - private field field2: double + 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 final method getField1(): double - public final method getField2(): double + public final static method getField1-impl(p0: double, p1: double): double + public final static method getField2-impl(p0: double, p1: double): double 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 @@ -162,24 +165,25 @@ public final class GenericFakeOverrideMFVC { 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-impl0(): double - public synthetic final method unbox-impl1(): double + 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 field field1: double - private field field2: double + 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 final method getField1(): double - public final method getField2(): double + public final static method getField1-impl(p0: double, p1: double): double + public final static method getField2-impl(p0: double, p1: double): double 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 @@ -192,8 +196,9 @@ public final class GenericFakeOverrideMFVCWithMFVCUpperBound { 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-impl0(): double - public synthetic final method unbox-impl1(): double + public synthetic final method unbox-impl-0(): double + public synthetic final method unbox-impl-1(): double + public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls } @kotlin.Metadata @@ -204,6 +209,7 @@ public final class GenericFakeOverrideWithMFVCUpperBound { 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 @@ -239,7 +245,11 @@ public interface GenericMFVCHolderWithImpls { 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 } @@ -248,7 +258,11 @@ public interface GenericMFVCHolderWithMFVCUpperBound { 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 @@ -258,7 +272,11 @@ public final class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls { 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 @@ -280,8 +298,8 @@ final class OverridesKt$box$1 { final class OverridesKt$box$10 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -292,8 +310,8 @@ final class OverridesKt$box$10 { final class OverridesKt$box$100 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -304,8 +322,8 @@ final class OverridesKt$box$100 { final class OverridesKt$box$101 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -316,8 +334,8 @@ final class OverridesKt$box$101 { final class OverridesKt$box$102 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -328,8 +346,8 @@ final class OverridesKt$box$102 { final class OverridesKt$box$103 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -340,8 +358,8 @@ final class OverridesKt$box$103 { final class OverridesKt$box$104 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -352,10 +370,10 @@ final class OverridesKt$box$104 { final class OverridesKt$box$105 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -366,10 +384,10 @@ final class OverridesKt$box$105 { final class OverridesKt$box$106 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -380,8 +398,8 @@ final class OverridesKt$box$106 { final class OverridesKt$box$107 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -392,8 +410,8 @@ final class OverridesKt$box$107 { final class OverridesKt$box$108 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -404,10 +422,10 @@ final class OverridesKt$box$108 { final class OverridesKt$box$109 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -430,10 +448,10 @@ final class OverridesKt$box$11 { final class OverridesKt$box$110 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -444,10 +462,10 @@ final class OverridesKt$box$110 { final class OverridesKt$box$111 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -458,8 +476,8 @@ final class OverridesKt$box$111 { final class OverridesKt$box$112 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -470,10 +488,10 @@ final class OverridesKt$box$112 { final class OverridesKt$box$113 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -484,8 +502,8 @@ final class OverridesKt$box$113 { final class OverridesKt$box$114 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dSegment$p1$x: double - synthetic final field $tmp1_dSegment$p1$y: double + 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 @@ -496,8 +514,8 @@ final class OverridesKt$box$114 { final class OverridesKt$box$115 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp2_dSegment$p2$x: double - synthetic final field $tmp3_dSegment$p2$y: double + 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 @@ -520,7 +538,7 @@ final class OverridesKt$box$116 { final class OverridesKt$box$117 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double + 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 @@ -543,7 +561,7 @@ final class OverridesKt$box$118 { final class OverridesKt$box$119 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dSegment$p1$x: double + 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 @@ -554,8 +572,8 @@ final class OverridesKt$box$119 { final class OverridesKt$box$12 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -578,7 +596,7 @@ final class OverridesKt$box$120 { final class OverridesKt$box$121 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_otherDPoint$x: double + 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 @@ -601,7 +619,7 @@ final class OverridesKt$box$122 { final class OverridesKt$box$123 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp2_dSegment$p2$x: double + 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 @@ -624,7 +642,7 @@ final class OverridesKt$box$124 { final class OverridesKt$box$125 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp1_dPoint$y: double + 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 @@ -647,7 +665,7 @@ final class OverridesKt$box$126 { final class OverridesKt$box$127 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp1_dSegment$p1$y: double + 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 @@ -670,7 +688,7 @@ final class OverridesKt$box$128 { final class OverridesKt$box$129 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp1_otherDPoint$y: double + 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 @@ -705,7 +723,7 @@ final class OverridesKt$box$130 { final class OverridesKt$box$131 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp3_dSegment$p2$y: double + 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 @@ -716,10 +734,10 @@ final class OverridesKt$box$131 { final class OverridesKt$box$132 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dSegment$p1$x: double - synthetic final field $tmp1_dSegment$p1$y: double - synthetic final field $tmp2_dSegment$p2$x: double - synthetic final field $tmp3_dSegment$p2$y: double + 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 @@ -730,10 +748,10 @@ final class OverridesKt$box$132 { final class OverridesKt$box$133 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dSegment$p1$x: double - synthetic final field $tmp1_dSegment$p1$y: double - synthetic final field $tmp2_dSegment$p2$x: double - synthetic final field $tmp3_dSegment$p2$y: double + 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 @@ -756,10 +774,10 @@ final class OverridesKt$box$134 { final class OverridesKt$box$135 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dSegment$p1$x: double - synthetic final field $tmp1_dSegment$p1$y: double - synthetic final field $tmp2_dSegment$p2$x: double - synthetic final field $tmp3_dSegment$p2$y: double + 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 @@ -782,10 +800,10 @@ final class OverridesKt$box$136 { final class OverridesKt$box$137 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dSegment$p1$x: double - synthetic final field $tmp1_dSegment$p1$y: double - synthetic final field $tmp2_dSegment$p2$x: double - synthetic final field $tmp3_dSegment$p2$y: double + 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 @@ -808,10 +826,10 @@ final class OverridesKt$box$138 { final class OverridesKt$box$139 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dSegment$p1$x: double - synthetic final field $tmp1_dSegment$p1$y: double - synthetic final field $tmp2_dSegment$p2$x: double - synthetic final field $tmp3_dSegment$p2$y: double + 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 @@ -822,10 +840,10 @@ final class OverridesKt$box$139 { final class OverridesKt$box$14 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_otherDPoint$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_otherDPoint$y: double + 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 @@ -848,10 +866,10 @@ final class OverridesKt$box$140 { final class OverridesKt$box$141 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dSegment$p1$x: double - synthetic final field $tmp1_dSegment$p1$y: double - synthetic final field $tmp2_dSegment$p2$x: double - synthetic final field $tmp3_dSegment$p2$y: double + 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 @@ -874,10 +892,10 @@ final class OverridesKt$box$15 { final class OverridesKt$box$16 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_otherDPoint$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_otherDPoint$y: double + 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 @@ -900,10 +918,10 @@ final class OverridesKt$box$17 { final class OverridesKt$box$18 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_otherDPoint$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_otherDPoint$y: double + 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 @@ -926,8 +944,8 @@ final class OverridesKt$box$19 { final class OverridesKt$box$2 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -938,10 +956,10 @@ final class OverridesKt$box$2 { final class OverridesKt$box$20 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_otherDPoint$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_otherDPoint$y: double + 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 @@ -952,8 +970,8 @@ final class OverridesKt$box$20 { final class OverridesKt$box$21 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -964,8 +982,8 @@ final class OverridesKt$box$21 { final class OverridesKt$box$22 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -988,7 +1006,7 @@ final class OverridesKt$box$23 { final class OverridesKt$box$24 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double + 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 @@ -1011,8 +1029,8 @@ final class OverridesKt$box$25 { final class OverridesKt$box$26 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -1035,7 +1053,7 @@ final class OverridesKt$box$27 { final class OverridesKt$box$28 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp1_dPoint$y: double + 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 @@ -1070,8 +1088,8 @@ final class OverridesKt$box$3 { final class OverridesKt$box$30 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -1181,8 +1199,8 @@ final class OverridesKt$box$39 { final class OverridesKt$box$4 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -1193,9 +1211,9 @@ final class OverridesKt$box$4 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$40 method (p0: RealOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1206,9 +1224,9 @@ final class OverridesKt$box$40 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$41 method (p0: RealOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1219,9 +1237,9 @@ final class OverridesKt$box$41 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$42 method (p0: RealOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1232,9 +1250,9 @@ final class OverridesKt$box$42 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$43 method (p0: RealOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1245,9 +1263,9 @@ final class OverridesKt$box$43 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$44 method (p0: RealOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1258,9 +1276,9 @@ final class OverridesKt$box$44 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$45 method (p0: RealOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1271,9 +1289,9 @@ final class OverridesKt$box$45 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$46 method (p0: RealOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1284,9 +1302,9 @@ final class OverridesKt$box$46 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$47 method (p0: RealOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1441,8 +1459,8 @@ final class OverridesKt$box$59 { final class OverridesKt$box$6 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -1453,9 +1471,9 @@ final class OverridesKt$box$6 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$60 method (p0: GenericFakeOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1466,9 +1484,9 @@ final class OverridesKt$box$60 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$61 method (p0: GenericFakeOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1479,9 +1497,9 @@ final class OverridesKt$box$61 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$62 method (p0: GenericFakeOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1492,9 +1510,9 @@ final class OverridesKt$box$62 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$63 method (p0: GenericFakeOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1505,9 +1523,9 @@ final class OverridesKt$box$63 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$64 method (p0: ReifiedFakeOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1518,9 +1536,9 @@ final class OverridesKt$box$64 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$65 method (p0: ReifiedFakeOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1531,9 +1549,9 @@ final class OverridesKt$box$65 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$66 method (p0: ReifiedFakeOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1544,9 +1562,9 @@ final class OverridesKt$box$66 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$67 method (p0: ReifiedFakeOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1557,9 +1575,9 @@ final class OverridesKt$box$67 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$68 method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1570,9 +1588,9 @@ final class OverridesKt$box$68 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$69 method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1595,9 +1613,9 @@ final class OverridesKt$box$7 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$70 method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1608,9 +1626,9 @@ final class OverridesKt$box$70 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class OverridesKt$box$71 method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1621,8 +1639,8 @@ final class OverridesKt$box$71 { final class OverridesKt$box$72 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: double - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: double + 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 @@ -1633,8 +1651,8 @@ final class OverridesKt$box$72 { final class OverridesKt$box$73 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: double - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: double + 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 @@ -1645,8 +1663,8 @@ final class OverridesKt$box$73 { final class OverridesKt$box$74 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: double - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: double + 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 @@ -1657,8 +1675,8 @@ final class OverridesKt$box$74 { final class OverridesKt$box$75 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: double - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: double + 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 @@ -1669,8 +1687,8 @@ final class OverridesKt$box$75 { final class OverridesKt$box$76 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: double - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: double + 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 @@ -1681,8 +1699,8 @@ final class OverridesKt$box$76 { final class OverridesKt$box$77 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: double - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: double + 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 @@ -1693,8 +1711,8 @@ final class OverridesKt$box$77 { final class OverridesKt$box$78 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: double - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: double + 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 @@ -1705,8 +1723,8 @@ final class OverridesKt$box$78 { final class OverridesKt$box$79 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: double - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: double + 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 @@ -1717,8 +1735,8 @@ final class OverridesKt$box$79 { final class OverridesKt$box$8 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -1729,8 +1747,8 @@ final class OverridesKt$box$8 { final class OverridesKt$box$80 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: double - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: double + 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 @@ -1741,8 +1759,8 @@ final class OverridesKt$box$80 { final class OverridesKt$box$81 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: double - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: double + 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 @@ -1753,8 +1771,8 @@ final class OverridesKt$box$81 { final class OverridesKt$box$82 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: double - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: double + 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 @@ -1765,8 +1783,8 @@ final class OverridesKt$box$82 { final class OverridesKt$box$83 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: double - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: double + 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 @@ -1777,10 +1795,10 @@ final class OverridesKt$box$83 { final class OverridesKt$box$84 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: double + 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 @@ -1791,10 +1809,10 @@ final class OverridesKt$box$84 { final class OverridesKt$box$85 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: double + 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 @@ -1805,10 +1823,10 @@ final class OverridesKt$box$85 { final class OverridesKt$box$86 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: double + 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 @@ -1819,10 +1837,10 @@ final class OverridesKt$box$86 { final class OverridesKt$box$87 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: double + 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 @@ -1833,10 +1851,10 @@ final class OverridesKt$box$87 { final class OverridesKt$box$88 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: double + 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 @@ -1847,10 +1865,10 @@ final class OverridesKt$box$88 { final class OverridesKt$box$89 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: double + 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 @@ -1873,10 +1891,10 @@ final class OverridesKt$box$9 { final class OverridesKt$box$90 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: double + 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 @@ -1887,10 +1905,10 @@ final class OverridesKt$box$90 { final class OverridesKt$box$91 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: double + 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 @@ -1901,10 +1919,10 @@ final class OverridesKt$box$91 { final class OverridesKt$box$92 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: double + 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 @@ -1915,10 +1933,10 @@ final class OverridesKt$box$92 { final class OverridesKt$box$93 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: double + 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 @@ -1929,10 +1947,10 @@ final class OverridesKt$box$93 { final class OverridesKt$box$94 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: double + 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 @@ -1943,10 +1961,10 @@ final class OverridesKt$box$94 { final class OverridesKt$box$95 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: double + 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 @@ -1957,8 +1975,8 @@ final class OverridesKt$box$95 { final class OverridesKt$box$96 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -1969,8 +1987,8 @@ final class OverridesKt$box$96 { final class OverridesKt$box$97 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -1981,8 +1999,8 @@ final class OverridesKt$box$97 { final class OverridesKt$box$98 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -1993,8 +2011,8 @@ final class OverridesKt$box$98 { final class OverridesKt$box$99 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -2005,8 +2023,8 @@ final class OverridesKt$box$99 { final class OverridesKt$box$dPointLam$1 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2041,8 +2059,8 @@ final class OverridesKt$box$lam1$1 { final class OverridesKt$box$lam10$1 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2065,8 +2083,8 @@ final class OverridesKt$box$lam11$1 { final class OverridesKt$box$lam12$1 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2089,8 +2107,8 @@ final class OverridesKt$box$lam13$1 { final class OverridesKt$box$lam14$1 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2113,8 +2131,8 @@ final class OverridesKt$box$lam15$1 { final class OverridesKt$box$lam16$1 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2137,8 +2155,8 @@ final class OverridesKt$box$lam17$1 { final class OverridesKt$box$lam18$1 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2161,8 +2179,8 @@ final class OverridesKt$box$lam19$1 { final class OverridesKt$box$lam2$1 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2197,8 +2215,8 @@ final class OverridesKt$box$lam3$1 { final class OverridesKt$box$lam4$1 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2221,8 +2239,8 @@ final class OverridesKt$box$lam5$1 { final class OverridesKt$box$lam6$1 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2245,8 +2263,8 @@ final class OverridesKt$box$lam7$1 { final class OverridesKt$box$lam8$1 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2269,8 +2287,8 @@ final class OverridesKt$box$lam9$1 { final class OverridesKt$box$otherDPointLam$1 { // source: 'overrides.kt' enclosing method OverridesKt.box()Ljava/lang/String; - synthetic final field $tmp0_otherDPoint$x: double - synthetic final field $tmp1_otherDPoint$y: double + 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 @@ -2451,15 +2469,17 @@ public final class OverridesKt { @kotlin.Metadata public final class RealOverride { // source: 'overrides.kt' - private field p$x: double - private field p$y: double + private field p-0: double + private field p-1: double public method (p0: double, p1: double): void - public final method getP$x(): double - public final method getP$y(): double 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 @@ -2474,22 +2494,23 @@ public final class ReifiedFakeOverride { 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 field field1: double - private field field2: double + 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 final method getField1(): double - public final method getField2(): double + public final static method getField1-impl(p0: double, p1: double): double + public final static method getField2-impl(p0: double, p1: double): double 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 @@ -2502,15 +2523,20 @@ public final class ReifiedFakeOverrideMFVC { 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-impl0(): double - public synthetic final method unbox-impl1(): double + 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 } @@ -2519,7 +2545,11 @@ public interface ReifiedMFVCHolder { 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 @@ -2529,7 +2559,11 @@ public final class ReifiedMFVCHolderWithImpls$DefaultImpls { 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 @@ -2540,6 +2574,8 @@ 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 @@ -2550,7 +2586,11 @@ public interface SomePointInterface { 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 diff --git a/compiler/testData/codegen/box/valueClasses/overrides_inlineClass.txt b/compiler/testData/codegen/box/valueClasses/overrides_inlineClass.txt index f811c7ec177..b97c35af023 100644 --- a/compiler/testData/codegen/box/valueClasses/overrides_inlineClass.txt +++ b/compiler/testData/codegen/box/valueClasses/overrides_inlineClass.txt @@ -16,8 +16,8 @@ public interface AbstractSegment { @kotlin.Metadata public final class DPoint { // source: 'overrides_inlineClass.kt' - private field x: double - private field y: double + 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 @@ -25,23 +25,25 @@ public final class DPoint { public static method equals-impl(p0: double, p1: double, p2: java.lang.Object): boolean public final static method equals-impl0(p0: double, p1: double, p2: double, p3: double): boolean public synthetic bridge method getX(): java.lang.Object - public final method getX-3cLST_U(): double + public method getX-3cLST_U(): double + public static method getX-impl(p0: double, p1: double): double public synthetic bridge method getY(): java.lang.Object - public final method getY-3cLST_U(): double + public method getY-3cLST_U(): double + public static method getY-impl(p0: double, p1: double): double public method hashCode(): int public static method hashCode-impl(p0: double, p1: double): int public @org.jetbrains.annotations.NotNull method toString(): java.lang.String public static method toString-impl(p0: double, p1: double): java.lang.String - public synthetic final method unbox-impl0(): double - public synthetic final method unbox-impl1(): double + 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 field x: double - private field y: double + 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 @@ -55,8 +57,8 @@ public final class DPointWithInterface { 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 final method getX-3cLST_U(): double - public final method getY-3cLST_U(): double + public final static method getX-impl(p0: double, p1: double): double + public final static method getY-impl(p0: double, p1: double): double public method hashCode(): int public static method hashCode-impl(p0: double, p1: double): int public synthetic bridge method setSomethingGeneric(p0: java.lang.Object): void @@ -68,40 +70,40 @@ public final class DPointWithInterface { 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-impl0(): double - public synthetic final method unbox-impl1(): double + 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 field p1$x: double - private field p1$y: double - private field p2$x: double - private field p2$y: double + 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 final method getP1$x-3cLST_U(): double - public final method getP1$y-3cLST_U(): double - public final @org.jetbrains.annotations.NotNull method getP1(): DPoint + public @org.jetbrains.annotations.NotNull method getP1(): DPoint public synthetic bridge method getP1(): java.lang.Object - public final method getP2$x-3cLST_U(): double - public final method getP2$y-3cLST_U(): double - public final @org.jetbrains.annotations.NotNull method getP2(): DPoint + public static @org.jetbrains.annotations.NotNull method getP1-impl(p0: double, p1: double, p2: double, p3: double): DPoint + public @org.jetbrains.annotations.NotNull method getP2(): DPoint public synthetic bridge method getP2(): java.lang.Object + public static @org.jetbrains.annotations.NotNull method getP2-impl(p0: double, p1: double, p2: double, p3: double): DPoint 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-impl0(): double - public synthetic final method unbox-impl1(): double - public synthetic final method unbox-impl2(): double - public synthetic final method unbox-impl3(): double + 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 @@ -130,22 +132,23 @@ public final class GenericFakeOverride { 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 field field1: double - private field field2: double + 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 final method getField1-3cLST_U(): double - public final method getField2-3cLST_U(): double + public final static method getField1-impl(p0: double, p1: double): double + public final static method getField2-impl(p0: double, p1: double): double 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 @@ -162,24 +165,25 @@ public final class GenericFakeOverrideMFVC { 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-impl0(): double - public synthetic final method unbox-impl1(): double + 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 field field1: double - private field field2: double + 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 final method getField1-3cLST_U(): double - public final method getField2-3cLST_U(): double + public final static method getField1-impl(p0: double, p1: double): double + public final static method getField2-impl(p0: double, p1: double): double 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 @@ -192,8 +196,9 @@ public final class GenericFakeOverrideMFVCWithMFVCUpperBound { 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-impl0(): double - public synthetic final method unbox-impl1(): double + public synthetic final method unbox-impl-0(): double + public synthetic final method unbox-impl-1(): double + public final inner class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls } @kotlin.Metadata @@ -204,6 +209,7 @@ public final class GenericFakeOverrideWithMFVCUpperBound { 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 @@ -239,7 +245,11 @@ public interface GenericMFVCHolderWithImpls { 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 } @@ -248,7 +258,11 @@ public interface GenericMFVCHolderWithMFVCUpperBound { 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 @@ -258,7 +272,11 @@ public final class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls { 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 @@ -299,8 +317,8 @@ final class Overrides_inlineClassKt$box$1 { final class Overrides_inlineClassKt$box$10 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -311,8 +329,8 @@ final class Overrides_inlineClassKt$box$10 { final class Overrides_inlineClassKt$box$100 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -323,8 +341,8 @@ final class Overrides_inlineClassKt$box$100 { final class Overrides_inlineClassKt$box$101 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -335,8 +353,8 @@ final class Overrides_inlineClassKt$box$101 { final class Overrides_inlineClassKt$box$102 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -347,8 +365,8 @@ final class Overrides_inlineClassKt$box$102 { final class Overrides_inlineClassKt$box$103 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -359,8 +377,8 @@ final class Overrides_inlineClassKt$box$103 { final class Overrides_inlineClassKt$box$104 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -371,10 +389,10 @@ final class Overrides_inlineClassKt$box$104 { final class Overrides_inlineClassKt$box$105 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -385,10 +403,10 @@ final class Overrides_inlineClassKt$box$105 { final class Overrides_inlineClassKt$box$106 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -399,8 +417,8 @@ final class Overrides_inlineClassKt$box$106 { final class Overrides_inlineClassKt$box$107 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -411,8 +429,8 @@ final class Overrides_inlineClassKt$box$107 { final class Overrides_inlineClassKt$box$108 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -423,10 +441,10 @@ final class Overrides_inlineClassKt$box$108 { final class Overrides_inlineClassKt$box$109 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -449,10 +467,10 @@ final class Overrides_inlineClassKt$box$11 { final class Overrides_inlineClassKt$box$110 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -463,10 +481,10 @@ final class Overrides_inlineClassKt$box$110 { final class Overrides_inlineClassKt$box$111 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -477,8 +495,8 @@ final class Overrides_inlineClassKt$box$111 { final class Overrides_inlineClassKt$box$112 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -489,10 +507,10 @@ final class Overrides_inlineClassKt$box$112 { final class Overrides_inlineClassKt$box$113 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -503,8 +521,8 @@ final class Overrides_inlineClassKt$box$113 { final class Overrides_inlineClassKt$box$114 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dSegment$p1$x: double - synthetic final field $tmp1_dSegment$p1$y: double + 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 @@ -515,8 +533,8 @@ final class Overrides_inlineClassKt$box$114 { final class Overrides_inlineClassKt$box$115 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp2_dSegment$p2$x: double - synthetic final field $tmp3_dSegment$p2$y: double + 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 @@ -539,7 +557,7 @@ final class Overrides_inlineClassKt$box$116 { final class Overrides_inlineClassKt$box$117 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double + 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 @@ -562,7 +580,7 @@ final class Overrides_inlineClassKt$box$118 { final class Overrides_inlineClassKt$box$119 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dSegment$p1$x: double + 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 @@ -573,8 +591,8 @@ final class Overrides_inlineClassKt$box$119 { final class Overrides_inlineClassKt$box$12 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -597,7 +615,7 @@ final class Overrides_inlineClassKt$box$120 { final class Overrides_inlineClassKt$box$121 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_otherDPoint$x: double + 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 @@ -620,7 +638,7 @@ final class Overrides_inlineClassKt$box$122 { final class Overrides_inlineClassKt$box$123 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp2_dSegment$p2$x: double + 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 @@ -643,7 +661,7 @@ final class Overrides_inlineClassKt$box$124 { final class Overrides_inlineClassKt$box$125 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp1_dPoint$y: double + 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 @@ -666,7 +684,7 @@ final class Overrides_inlineClassKt$box$126 { final class Overrides_inlineClassKt$box$127 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp1_dSegment$p1$y: double + 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 @@ -689,7 +707,7 @@ final class Overrides_inlineClassKt$box$128 { final class Overrides_inlineClassKt$box$129 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp1_otherDPoint$y: double + 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 @@ -724,7 +742,7 @@ final class Overrides_inlineClassKt$box$130 { final class Overrides_inlineClassKt$box$131 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp3_dSegment$p2$y: double + 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 @@ -735,10 +753,10 @@ final class Overrides_inlineClassKt$box$131 { final class Overrides_inlineClassKt$box$132 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dSegment$p1$x: double - synthetic final field $tmp1_dSegment$p1$y: double - synthetic final field $tmp2_dSegment$p2$x: double - synthetic final field $tmp3_dSegment$p2$y: double + 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 @@ -749,10 +767,10 @@ final class Overrides_inlineClassKt$box$132 { final class Overrides_inlineClassKt$box$133 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dSegment$p1$x: double - synthetic final field $tmp1_dSegment$p1$y: double - synthetic final field $tmp2_dSegment$p2$x: double - synthetic final field $tmp3_dSegment$p2$y: double + 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 @@ -775,10 +793,10 @@ final class Overrides_inlineClassKt$box$134 { final class Overrides_inlineClassKt$box$135 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dSegment$p1$x: double - synthetic final field $tmp1_dSegment$p1$y: double - synthetic final field $tmp2_dSegment$p2$x: double - synthetic final field $tmp3_dSegment$p2$y: double + 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 @@ -801,10 +819,10 @@ final class Overrides_inlineClassKt$box$136 { final class Overrides_inlineClassKt$box$137 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dSegment$p1$x: double - synthetic final field $tmp1_dSegment$p1$y: double - synthetic final field $tmp2_dSegment$p2$x: double - synthetic final field $tmp3_dSegment$p2$y: double + 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 @@ -827,10 +845,10 @@ final class Overrides_inlineClassKt$box$138 { final class Overrides_inlineClassKt$box$139 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dSegment$p1$x: double - synthetic final field $tmp1_dSegment$p1$y: double - synthetic final field $tmp2_dSegment$p2$x: double - synthetic final field $tmp3_dSegment$p2$y: double + 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 @@ -841,10 +859,10 @@ final class Overrides_inlineClassKt$box$139 { final class Overrides_inlineClassKt$box$14 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_otherDPoint$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_otherDPoint$y: double + 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 @@ -867,10 +885,10 @@ final class Overrides_inlineClassKt$box$140 { final class Overrides_inlineClassKt$box$141 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dSegment$p1$x: double - synthetic final field $tmp1_dSegment$p1$y: double - synthetic final field $tmp2_dSegment$p2$x: double - synthetic final field $tmp3_dSegment$p2$y: double + 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 @@ -893,10 +911,10 @@ final class Overrides_inlineClassKt$box$15 { final class Overrides_inlineClassKt$box$16 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_otherDPoint$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_otherDPoint$y: double + 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 @@ -919,10 +937,10 @@ final class Overrides_inlineClassKt$box$17 { final class Overrides_inlineClassKt$box$18 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_otherDPoint$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_otherDPoint$y: double + 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 @@ -945,8 +963,8 @@ final class Overrides_inlineClassKt$box$19 { final class Overrides_inlineClassKt$box$2 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -957,10 +975,10 @@ final class Overrides_inlineClassKt$box$2 { final class Overrides_inlineClassKt$box$20 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_otherDPoint$x: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_otherDPoint$y: double + 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 @@ -971,8 +989,8 @@ final class Overrides_inlineClassKt$box$20 { final class Overrides_inlineClassKt$box$21 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -983,8 +1001,8 @@ final class Overrides_inlineClassKt$box$21 { final class Overrides_inlineClassKt$box$22 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -1007,7 +1025,7 @@ final class Overrides_inlineClassKt$box$23 { final class Overrides_inlineClassKt$box$24 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double + 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 @@ -1029,8 +1047,8 @@ final class Overrides_inlineClassKt$box$25 { final class Overrides_inlineClassKt$box$26 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -1052,7 +1070,7 @@ final class Overrides_inlineClassKt$box$27 { final class Overrides_inlineClassKt$box$28 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp1_dPoint$y: double + 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 @@ -1086,8 +1104,8 @@ final class Overrides_inlineClassKt$box$3 { final class Overrides_inlineClassKt$box$30 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -1196,8 +1214,8 @@ final class Overrides_inlineClassKt$box$39 { final class Overrides_inlineClassKt$box$4 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -1208,9 +1226,9 @@ final class Overrides_inlineClassKt$box$4 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$40 method (p0: RealOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1221,9 +1239,9 @@ final class Overrides_inlineClassKt$box$40 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$41 method (p0: RealOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1234,9 +1252,9 @@ final class Overrides_inlineClassKt$box$41 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$42 method (p0: RealOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1247,9 +1265,9 @@ final class Overrides_inlineClassKt$box$42 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$43 method (p0: RealOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1260,9 +1278,9 @@ final class Overrides_inlineClassKt$box$43 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$44 method (p0: RealOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1273,9 +1291,9 @@ final class Overrides_inlineClassKt$box$44 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$45 method (p0: RealOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1286,9 +1304,9 @@ final class Overrides_inlineClassKt$box$45 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$46 method (p0: RealOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1299,9 +1317,9 @@ final class Overrides_inlineClassKt$box$46 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$47 method (p0: RealOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1456,8 +1474,8 @@ final class Overrides_inlineClassKt$box$59 { final class Overrides_inlineClassKt$box$6 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -1468,9 +1486,9 @@ final class Overrides_inlineClassKt$box$6 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$60 method (p0: GenericFakeOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1481,9 +1499,9 @@ final class Overrides_inlineClassKt$box$60 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$61 method (p0: GenericFakeOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1494,9 +1512,9 @@ final class Overrides_inlineClassKt$box$61 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$62 method (p0: GenericFakeOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1507,9 +1525,9 @@ final class Overrides_inlineClassKt$box$62 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$63 method (p0: GenericFakeOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1520,9 +1538,9 @@ final class Overrides_inlineClassKt$box$63 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$64 method (p0: ReifiedFakeOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1533,9 +1551,9 @@ final class Overrides_inlineClassKt$box$64 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$65 method (p0: ReifiedFakeOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1546,9 +1564,9 @@ final class Overrides_inlineClassKt$box$65 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$66 method (p0: ReifiedFakeOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1559,9 +1577,9 @@ final class Overrides_inlineClassKt$box$66 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$67 method (p0: ReifiedFakeOverride, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1572,9 +1590,9 @@ final class Overrides_inlineClassKt$box$67 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$68 method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1585,9 +1603,9 @@ final class Overrides_inlineClassKt$box$68 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$69 method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1610,9 +1628,9 @@ final class Overrides_inlineClassKt$box$7 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$70 method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1623,9 +1641,9 @@ final class Overrides_inlineClassKt$box$70 { 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 - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double inner (anonymous) class Overrides_inlineClassKt$box$71 method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: double, p2: double): void public synthetic bridge method invoke(): java.lang.Object @@ -1636,8 +1654,8 @@ final class Overrides_inlineClassKt$box$71 { final class Overrides_inlineClassKt$box$72 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: double - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: double + 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 @@ -1648,8 +1666,8 @@ final class Overrides_inlineClassKt$box$72 { final class Overrides_inlineClassKt$box$73 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: double - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: double + 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 @@ -1660,8 +1678,8 @@ final class Overrides_inlineClassKt$box$73 { final class Overrides_inlineClassKt$box$74 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: double - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: double + 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 @@ -1672,8 +1690,8 @@ final class Overrides_inlineClassKt$box$74 { final class Overrides_inlineClassKt$box$75 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: double - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: double + 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 @@ -1684,8 +1702,8 @@ final class Overrides_inlineClassKt$box$75 { final class Overrides_inlineClassKt$box$76 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: double - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: double + 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 @@ -1696,8 +1714,8 @@ final class Overrides_inlineClassKt$box$76 { final class Overrides_inlineClassKt$box$77 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: double - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: double + 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 @@ -1708,8 +1726,8 @@ final class Overrides_inlineClassKt$box$77 { final class Overrides_inlineClassKt$box$78 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: double - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: double + 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 @@ -1720,8 +1738,8 @@ final class Overrides_inlineClassKt$box$78 { final class Overrides_inlineClassKt$box$79 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: double - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: double + 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 @@ -1732,8 +1750,8 @@ final class Overrides_inlineClassKt$box$79 { final class Overrides_inlineClassKt$box$8 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -1744,8 +1762,8 @@ final class Overrides_inlineClassKt$box$8 { final class Overrides_inlineClassKt$box$80 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: double - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: double + 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 @@ -1756,8 +1774,8 @@ final class Overrides_inlineClassKt$box$80 { final class Overrides_inlineClassKt$box$81 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: double - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: double + 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 @@ -1768,8 +1786,8 @@ final class Overrides_inlineClassKt$box$81 { final class Overrides_inlineClassKt$box$82 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: double - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: double + 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 @@ -1780,8 +1798,8 @@ final class Overrides_inlineClassKt$box$82 { final class Overrides_inlineClassKt$box$83 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: double - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: double + 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 @@ -1792,10 +1810,10 @@ final class Overrides_inlineClassKt$box$83 { final class Overrides_inlineClassKt$box$84 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: double + 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 @@ -1806,10 +1824,10 @@ final class Overrides_inlineClassKt$box$84 { final class Overrides_inlineClassKt$box$85 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: double + 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 @@ -1820,10 +1838,10 @@ final class Overrides_inlineClassKt$box$85 { final class Overrides_inlineClassKt$box$86 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: double + 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 @@ -1834,10 +1852,10 @@ final class Overrides_inlineClassKt$box$86 { final class Overrides_inlineClassKt$box$87 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: double + 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 @@ -1848,10 +1866,10 @@ final class Overrides_inlineClassKt$box$87 { final class Overrides_inlineClassKt$box$88 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: double + 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 @@ -1862,10 +1880,10 @@ final class Overrides_inlineClassKt$box$88 { final class Overrides_inlineClassKt$box$89 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: double + 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 @@ -1888,10 +1906,10 @@ final class Overrides_inlineClassKt$box$9 { final class Overrides_inlineClassKt$box$90 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: double + 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 @@ -1902,10 +1920,10 @@ final class Overrides_inlineClassKt$box$90 { final class Overrides_inlineClassKt$box$91 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: double + 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 @@ -1916,10 +1934,10 @@ final class Overrides_inlineClassKt$box$91 { final class Overrides_inlineClassKt$box$92 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: double + 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 @@ -1930,10 +1948,10 @@ final class Overrides_inlineClassKt$box$92 { final class Overrides_inlineClassKt$box$93 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: double + 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 @@ -1944,10 +1962,10 @@ final class Overrides_inlineClassKt$box$93 { final class Overrides_inlineClassKt$box$94 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: double + 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 @@ -1958,10 +1976,10 @@ final class Overrides_inlineClassKt$box$94 { final class Overrides_inlineClassKt$box$95 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: double - synthetic final field $tmp1_dPoint$y: double - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: double + 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 @@ -1972,8 +1990,8 @@ final class Overrides_inlineClassKt$box$95 { final class Overrides_inlineClassKt$box$96 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -1984,8 +2002,8 @@ final class Overrides_inlineClassKt$box$96 { final class Overrides_inlineClassKt$box$97 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -1996,8 +2014,8 @@ final class Overrides_inlineClassKt$box$97 { final class Overrides_inlineClassKt$box$98 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -2008,8 +2026,8 @@ final class Overrides_inlineClassKt$box$98 { final class Overrides_inlineClassKt$box$99 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPointWithInterface$x: double - synthetic final field $tmp1_dPointWithInterface$y: double + 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 @@ -2020,8 +2038,8 @@ final class Overrides_inlineClassKt$box$99 { final class Overrides_inlineClassKt$box$dPointLam$1 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2056,8 +2074,8 @@ final class Overrides_inlineClassKt$box$lam1$1 { final class Overrides_inlineClassKt$box$lam10$1 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2080,8 +2098,8 @@ final class Overrides_inlineClassKt$box$lam11$1 { final class Overrides_inlineClassKt$box$lam12$1 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2104,8 +2122,8 @@ final class Overrides_inlineClassKt$box$lam13$1 { final class Overrides_inlineClassKt$box$lam14$1 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2128,8 +2146,8 @@ final class Overrides_inlineClassKt$box$lam15$1 { final class Overrides_inlineClassKt$box$lam16$1 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2152,8 +2170,8 @@ final class Overrides_inlineClassKt$box$lam17$1 { final class Overrides_inlineClassKt$box$lam18$1 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2176,8 +2194,8 @@ final class Overrides_inlineClassKt$box$lam19$1 { final class Overrides_inlineClassKt$box$lam2$1 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2212,8 +2230,8 @@ final class Overrides_inlineClassKt$box$lam3$1 { final class Overrides_inlineClassKt$box$lam4$1 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2236,8 +2254,8 @@ final class Overrides_inlineClassKt$box$lam5$1 { final class Overrides_inlineClassKt$box$lam6$1 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2260,8 +2278,8 @@ final class Overrides_inlineClassKt$box$lam7$1 { final class Overrides_inlineClassKt$box$lam8$1 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_dPoint$x: double - synthetic final field $tmp1_dPoint$y: double + 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 @@ -2284,8 +2302,8 @@ final class Overrides_inlineClassKt$box$lam9$1 { final class Overrides_inlineClassKt$box$otherDPointLam$1 { // source: 'overrides_inlineClass.kt' enclosing method Overrides_inlineClassKt.box()Ljava/lang/String; - synthetic final field $tmp0_otherDPoint$x: double - synthetic final field $tmp1_otherDPoint$y: double + 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 @@ -2467,16 +2485,18 @@ public final class Overrides_inlineClassKt { @kotlin.Metadata public final class RealOverride { // source: 'overrides_inlineClass.kt' - private field p$x: double - private field p$y: double + 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 final method getP$x-3cLST_U(): double - public final method getP$y-3cLST_U(): double 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 @@ -2491,22 +2511,23 @@ public final class ReifiedFakeOverride { 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 field field1: double - private field field2: double + 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 final method getField1-3cLST_U(): double - public final method getField2-3cLST_U(): double + public final static method getField1-impl(p0: double, p1: double): double + public final static method getField2-impl(p0: double, p1: double): double 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 @@ -2519,15 +2540,20 @@ public final class ReifiedFakeOverrideMFVC { 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-impl0(): double - public synthetic final method unbox-impl1(): double + 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 } @@ -2536,7 +2562,11 @@ public interface ReifiedMFVCHolder { 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 @@ -2546,7 +2576,11 @@ public final class ReifiedMFVCHolderWithImpls$DefaultImpls { 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 @@ -2557,6 +2591,8 @@ 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 @@ -2567,7 +2603,11 @@ public interface SomePointInterface { 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 diff --git a/compiler/testData/codegen/box/valueClasses/overrides_typeParameters.txt b/compiler/testData/codegen/box/valueClasses/overrides_typeParameters.txt index 9d3ff1f850c..6df22aedf9c 100644 --- a/compiler/testData/codegen/box/valueClasses/overrides_typeParameters.txt +++ b/compiler/testData/codegen/box/valueClasses/overrides_typeParameters.txt @@ -38,22 +38,23 @@ public final class GenericFakeOverride { 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 field field1: java.lang.Object - private field field2: java.lang.Object + 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 final method getField1(): java.lang.Object - public final method getField2(): java.lang.Object + public final static method getField1-impl(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object + public final static method getField2-impl(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object 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 @@ -70,24 +71,25 @@ public final class GenericFakeOverrideMFVC { 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-impl0(): java.lang.Object - public synthetic final method unbox-impl1(): java.lang.Object + 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 field field1: java.lang.Object - private field field2: java.lang.Object + 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 final method getField1(): java.lang.Object - public final method getField2(): java.lang.Object + public final static method getField1-impl(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object + public final static method getField2-impl(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object 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 @@ -100,8 +102,9 @@ public final class GenericFakeOverrideMFVCWithMFVCUpperBound { 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-impl0(): java.lang.Object - public synthetic final method unbox-impl1(): java.lang.Object + 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 @@ -112,6 +115,7 @@ public final class GenericFakeOverrideWithMFVCUpperBound { 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 @@ -147,7 +151,11 @@ public interface GenericMFVCHolderWithImpls { 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 } @@ -156,7 +164,11 @@ public interface GenericMFVCHolderWithMFVCUpperBound { 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 @@ -166,7 +178,11 @@ public final class GenericMFVCHolderWithMFVCUpperBoundWithImpls$DefaultImpls { 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 @@ -188,8 +204,8 @@ final class Overrides_typeParametersKt$box$1 { final class Overrides_typeParametersKt$box$10 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$10 method (p0: java.lang.Object, p1: java.lang.Object): void public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean @@ -200,8 +216,8 @@ final class Overrides_typeParametersKt$box$10 { final class Overrides_typeParametersKt$box$100 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPointWithInterface$x: java.lang.Object - synthetic final field $tmp1_xPointWithInterface$y: 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$100 method (p0: java.lang.Object, p1: java.lang.Object): void public final @org.jetbrains.annotations.NotNull method invoke(): XPoint @@ -212,8 +228,8 @@ final class Overrides_typeParametersKt$box$100 { final class Overrides_typeParametersKt$box$101 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPointWithInterface$x: java.lang.Object - synthetic final field $tmp1_xPointWithInterface$y: 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$101 method (p0: java.lang.Object, p1: java.lang.Object): void public final @org.jetbrains.annotations.NotNull method invoke(): XPoint @@ -224,8 +240,8 @@ final class Overrides_typeParametersKt$box$101 { final class Overrides_typeParametersKt$box$102 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPointWithInterface$x: java.lang.Object - synthetic final field $tmp1_xPointWithInterface$y: 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$102 method (p0: java.lang.Object, p1: java.lang.Object): void public final @org.jetbrains.annotations.NotNull method invoke(): XPoint @@ -236,8 +252,8 @@ final class Overrides_typeParametersKt$box$102 { final class Overrides_typeParametersKt$box$103 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPointWithInterface$x: java.lang.Object - synthetic final field $tmp1_xPointWithInterface$y: 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$103 method (p0: java.lang.Object, p1: java.lang.Object): void public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer @@ -248,8 +264,8 @@ final class Overrides_typeParametersKt$box$103 { final class Overrides_typeParametersKt$box$104 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPointWithInterface$x: java.lang.Object - synthetic final field $tmp1_xPointWithInterface$y: 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$104 method (p0: java.lang.Object, p1: java.lang.Object): void public final @org.jetbrains.annotations.NotNull method invoke(): XPoint @@ -260,10 +276,10 @@ final class Overrides_typeParametersKt$box$104 { final class Overrides_typeParametersKt$box$105 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp0_xPointWithInterface$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object - synthetic final field $tmp1_xPointWithInterface$y: java.lang.Object + 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 @@ -274,10 +290,10 @@ final class Overrides_typeParametersKt$box$105 { final class Overrides_typeParametersKt$box$106 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp0_xPointWithInterface$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object - synthetic final field $tmp1_xPointWithInterface$y: java.lang.Object + 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 @@ -288,8 +304,8 @@ final class Overrides_typeParametersKt$box$106 { final class Overrides_typeParametersKt$box$107 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPointWithInterface$x: java.lang.Object - synthetic final field $tmp1_xPointWithInterface$y: 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$107 method (p0: java.lang.Object, p1: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -300,8 +316,8 @@ final class Overrides_typeParametersKt$box$107 { final class Overrides_typeParametersKt$box$108 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPointWithInterface$x: java.lang.Object - synthetic final field $tmp1_xPointWithInterface$y: 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$108 method (p0: java.lang.Object, p1: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -312,10 +328,10 @@ final class Overrides_typeParametersKt$box$108 { final class Overrides_typeParametersKt$box$109 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp0_xPointWithInterface$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object - synthetic final field $tmp1_xPointWithInterface$y: java.lang.Object + 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 @@ -338,10 +354,10 @@ final class Overrides_typeParametersKt$box$11 { final class Overrides_typeParametersKt$box$110 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp0_xPointWithInterface$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object - synthetic final field $tmp1_xPointWithInterface$y: java.lang.Object + 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 @@ -352,10 +368,10 @@ final class Overrides_typeParametersKt$box$110 { final class Overrides_typeParametersKt$box$111 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp0_xPointWithInterface$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object - synthetic final field $tmp1_xPointWithInterface$y: java.lang.Object + 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 @@ -366,8 +382,8 @@ final class Overrides_typeParametersKt$box$111 { final class Overrides_typeParametersKt$box$112 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPointWithInterface$x: java.lang.Object - synthetic final field $tmp1_xPointWithInterface$y: 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$112 method (p0: java.lang.Object, p1: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -378,10 +394,10 @@ final class Overrides_typeParametersKt$box$112 { final class Overrides_typeParametersKt$box$113 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp0_xPointWithInterface$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object - synthetic final field $tmp1_xPointWithInterface$y: java.lang.Object + 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 @@ -392,8 +408,8 @@ final class Overrides_typeParametersKt$box$113 { final class Overrides_typeParametersKt$box$114 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xSegment$p1$x: java.lang.Object - synthetic final field $tmp1_xSegment$p1$y: java.lang.Object + 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 @@ -404,8 +420,8 @@ final class Overrides_typeParametersKt$box$114 { final class Overrides_typeParametersKt$box$115 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp2_xSegment$p2$x: java.lang.Object - synthetic final field $tmp3_xSegment$p2$y: 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$115 method (p0: java.lang.Object, p1: java.lang.Object): void public final @org.jetbrains.annotations.NotNull method invoke(): XPoint @@ -428,7 +444,7 @@ final class Overrides_typeParametersKt$box$116 { final class Overrides_typeParametersKt$box$117 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object + 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 @@ -451,7 +467,7 @@ final class Overrides_typeParametersKt$box$118 { final class Overrides_typeParametersKt$box$119 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xSegment$p1$x: java.lang.Object + 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 @@ -462,8 +478,8 @@ final class Overrides_typeParametersKt$box$119 { final class Overrides_typeParametersKt$box$12 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$12 method (p0: java.lang.Object, p1: java.lang.Object): void public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean @@ -486,7 +502,7 @@ final class Overrides_typeParametersKt$box$120 { final class Overrides_typeParametersKt$box$121 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_otherXPoint$x: java.lang.Object + 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 @@ -509,7 +525,7 @@ final class Overrides_typeParametersKt$box$122 { final class Overrides_typeParametersKt$box$123 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp2_xSegment$p2$x: java.lang.Object + 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 @@ -532,7 +548,7 @@ final class Overrides_typeParametersKt$box$124 { final class Overrides_typeParametersKt$box$125 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp1_xPoint$y: java.lang.Object + 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 @@ -555,7 +571,7 @@ final class Overrides_typeParametersKt$box$126 { final class Overrides_typeParametersKt$box$127 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp1_xSegment$p1$y: java.lang.Object + 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 @@ -578,7 +594,7 @@ final class Overrides_typeParametersKt$box$128 { final class Overrides_typeParametersKt$box$129 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp1_otherXPoint$y: java.lang.Object + 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 @@ -613,7 +629,7 @@ final class Overrides_typeParametersKt$box$130 { final class Overrides_typeParametersKt$box$131 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp3_xSegment$p2$y: java.lang.Object + 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 @@ -624,10 +640,10 @@ final class Overrides_typeParametersKt$box$131 { final class Overrides_typeParametersKt$box$132 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xSegment$p1$x: java.lang.Object - synthetic final field $tmp1_xSegment$p1$y: java.lang.Object - synthetic final field $tmp2_xSegment$p2$x: java.lang.Object - synthetic final field $tmp3_xSegment$p2$y: java.lang.Object + 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 @@ -638,10 +654,10 @@ final class Overrides_typeParametersKt$box$132 { final class Overrides_typeParametersKt$box$133 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xSegment$p1$x: java.lang.Object - synthetic final field $tmp1_xSegment$p1$y: java.lang.Object - synthetic final field $tmp2_xSegment$p2$x: java.lang.Object - synthetic final field $tmp3_xSegment$p2$y: java.lang.Object + 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 @@ -664,10 +680,10 @@ final class Overrides_typeParametersKt$box$134 { final class Overrides_typeParametersKt$box$135 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xSegment$p1$x: java.lang.Object - synthetic final field $tmp1_xSegment$p1$y: java.lang.Object - synthetic final field $tmp2_xSegment$p2$x: java.lang.Object - synthetic final field $tmp3_xSegment$p2$y: java.lang.Object + 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 @@ -690,10 +706,10 @@ final class Overrides_typeParametersKt$box$136 { final class Overrides_typeParametersKt$box$137 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xSegment$p1$x: java.lang.Object - synthetic final field $tmp1_xSegment$p1$y: java.lang.Object - synthetic final field $tmp2_xSegment$p2$x: java.lang.Object - synthetic final field $tmp3_xSegment$p2$y: java.lang.Object + 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 @@ -716,10 +732,10 @@ final class Overrides_typeParametersKt$box$138 { final class Overrides_typeParametersKt$box$139 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xSegment$p1$x: java.lang.Object - synthetic final field $tmp1_xSegment$p1$y: java.lang.Object - synthetic final field $tmp2_xSegment$p2$x: java.lang.Object - synthetic final field $tmp3_xSegment$p2$y: java.lang.Object + 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 @@ -730,10 +746,10 @@ final class Overrides_typeParametersKt$box$139 { final class Overrides_typeParametersKt$box$14 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_otherXPoint$x: java.lang.Object - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_otherXPoint$y: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object + 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 @@ -756,10 +772,10 @@ final class Overrides_typeParametersKt$box$140 { final class Overrides_typeParametersKt$box$141 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xSegment$p1$x: java.lang.Object - synthetic final field $tmp1_xSegment$p1$y: java.lang.Object - synthetic final field $tmp2_xSegment$p2$x: java.lang.Object - synthetic final field $tmp3_xSegment$p2$y: java.lang.Object + 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 @@ -782,10 +798,10 @@ final class Overrides_typeParametersKt$box$15 { final class Overrides_typeParametersKt$box$16 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_otherXPoint$x: java.lang.Object - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_otherXPoint$y: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object + 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 @@ -808,10 +824,10 @@ final class Overrides_typeParametersKt$box$17 { final class Overrides_typeParametersKt$box$18 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_otherXPoint$x: java.lang.Object - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_otherXPoint$y: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object + 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 @@ -834,8 +850,8 @@ final class Overrides_typeParametersKt$box$19 { final class Overrides_typeParametersKt$box$2 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$2 method (p0: java.lang.Object, p1: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -846,10 +862,10 @@ final class Overrides_typeParametersKt$box$2 { final class Overrides_typeParametersKt$box$20 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_otherXPoint$x: java.lang.Object - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_otherXPoint$y: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object + 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 @@ -860,8 +876,8 @@ final class Overrides_typeParametersKt$box$20 { final class Overrides_typeParametersKt$box$21 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$21 method (p0: java.lang.Object, p1: java.lang.Object): void public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer @@ -872,8 +888,8 @@ final class Overrides_typeParametersKt$box$21 { final class Overrides_typeParametersKt$box$22 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$22 method (p0: java.lang.Object, p1: java.lang.Object): void public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer @@ -896,7 +912,7 @@ final class Overrides_typeParametersKt$box$23 { final class Overrides_typeParametersKt$box$24 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object + 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 @@ -919,8 +935,8 @@ final class Overrides_typeParametersKt$box$25 { final class Overrides_typeParametersKt$box$26 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$26 method (p0: java.lang.Object, p1: java.lang.Object): void public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double @@ -943,7 +959,7 @@ final class Overrides_typeParametersKt$box$27 { final class Overrides_typeParametersKt$box$28 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp1_xPoint$y: java.lang.Object + 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 @@ -978,8 +994,8 @@ final class Overrides_typeParametersKt$box$3 { final class Overrides_typeParametersKt$box$30 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$30 method (p0: java.lang.Object, p1: java.lang.Object): void public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Double @@ -1089,8 +1105,8 @@ final class Overrides_typeParametersKt$box$39 { final class Overrides_typeParametersKt$box$4 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$4 method (p0: java.lang.Object, p1: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1102,8 +1118,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$40 method (p0: RealOverride, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1115,8 +1131,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$41 method (p0: RealOverride, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1128,8 +1144,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$42 method (p0: RealOverride, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1141,8 +1157,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$43 method (p0: RealOverride, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1154,8 +1170,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$44 method (p0: RealOverride, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1167,8 +1183,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$45 method (p0: RealOverride, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1180,8 +1196,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$46 method (p0: RealOverride, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1193,8 +1209,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$47 method (p0: RealOverride, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1349,8 +1365,8 @@ final class Overrides_typeParametersKt$box$59 { final class Overrides_typeParametersKt$box$6 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$6 method (p0: java.lang.Object, p1: java.lang.Object): void public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean @@ -1362,8 +1378,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$60 method (p0: GenericFakeOverride, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1375,8 +1391,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$61 method (p0: GenericFakeOverride, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1388,8 +1404,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$62 method (p0: GenericFakeOverride, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1401,8 +1417,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$63 method (p0: GenericFakeOverride, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1414,8 +1430,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$64 method (p0: ReifiedFakeOverride, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1427,8 +1443,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$65 method (p0: ReifiedFakeOverride, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1440,8 +1456,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$66 method (p0: ReifiedFakeOverride, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1453,8 +1469,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$67 method (p0: ReifiedFakeOverride, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1466,8 +1482,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$68 method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1479,8 +1495,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$69 method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1504,8 +1520,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$70 method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1517,8 +1533,8 @@ 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 $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$71 method (p0: GenericFakeOverrideWithMFVCUpperBound, p1: java.lang.Object, p2: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1529,8 +1545,8 @@ final class Overrides_typeParametersKt$box$71 { final class Overrides_typeParametersKt$box$72 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: java.lang.Object - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: java.lang.Object + 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 @@ -1541,8 +1557,8 @@ final class Overrides_typeParametersKt$box$72 { final class Overrides_typeParametersKt$box$73 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: java.lang.Object - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: java.lang.Object + 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 @@ -1553,8 +1569,8 @@ final class Overrides_typeParametersKt$box$73 { final class Overrides_typeParametersKt$box$74 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: java.lang.Object - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: java.lang.Object + 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 @@ -1565,8 +1581,8 @@ final class Overrides_typeParametersKt$box$74 { final class Overrides_typeParametersKt$box$75 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: java.lang.Object - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: java.lang.Object + 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 @@ -1577,8 +1593,8 @@ final class Overrides_typeParametersKt$box$75 { final class Overrides_typeParametersKt$box$76 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: java.lang.Object - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: java.lang.Object + 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 @@ -1589,8 +1605,8 @@ final class Overrides_typeParametersKt$box$76 { final class Overrides_typeParametersKt$box$77 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: java.lang.Object - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: java.lang.Object + 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 @@ -1601,8 +1617,8 @@ final class Overrides_typeParametersKt$box$77 { final class Overrides_typeParametersKt$box$78 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: java.lang.Object - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: java.lang.Object + 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 @@ -1613,8 +1629,8 @@ final class Overrides_typeParametersKt$box$78 { final class Overrides_typeParametersKt$box$79 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: java.lang.Object - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: java.lang.Object + 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 @@ -1625,8 +1641,8 @@ final class Overrides_typeParametersKt$box$79 { final class Overrides_typeParametersKt$box$8 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$8 method (p0: java.lang.Object, p1: java.lang.Object): void public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Boolean @@ -1637,8 +1653,8 @@ final class Overrides_typeParametersKt$box$8 { final class Overrides_typeParametersKt$box$80 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: java.lang.Object - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: java.lang.Object + 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 @@ -1649,8 +1665,8 @@ final class Overrides_typeParametersKt$box$80 { final class Overrides_typeParametersKt$box$81 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: java.lang.Object - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: java.lang.Object + 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 @@ -1661,8 +1677,8 @@ final class Overrides_typeParametersKt$box$81 { final class Overrides_typeParametersKt$box$82 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: java.lang.Object - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: java.lang.Object + 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 @@ -1673,8 +1689,8 @@ final class Overrides_typeParametersKt$box$82 { final class Overrides_typeParametersKt$box$83 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: java.lang.Object - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: java.lang.Object + 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 @@ -1685,10 +1701,10 @@ final class Overrides_typeParametersKt$box$83 { final class Overrides_typeParametersKt$box$84 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: java.lang.Object - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object + 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 @@ -1699,10 +1715,10 @@ final class Overrides_typeParametersKt$box$84 { final class Overrides_typeParametersKt$box$85 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: java.lang.Object - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object + 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 @@ -1713,10 +1729,10 @@ final class Overrides_typeParametersKt$box$85 { final class Overrides_typeParametersKt$box$86 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: java.lang.Object - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object + 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 @@ -1727,10 +1743,10 @@ final class Overrides_typeParametersKt$box$86 { final class Overrides_typeParametersKt$box$87 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVC$field1: java.lang.Object - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_genericFakeOverrideMFVC$field2: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object + 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 @@ -1741,10 +1757,10 @@ final class Overrides_typeParametersKt$box$87 { final class Overrides_typeParametersKt$box$88 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: java.lang.Object - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object + 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 @@ -1755,10 +1771,10 @@ final class Overrides_typeParametersKt$box$88 { final class Overrides_typeParametersKt$box$89 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: java.lang.Object - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object + 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 @@ -1781,10 +1797,10 @@ final class Overrides_typeParametersKt$box$9 { final class Overrides_typeParametersKt$box$90 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: java.lang.Object - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object + 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 @@ -1795,10 +1811,10 @@ final class Overrides_typeParametersKt$box$90 { final class Overrides_typeParametersKt$box$91 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_reifiedFakeOverrideMFVC$field1: java.lang.Object - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_reifiedFakeOverrideMFVC$field2: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object + 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 @@ -1809,10 +1825,10 @@ final class Overrides_typeParametersKt$box$91 { final class Overrides_typeParametersKt$box$92 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: java.lang.Object - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object + 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 @@ -1823,10 +1839,10 @@ final class Overrides_typeParametersKt$box$92 { final class Overrides_typeParametersKt$box$93 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: java.lang.Object - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object + 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 @@ -1837,10 +1853,10 @@ final class Overrides_typeParametersKt$box$93 { final class Overrides_typeParametersKt$box$94 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: java.lang.Object - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object + 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 @@ -1851,10 +1867,10 @@ final class Overrides_typeParametersKt$box$94 { final class Overrides_typeParametersKt$box$95 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_genericFakeOverrideMFVCWithMFVCUpperBound$field1: java.lang.Object - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_genericFakeOverrideMFVCWithMFVCUpperBound$field2: java.lang.Object - synthetic final field $tmp1_xPoint$y: java.lang.Object + 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 @@ -1865,8 +1881,8 @@ final class Overrides_typeParametersKt$box$95 { final class Overrides_typeParametersKt$box$96 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPointWithInterface$x: java.lang.Object - synthetic final field $tmp1_xPointWithInterface$y: 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$96 method (p0: java.lang.Object, p1: java.lang.Object): void public final @org.jetbrains.annotations.NotNull method invoke(): XPoint @@ -1877,8 +1893,8 @@ final class Overrides_typeParametersKt$box$96 { final class Overrides_typeParametersKt$box$97 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPointWithInterface$x: java.lang.Object - synthetic final field $tmp1_xPointWithInterface$y: 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$97 method (p0: java.lang.Object, p1: java.lang.Object): void public final @org.jetbrains.annotations.NotNull method invoke(): XPoint @@ -1889,8 +1905,8 @@ final class Overrides_typeParametersKt$box$97 { final class Overrides_typeParametersKt$box$98 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPointWithInterface$x: java.lang.Object - synthetic final field $tmp1_xPointWithInterface$y: 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$98 method (p0: java.lang.Object, p1: java.lang.Object): void public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer @@ -1901,8 +1917,8 @@ final class Overrides_typeParametersKt$box$98 { final class Overrides_typeParametersKt$box$99 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPointWithInterface$x: java.lang.Object - synthetic final field $tmp1_xPointWithInterface$y: 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$99 method (p0: java.lang.Object, p1: java.lang.Object): void public final @org.jetbrains.annotations.NotNull method invoke(): java.lang.Integer @@ -1937,8 +1953,8 @@ final class Overrides_typeParametersKt$box$lam1$1 { final class Overrides_typeParametersKt$box$lam10$1 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$lam10$1 method (p0: java.lang.Object, p1: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1961,8 +1977,8 @@ final class Overrides_typeParametersKt$box$lam11$1 { final class Overrides_typeParametersKt$box$lam12$1 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$lam12$1 method (p0: java.lang.Object, p1: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -1985,8 +2001,8 @@ final class Overrides_typeParametersKt$box$lam13$1 { final class Overrides_typeParametersKt$box$lam14$1 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$lam14$1 method (p0: java.lang.Object, p1: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -2009,8 +2025,8 @@ final class Overrides_typeParametersKt$box$lam15$1 { final class Overrides_typeParametersKt$box$lam16$1 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$lam16$1 method (p0: java.lang.Object, p1: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -2033,8 +2049,8 @@ final class Overrides_typeParametersKt$box$lam17$1 { final class Overrides_typeParametersKt$box$lam18$1 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$lam18$1 method (p0: java.lang.Object, p1: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -2057,8 +2073,8 @@ final class Overrides_typeParametersKt$box$lam19$1 { final class Overrides_typeParametersKt$box$lam2$1 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$lam2$1 method (p0: java.lang.Object, p1: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -2093,8 +2109,8 @@ final class Overrides_typeParametersKt$box$lam3$1 { final class Overrides_typeParametersKt$box$lam4$1 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$lam4$1 method (p0: java.lang.Object, p1: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -2117,8 +2133,8 @@ final class Overrides_typeParametersKt$box$lam5$1 { final class Overrides_typeParametersKt$box$lam6$1 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$lam6$1 method (p0: java.lang.Object, p1: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -2141,8 +2157,8 @@ final class Overrides_typeParametersKt$box$lam7$1 { final class Overrides_typeParametersKt$box$lam8$1 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$lam8$1 method (p0: java.lang.Object, p1: java.lang.Object): void public synthetic bridge method invoke(): java.lang.Object @@ -2165,8 +2181,8 @@ final class Overrides_typeParametersKt$box$lam9$1 { final class Overrides_typeParametersKt$box$otherXPointLam$1 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_otherXPoint$x: java.lang.Object - synthetic final field $tmp1_otherXPoint$y: java.lang.Object + 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 @@ -2177,8 +2193,8 @@ final class Overrides_typeParametersKt$box$otherXPointLam$1 { final class Overrides_typeParametersKt$box$xPointLam$1 { // source: 'overrides_typeParameters.kt' enclosing method Overrides_typeParametersKt.box()Ljava/lang/String; - synthetic final field $tmp0_xPoint$x: java.lang.Object - synthetic final field $tmp1_xPoint$y: 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$xPointLam$1 method (p0: java.lang.Object, p1: java.lang.Object): void public final @org.jetbrains.annotations.NotNull method invoke(): XPoint @@ -2361,15 +2377,17 @@ public final class Overrides_typeParametersKt { @kotlin.Metadata public final class RealOverride { // source: 'overrides_typeParameters.kt' - private field p$x: java.lang.Object - private field p$y: java.lang.Object + 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 final method getP$x(): java.lang.Object - public final method getP$y(): java.lang.Object 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 @@ -2384,22 +2402,23 @@ public final class ReifiedFakeOverride { 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 field field1: java.lang.Object - private field field2: java.lang.Object + 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 final method getField1(): java.lang.Object - public final method getField2(): java.lang.Object + public final static method getField1-impl(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object + public final static method getField2-impl(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object 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 @@ -2412,15 +2431,20 @@ public final class ReifiedFakeOverrideMFVC { 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-impl0(): java.lang.Object - public synthetic final method unbox-impl1(): java.lang.Object + 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 } @@ -2429,7 +2453,11 @@ public interface ReifiedMFVCHolder { 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 @@ -2439,7 +2467,11 @@ public final class ReifiedMFVCHolderWithImpls$DefaultImpls { 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 @@ -2466,6 +2498,8 @@ 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 @@ -2476,7 +2510,11 @@ public interface SomePointInterface { 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 @@ -2487,16 +2525,18 @@ public interface SomePointInterfaceWithMFVCBound { @kotlin.Metadata public final class XPoint { // source: 'overrides_typeParameters.kt' - private field x: java.lang.Object - private field y: java.lang.Object + 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 final method getX(): java.lang.Object - public final method getY(): java.lang.Object + public method getX(): java.lang.Object + public static method getX-impl(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object + public method getY(): java.lang.Object + public static method getY-impl(p0: java.lang.Object, p1: java.lang.Object): 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 @@ -2505,16 +2545,16 @@ public final class XPoint { 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-impl0(): java.lang.Object - public synthetic final method unbox-impl1(): java.lang.Object + 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 field x: java.lang.Object - private field y: java.lang.Object + 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 @@ -2528,8 +2568,8 @@ public final class XPointWithInterface { 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 final method getX(): java.lang.Object - public final method getY(): java.lang.Object + public final static method getX-impl(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object + public final static method getY-impl(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object 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 @@ -2541,40 +2581,40 @@ public final class XPointWithInterface { 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-impl0(): java.lang.Object - public synthetic final method unbox-impl1(): java.lang.Object + 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 field p1$x: java.lang.Object - private field p1$y: java.lang.Object - private field p2$x: java.lang.Object - private field p2$y: java.lang.Object + 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 final method getP1$x(): java.lang.Object - public final method getP1$y(): java.lang.Object - public final @org.jetbrains.annotations.NotNull method getP1(): XPoint + public @org.jetbrains.annotations.NotNull method getP1(): XPoint public synthetic bridge method getP1(): java.lang.Object - public final method getP2$x(): java.lang.Object - public final method getP2$y(): java.lang.Object - public final @org.jetbrains.annotations.NotNull method getP2(): XPoint + public static @org.jetbrains.annotations.NotNull method getP1-impl(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): XPoint + public @org.jetbrains.annotations.NotNull method getP2(): XPoint public synthetic bridge method getP2(): java.lang.Object + public static @org.jetbrains.annotations.NotNull method getP2-impl(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): XPoint 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-impl0(): java.lang.Object - public synthetic final method unbox-impl1(): java.lang.Object - public synthetic final method unbox-impl2(): java.lang.Object - public synthetic final method unbox-impl3(): java.lang.Object + 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 diff --git a/compiler/testData/codegen/box/valueClasses/throwingMFVCReassignments.txt b/compiler/testData/codegen/box/valueClasses/throwingMFVCReassignments.txt index 77a8799dadd..0f7e98b0c3c 100644 --- a/compiler/testData/codegen/box/valueClasses/throwingMFVCReassignments.txt +++ b/compiler/testData/codegen/box/valueClasses/throwingMFVCReassignments.txt @@ -2,33 +2,33 @@ @kotlin.Metadata public final class DPoint { // source: 'throwingMFVCReassignments.kt' - private field x: double - private field y: double + 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 final method getX(): double - public final method getY(): double + public final static method getX-impl(p0: double, p1: double): double + public final static method getY-impl(p0: double, p1: double): double public method hashCode(): int public static method hashCode-impl(p0: double, p1: double): int public @org.jetbrains.annotations.NotNull method toString(): java.lang.String public static method toString-impl(p0: double, p1: double): java.lang.String - public synthetic final method unbox-impl0(): double - public synthetic final method unbox-impl1(): double + 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$x: double - private field value$y: double + private field value-0: double + private field value-1: double public method (p0: double, p1: double): void - public final method getValue$x(): double - public final method getValue$y(): double public final @org.jetbrains.annotations.NotNull method getValue(): DPoint + public synthetic final method getValue-0(): double + public synthetic final method getValue-1(): double public final method setValue-sUp7gFk(p0: double, p1: double): void } diff --git a/compiler/testData/codegen/box/valueClasses/visibility.kt b/compiler/testData/codegen/box/valueClasses/visibility.kt index ac11720b4c4..14272fd1063 100644 --- a/compiler/testData/codegen/box/valueClasses/visibility.kt +++ b/compiler/testData/codegen/box/valueClasses/visibility.kt @@ -1,5 +1,3 @@ -// 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 @@ -9,15 +7,29 @@ @JvmInline value class Public(val x: Int, val y: Int) { companion object { - // TODO + 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 - // TODO + @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) } } @@ -60,11 +72,11 @@ class Regular { 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) @@ -73,11 +85,11 @@ class Regular { 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) @@ -86,12 +98,11 @@ class Regular { private set internal var z5: Private = Private(33, 34) private set - + var z6: Private = Private(35, 36) internal set - + companion object { - // TODO @JvmStatic var staticX1: Public = Public(-1, -2) internal var staticX2: Public = Public(-3, -4) private var staticX3: Public = Public(-5, -6) @@ -129,19 +140,157 @@ class Regular { 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 + } - - // TODO statics + fun callAll() { - z6 - x3 - x3.x - x3.y + 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 { - Regular().callAll() + 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 index 08da759a2cd..fc668485956 100644 --- a/compiler/testData/codegen/box/valueClasses/visibility.txt +++ b/compiler/testData/codegen/box/valueClasses/visibility.txt @@ -1,377 +1,788 @@ +@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' - private field x: int - private field y: int + public final static @org.jetbrains.annotations.NotNull field Companion: Internal$Companion + private final field field-0: int + private final field field-1: 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 method getX$main(): int - public final method getY$main(): int + public final static @org.jetbrains.annotations.NotNull method getT(): Internal + public final static method getX(): int + public final static method getX-impl$main(p0: int, p1: int): int + public final static method getY(): int + public final static method getY-impl$main(p0: int, p1: int): 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-impl0(): int - public synthetic final method unbox-impl1(): int + 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 field value$x: int - private field value$y: int + 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 final @org.jetbrains.annotations.NotNull method getValue$main(): Internal - public final method getValue$x$main(): int - public final method getValue$y$main(): int + public final static @org.jetbrains.annotations.NotNull method getValue-impl$main(p0: int, p1: int): Internal public method hashCode(): int public static method hashCode-impl(p0: int, p1: int): int public @org.jetbrains.annotations.NotNull method toString(): java.lang.String public static method toString-impl(p0: int, p1: int): java.lang.String - public synthetic final method unbox-impl0(): int - public synthetic final method unbox-impl1(): int + 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 field value$x: int - private field value$y: int + 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 final @org.jetbrains.annotations.NotNull method getValue$main(): Private - private final method getValue$x(): int - private final method getValue$y(): int + public final static @org.jetbrains.annotations.NotNull method getValue-impl$main(p0: int, p1: int): Private public method hashCode(): int public static method hashCode-impl(p0: int, p1: int): int public @org.jetbrains.annotations.NotNull method toString(): java.lang.String public static method toString-impl(p0: int, p1: int): java.lang.String - public synthetic final method unbox-impl0(): int - public synthetic final method unbox-impl1(): int + 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 field value$x: int - private field value$y: int + 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 final @org.jetbrains.annotations.NotNull method getValue$main(): Public - public final method getValue$x$main(): int - public final method getValue$y$main(): int + public final static @org.jetbrains.annotations.NotNull method getValue-impl$main(p0: int, p1: int): Public public method hashCode(): int public static method hashCode-impl(p0: int, p1: int): int public @org.jetbrains.annotations.NotNull method toString(): java.lang.String public static method toString-impl(p0: int, p1: int): java.lang.String - public synthetic final method unbox-impl0(): int - public synthetic final method unbox-impl1(): int + 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 field x: int - private field y: int + 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 - private final method getX(): int - private final method getY(): int public method hashCode(): int public static method hashCode-impl(p0: int, p1: int): int public @org.jetbrains.annotations.NotNull method toString(): java.lang.String public static method toString-impl(p0: int, p1: int): java.lang.String - public synthetic final method unbox-impl0(): int - public synthetic final method unbox-impl1(): int + 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 field value$x: int - private field value$y: int + 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 - private final method getValue$x(): int - private final method getValue$y(): int - private final method getValue(): Internal public method hashCode(): int public static method hashCode-impl(p0: int, p1: int): int public @org.jetbrains.annotations.NotNull method toString(): java.lang.String public static method toString-impl(p0: int, p1: int): java.lang.String - public synthetic final method unbox-impl0(): int - public synthetic final method unbox-impl1(): int + 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 field value$x: int - private field value$y: int + 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 - private final method getValue$x(): int - private final method getValue$y(): int - private final method getValue(): Private public method hashCode(): int public static method hashCode-impl(p0: int, p1: int): int public @org.jetbrains.annotations.NotNull method toString(): java.lang.String public static method toString-impl(p0: int, p1: int): java.lang.String - public synthetic final method unbox-impl0(): int - public synthetic final method unbox-impl1(): int + 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 field value$x: int - private field value$y: int + 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 - private final method getValue$x(): int - private final method getValue$y(): int - private final method getValue(): Public public method hashCode(): int public static method hashCode-impl(p0: int, p1: int): int public @org.jetbrains.annotations.NotNull method toString(): java.lang.String public static method toString-impl(p0: int, p1: int): java.lang.String - public synthetic final method unbox-impl0(): int - public synthetic final method unbox-impl1(): int + 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' - private field x: int - private field y: int + public final static @org.jetbrains.annotations.NotNull field Companion: Public$Companion + private final field field-0: int + private final field field-1: 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 final method getX(): int - public final method getY(): int + public final static method getX-impl(p0: int, p1: int): int + public final static method getY-impl(p0: int, p1: int): int public method hashCode(): int public static method hashCode-impl(p0: int, p1: int): int public @org.jetbrains.annotations.NotNull method toString(): java.lang.String public static method toString-impl(p0: int, p1: int): java.lang.String - public synthetic final method unbox-impl0(): int - public synthetic final method unbox-impl1(): int + 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 field value$x: int - private field value$y: int + 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 final method getValue$x$main(): int - public final method getValue$y$main(): int - public final @org.jetbrains.annotations.NotNull method getValue(): Internal + public final static @org.jetbrains.annotations.NotNull method getValue-impl(p0: int, p1: int): Internal public method hashCode(): int public static method hashCode-impl(p0: int, p1: int): int public @org.jetbrains.annotations.NotNull method toString(): java.lang.String public static method toString-impl(p0: int, p1: int): java.lang.String - public synthetic final method unbox-impl0(): int - public synthetic final method unbox-impl1(): int + 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 field value$x: int - private field value$y: int + 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 - private final method getValue$x(): int - private final method getValue$y(): int - public final @org.jetbrains.annotations.NotNull method getValue(): Private + public final static @org.jetbrains.annotations.NotNull method getValue-impl(p0: int, p1: int): Private public method hashCode(): int public static method hashCode-impl(p0: int, p1: int): int public @org.jetbrains.annotations.NotNull method toString(): java.lang.String public static method toString-impl(p0: int, p1: int): java.lang.String - public synthetic final method unbox-impl0(): int - public synthetic final method unbox-impl1(): int + 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 field value$x: int - private field value$y: int + 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 final method getValue$x(): int - public final method getValue$y(): int - public final @org.jetbrains.annotations.NotNull method getValue(): Public + public final static @org.jetbrains.annotations.NotNull method getValue-impl(p0: int, p1: int): Public public method hashCode(): int public static method hashCode-impl(p0: int, p1: int): int public @org.jetbrains.annotations.NotNull method toString(): java.lang.String public static method toString-impl(p0: int, p1: int): java.lang.String - public synthetic final method unbox-impl0(): int - public synthetic final method unbox-impl1(): int + 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' - private field x1$x: int - private field x1$y: int - private field x2$x: int - private field x2$y: int - private field x3$x: int - private field x3$y: int - private field x4$x: int - private field x4$y: int - private field x5$x: int - private field x5$y: int - private field x6$x: int - private field x6$y: int - private field y1$x: int - private field y1$y: int - private field y2$x: int - private field y2$y: int - private field y3$x: int - private field y3$y: int - private field y4$x: int - private field y4$y: int - private field y5$x: int - private field y5$y: int - private field y6$x: int - private field y6$y: int - private field z1$x: int - private field z1$y: int - private field z2$x: int - private field z2$y: int - private field z3$x: int - private field z3$y: int - private field z4$x: int - private field z4$y: int - private field z5$x: int - private field z5$y: int - private field z6$x: int - private field z6$y: int + 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 method getX1$x(): int - public final method getX1$y(): int + 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 final method getX2$x$main(): int - public final method getX2$y$main(): int + public synthetic final method getX2-0(): int + public synthetic final method getX2-1(): int private final method getX3(): Public - public final method getX4$x(): int - public final method getX4$y(): int + 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 final method getX5$x$main(): int - public final method getX5$y$main(): int - public final method getX6$x(): int - public final method getX6$y(): int + public synthetic final method getX5-0(): int + public synthetic final method getX5-1(): int public final @org.jetbrains.annotations.NotNull method getX6(): Public - public final method getY1$x$main(): int - public final method getY1$y$main(): int + 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 final method getY2$x$main(): int - public final method getY2$y$main(): int + public synthetic final method getY2-0(): int + public synthetic final method getY2-1(): int private final method getY3(): Internal - public final method getY4$x$main(): int - public final method getY4$y$main(): int + 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 final method getY5$x$main(): int - public final method getY5$y$main(): int - public final method getY6$x$main(): int - public final method getY6$y$main(): int + 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 - private final method setX3-sUp7gFk(p0: int, p1: int): void - private final method setX4-sUp7gFk(p0: int, p1: int): void - private final method setX5-sUp7gFk(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 - private final method setY3-sUp7gFk(p0: int, p1: int): void - private final method setY4-sUp7gFk(p0: int, p1: int): void - private final method setY5-sUp7gFk(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 - private final method setZ3-sUp7gFk(p0: int, p1: int): void - private final method setZ4-sUp7gFk(p0: int, p1: int): void - private final method setZ5-sUp7gFk(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/MFVCDeclaration.kt b/compiler/testData/codegen/bytecodeText/valueClasses/MFVCDeclaration.kt index ae79d97bcfb..782b2c3ae08 100644 --- a/compiler/testData/codegen/bytecodeText/valueClasses/MFVCDeclaration.kt +++ b/compiler/testData/codegen/bytecodeText/valueClasses/MFVCDeclaration.kt @@ -41,28 +41,27 @@ fun functionWithoutBoxes(x: D, y: D) { // 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 -// 1 public final getX\(\)LC; -// 1 public final getX\$x\(\)I -// 1 public final getX\$y-\w*\(\)I -// 1 public final getX\$z\(\)Ljava/lang/String; +// 1 public final static getX-impl\(.+\)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; -// 2 public final synthetic unbox-impl0\(\)I -// 2 public final synthetic unbox-impl1\(\)I -// 2 public final synthetic unbox-impl2\(\)Ljava/lang/String; -// 1 private I x\$x -// 1 private I x\$y -// 1 private Ljava/lang/String; x\$z -// 0 private LC; x -// 3 private I x -// 1 private I y -// 1 private Ljava/lang/String; z +// 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 // 1 INVOKESTATIC D.box-impl \(IILjava/lang/String;\)LD; -// 1 INVOKESTATIC D.box-impl \(IILjava/lang/String;\)LD;\n ARETURN -// 1 INVOKESTATIC C.box-impl \(IILjava/lang/String;\)LC; -// 1 INVOKESTATIC C.box-impl \(IILjava/lang/String;\)LC;\n ARETURN +// 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;))) diff --git a/compiler/testData/codegen/bytecodeText/valueClasses/MFVCReassignments.kt b/compiler/testData/codegen/bytecodeText/valueClasses/MFVCReassignments.kt index 09cb8313ae9..13430de8ad9 100644 --- a/compiler/testData/codegen/bytecodeText/valueClasses/MFVCReassignments.kt +++ b/compiler/testData/codegen/bytecodeText/valueClasses/MFVCReassignments.kt @@ -62,12 +62,10 @@ fun reassignField(x: DPoint, box: Box) { // 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 -// 1 109(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){2}110 -// 0 109(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){3}110 +// 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 -// 1 112(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){2}113 -// 0 112(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){3}113 -// 1 113(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){2}114 -// 0 113(\D|\d\D|\d\d\D)*(DSTORE(\D|\d\D|\d\d\D)*){3}114 +// 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/equalsBoxTest.kt b/compiler/testData/codegen/bytecodeText/valueClasses/equalsBoxTest.kt index cd648dfeb75..939d65ebd3b 100644 --- a/compiler/testData/codegen/bytecodeText/valueClasses/equalsBoxTest.kt +++ b/compiler/testData/codegen/bytecodeText/valueClasses/equalsBoxTest.kt @@ -13,18 +13,43 @@ fun DPoint.toObject() = this as Any fun DPoint.toDPointOrNull() = this as DPoint? fun Nothing?.toDPointOrNull() = this as DPoint? -fun equalsChecks(left: DPoint, right: 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()) } @@ -36,7 +61,7 @@ fun equalsChecks(left: DPoint, right: DPoint) { // 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}DUP\n {4}IFNONNULL.*(\n {3}([^b\n]|b[^o\n]|bo[^x\n]|box-impl\d)*)*\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}DUP\n {4}IFNONNULL.*(\n {3}([^b\n]|b[^o\n]|bo[^x\n]|box-impl\d)*)*\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/regularClassWithMFVC.kt b/compiler/testData/codegen/bytecodeText/valueClasses/regularClassWithMFVC.kt index 72acb825bf3..548ecf738bb 100644 --- a/compiler/testData/codegen/bytecodeText/valueClasses/regularClassWithMFVC.kt +++ b/compiler/testData/codegen/bytecodeText/valueClasses/regularClassWithMFVC.kt @@ -74,20 +74,20 @@ fun trySetSegment(segment: DSegment) { // 0 public final getOpposite\(\)LDPoint; // 1 public final static getOpposite-impl\(DD\)LDPoint; -// 1 private D p1\$x -// 1 private D p1\$y +// 1 private D p1-0 +// 1 private D p1-1 // 0 private DPoint; p1 -// 1 private D p2\$x -// 1 private D p2\$y +// 1 private D p2-0 +// 1 private D p2-1 // 0 private DPoint; p2 -// 1 private D point1WithBackingFieldAndDefaultGetter\$x -// 1 private D point1WithBackingFieldAndDefaultGetter\$y +// 1 private D point1WithBackingFieldAndDefaultGetter-0 +// 1 private D point1WithBackingFieldAndDefaultGetter-1 // 0 private DPoint; point1WithBackingFieldAndDefaultGetter -// 1 private D point2WithBackingFieldAndDefaultGetter\$x -// 1 private D point2WithBackingFieldAndDefaultGetter\$y +// 1 private D point2WithBackingFieldAndDefaultGetter-0 +// 1 private D point2WithBackingFieldAndDefaultGetter-1 // 0 private DPoint; point2WithBackingFieldAndDefaultGetter -// 1 private D pointWithBackingFieldAndCustomGetter\$x -// 1 private D pointWithBackingFieldAndCustomGetter\$y +// 1 private D pointWithBackingFieldAndCustomGetter-0 +// 1 private D pointWithBackingFieldAndCustomGetter-1 // 0 private DPoint; pointWithBackingFieldAndCustomGetter // 0 private DPoint; notImplemented // 0 private D notImplemented @@ -108,22 +108,22 @@ fun trySetSegment(segment: DSegment) { // 1 public final setPoint2WithBackingFieldAndDefaultGetter-sUp7gFk\(DD\)V // 1 public final getPointWithBackingFieldAndCustomGetter\(\)LDPoint; // 1 public final setPointWithBackingFieldAndCustomGetter-sUp7gFk\(DD\)V -// 1 public final getP1\$x\(\)D -// 1 public final getP1\$y\(\)D -// 1 public final getP2\$x\(\)D -// 1 public final getP2\$y\(\)D -// 1 public final getPoint1WithBackingFieldAndDefaultGetter\$x\(\)D -// 1 public final getPoint1WithBackingFieldAndDefaultGetter\$y\(\)D -// 1 public final getPoint2WithBackingFieldAndDefaultGetter\$x\(\)D -// 1 public final getPoint2WithBackingFieldAndDefaultGetter\$y\(\)D +// 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;)){13} -// 0 tryGetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}.*LDPoint;)){14} +// 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} @@ -137,13 +137,8 @@ fun trySetSegment(segment: DSegment) { // 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} -// 1 tryGetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DPoint\.getX \(\)D)){3} -// 0 tryGetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DPoint\.getX \(\)D)){4} -// 0 trySetSegment\(LDSegment;\)V.*(\n {3}.*)*(\n {4}INVOKEVIRTUAL DPoint\.getX \(\)D) -// 1 tryGetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DPoint\.getY \(\)D)){3} -// 0 tryGetSegment\(LDSegment;\)V.*((\n {3}.*)*(\n {4}INVOKEVIRTUAL DPoint\.getY \(\)D)){4} -// 0 trySetSegment\(LDSegment;\)V.*(\n {3}.*)*(\n {4}INVOKEVIRTUAL DPoint\.getY \(\)D) -// 1 tryGetSegment\(LDSegment;\)V.*((\n {3}.*)*?(\n {4}INVOKEVIRTUAL DSegment\.get.*\$[xy] \(\)D)){8} -// 0 tryGetSegment\(LDSegment;\)V.*((\n {3}.*)*?(\n {4}INVOKEVIRTUAL DSegment\.get.*\$[xy] \(\)D)){9} -// 1 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*?(\n {4}INVOKEVIRTUAL DSegment\.get.*\$[xy] \(\)D)){12} -// 0 trySetSegment\(LDSegment;\)V.*((\n {3}.*)*?(\n {4}INVOKEVIRTUAL DSegment\.get.*\$[xy] \(\)D)){13} +// 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/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 1e1b33b6bef..9c07a19faaf 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 @@ -50202,9 +50202,9 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } @Test - @TestMetadata("MFVCFieldInitializationOrder.kt") - public void testMFVCFieldInitializationOrder() throws Exception { - runTest("compiler/testData/codegen/box/valueClasses/MFVCFieldInitializationOrder.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); + @TestMetadata("MfvcFieldInitializationOrder.kt") + public void testMfvcFieldInitializationOrder() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/MfvcFieldInitializationOrder.kt", TransformersFunctions.getReplaceOptionalJvmInlineAnnotationWithReal()); } @Test