From 40f38c8adb55787de1acfe2d1be87ebe496511c6 Mon Sep 17 00:00:00 2001 From: "Evgeniy.Zhelenskiy" Date: Sun, 13 Nov 2022 21:57:15 +0100 Subject: [PATCH] [IR] Eliminate redundant boxing/unboxing of MFVC after inlining Signed-off-by: Evgeniy.Zhelenskiy #KT-1179 --- .../optimization/boxing/BoxedBasicValue.kt | 81 +- .../optimization/boxing/BoxingInterpreter.kt | 42 +- .../boxing/RedundantBoxingInterpreter.kt | 12 +- .../RedundantBoxingMethodTransformer.kt | 211 +- .../optimization/common/FastMethodAnalyzer.kt | 5 + .../kotlin/codegen/state/GenerationState.kt | 15 +- .../FirBlackBoxCodegenTestGenerated.java | 6 + .../backend/jvm/codegen/ExpressionCodegen.kt | 4 +- .../lower/JvmMultiFieldValueClassLowering.kt | 250 +- .../kotlin/backend/jvm/JvmBackendContext.kt | 8 + .../jvm/JvmLoweredDeclarationOrigin.kt | 6 +- ...emoizedMultiFieldValueClassReplacements.kt | 2 +- .../jetbrains/kotlin/backend/jvm/MfvcNode.kt | 2 +- .../kotlin/backend/jvm/MfvcNodeInstance.kt | 8 +- .../ir/declarations/IrDeclarationOrigin.kt | 3 - .../box/valueClasses/classFlattening.txt | 1 - .../box/valueClasses/defaultParameters.txt | 1 - .../valueClasses/functionReferences.fir.txt | 2066 ----------------- .../box/valueClasses/functionReferences.kt | 29 +- .../box/valueClasses/functionReferences.txt | 28 +- .../box/valueClasses/inlineFunctions.kt | 85 + .../box/valueClasses/inlineFunctions.txt | 110 + .../valueClasses/mfvcReassignments.kt | 18 +- .../valueClasses/passingMFVC2Functions.kt | 19 +- .../IrBlackBoxCodegenTestGenerated.java | 6 + 25 files changed, 726 insertions(+), 2292 deletions(-) delete mode 100644 compiler/testData/codegen/box/valueClasses/functionReferences.fir.txt create mode 100644 compiler/testData/codegen/box/valueClasses/inlineFunctions.kt create mode 100644 compiler/testData/codegen/box/valueClasses/inlineFunctions.txt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxedBasicValue.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxedBasicValue.kt index a65a411e0b6..bf73af557d1 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxedBasicValue.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxedBasicValue.kt @@ -20,10 +20,16 @@ import com.intellij.openapi.util.Pair import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.codegen.optimization.common.StrictBasicValue import org.jetbrains.kotlin.codegen.state.GenerationState +import org.jetbrains.kotlin.codegen.state.GenerationState.MultiFieldValueClassUnboxInfo import org.jetbrains.kotlin.resolve.isInlineClass +import org.jetbrains.kotlin.resolve.isMultiFieldValueClass import org.jetbrains.kotlin.resolve.jvm.AsmTypes +import org.jetbrains.org.objectweb.asm.Opcodes import org.jetbrains.org.objectweb.asm.Type import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode +import org.jetbrains.org.objectweb.asm.tree.InsnList +import org.jetbrains.org.objectweb.asm.tree.InsnNode +import org.jetbrains.org.objectweb.asm.tree.MethodInsnNode abstract class BoxedBasicValue(type: Type) : StrictBasicValue(type) { abstract val descriptor: BoxedValueDescriptor @@ -55,22 +61,33 @@ class TaintedBoxedValue(private val boxedBasicValue: CleanBoxedValue) : BoxedBas class BoxedValueDescriptor( - boxedType: Type, + val boxedType: Type, val boxingInsn: AbstractInsnNode, val progressionIterator: ProgressionIteratorBasicValue?, val generationState: GenerationState ) { - private val associatedInsns = HashSet() - private val unboxingWithCastInsns = HashSet>() + private val associatedInsns = LinkedHashSet() + private val unboxingWithCastInsns = LinkedHashSet>() private val associatedVariables = HashSet() private val mergedWith = HashSet() var isSafeToRemove = true; private set - val unboxedType: Type = getUnboxedType(boxedType, generationState) - val isInlineClassValue = isInlineClassValue(boxedType) + val multiFieldValueClassUnboxInfo = getMultiFieldValueClassUnboxInfo(boxedType, generationState) + val unboxedTypes: List = getUnboxedTypes(boxedType, generationState, multiFieldValueClassUnboxInfo) + + fun getUnboxTypeOrOtherwiseMethodReturnType(methodInsnNode: MethodInsnNode?) = + unboxedTypes.singleOrNull() ?: Type.getReturnType(methodInsnNode!!.desc) + + val isValueClassValue = isValueClassValue(boxedType) fun getAssociatedInsns() = associatedInsns.toList() + fun sortAssociatedInsns(indexes: Map) { + val newOrder = associatedInsns.sortedBy { indexes[it]!! } + associatedInsns.clear() + associatedInsns.addAll(newOrder) + } + fun addInsn(insnNode: AbstractInsnNode) { associatedInsns.add(insnNode) } @@ -93,7 +110,7 @@ class BoxedValueDescriptor( isSafeToRemove = false } - fun isDoubleSize() = unboxedType.size == 2 + fun getTotalUnboxSize() = unboxedTypes.sumOf { it.size } fun isFromProgressionIterator() = progressionIterator != null @@ -103,16 +120,51 @@ class BoxedValueDescriptor( fun getUnboxingWithCastInsns(): Set> = unboxingWithCastInsns + + fun sortUnboxingWithCastInsns(indexes: Map) { + val newInsnsAndResultTypes = unboxingWithCastInsns.sortedBy { insnAndResultType -> indexes[insnAndResultType.first]!! } + unboxingWithCastInsns.clear() + unboxingWithCastInsns.addAll(newInsnsAndResultTypes) + } +} + +internal fun makePops(unboxedTypes: List) = InsnList().apply { + var restSingleSize = false + for (unboxType in unboxedTypes.asReversed()) { + restSingleSize = when (unboxType.size) { + 1 -> { + if (restSingleSize) add(InsnNode(Opcodes.POP2)) + !restSingleSize + } + + 2 -> { + if (restSingleSize) add(InsnNode(Opcodes.POP)) + add(InsnNode(Opcodes.POP2)) + false + } + + else -> error("Illegal type size: ${unboxType.size}") + } + } + + if (restSingleSize) { + add(InsnNode(Opcodes.POP)) + } } -fun getUnboxedType(boxedType: Type, state: GenerationState): Type { +fun getUnboxedTypes( + boxedType: Type, + state: GenerationState, + multiFieldValueClassUnboxInfo: MultiFieldValueClassUnboxInfo? +): List { val primitiveType = AsmUtil.unboxPrimitiveTypeOrNull(boxedType) - if (primitiveType != null) return primitiveType + if (primitiveType != null) return listOf(primitiveType) - if (boxedType == AsmTypes.K_CLASS_TYPE) return AsmTypes.JAVA_CLASS_TYPE + if (boxedType == AsmTypes.K_CLASS_TYPE) return listOf(AsmTypes.JAVA_CLASS_TYPE) - unboxedTypeOfInlineClass(boxedType, state)?.let { return it } + unboxedTypeOfInlineClass(boxedType, state)?.let { return listOf(it) } + multiFieldValueClassUnboxInfo?.let { return it.unboxedTypes } throw IllegalArgumentException("Expected primitive type wrapper or KClass or inline class wrapper, got: $boxedType") } @@ -123,6 +175,13 @@ fun unboxedTypeOfInlineClass(boxedType: Type, state: GenerationState): Type? { return state.mapInlineClass(descriptor) } -private fun isInlineClassValue(boxedType: Type): Boolean { +fun getMultiFieldValueClassUnboxInfo(boxedType: Type, state: GenerationState): MultiFieldValueClassUnboxInfo? { + val descriptor = + state.jvmBackendClassResolver.resolveToClassDescriptors(boxedType).singleOrNull()?.takeIf { it.isMultiFieldValueClass() } + ?: return null + return state.multiFieldValueClassUnboxInfo(descriptor) +} + +private fun isValueClassValue(boxedType: Type): Boolean { return !AsmUtil.isBoxedPrimitiveType(boxedType) && boxedType != AsmTypes.K_CLASS_TYPE } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxingInterpreter.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxingInterpreter.kt index 816ac95141a..c4eaac73577 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxingInterpreter.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/BoxingInterpreter.kt @@ -180,7 +180,7 @@ open class BoxingInterpreter( v is TaintedBoxedValue -> v w is TaintedBoxedValue -> w v.type != w.type -> mergeBoxedHazardous(v, w, isLocalVariable) - else -> v + else -> v // two clean boxed values with the same type are equal } } v is BoxedBasicValue -> @@ -222,10 +222,10 @@ private val KCLASS_TO_JLCLASS = Type.getMethodDescriptor(AsmTypes.JAVA_CLASS_TYP private val JLCLASS_TO_KCLASS = Type.getMethodDescriptor(AsmTypes.K_CLASS_TYPE, AsmTypes.JAVA_CLASS_TYPE) fun AbstractInsnNode.isUnboxing(state: GenerationState) = - isPrimitiveUnboxing() || isJavaLangClassUnboxing() || isInlineClassUnboxing(state) + isPrimitiveUnboxing() || isJavaLangClassUnboxing() || isInlineClassUnboxing(state) || isMultiFieldValueClassUnboxing(state) fun AbstractInsnNode.isBoxing(state: GenerationState) = - isPrimitiveBoxing() || isJavaLangClassBoxing() || isInlineClassBoxing(state) || isCoroutinePrimitiveBoxing() + isPrimitiveBoxing() || isJavaLangClassBoxing() || isInlineClassBoxing(state) || isCoroutinePrimitiveBoxing() || isMultiFieldValueClassBoxing(state) fun AbstractInsnNode.isPrimitiveUnboxing() = isMethodInsnWith(Opcodes.INVOKEVIRTUAL) { @@ -292,11 +292,21 @@ private fun AbstractInsnNode.isInlineClassBoxing(state: GenerationState) = isInlineClassBoxingMethodDescriptor(state) } +private fun AbstractInsnNode.isMultiFieldValueClassBoxing(state: GenerationState) = + isMethodInsnWith(Opcodes.INVOKESTATIC) { + isMultiFieldValueClassBoxingMethodDescriptor(state) + } + private fun AbstractInsnNode.isInlineClassUnboxing(state: GenerationState) = isMethodInsnWith(Opcodes.INVOKEVIRTUAL) { isInlineClassUnboxingMethodDescriptor(state) } +private fun AbstractInsnNode.isMultiFieldValueClassUnboxing(state: GenerationState) = + isMethodInsnWith(Opcodes.INVOKEVIRTUAL) { + isMultiFieldValueClassUnboxingMethodDescriptor(state) + } + private fun MethodInsnNode.isInlineClassBoxingMethodDescriptor(state: GenerationState): Boolean { if (name != KotlinTypeMapper.BOX_JVM_METHOD_NAME) return false @@ -305,6 +315,14 @@ private fun MethodInsnNode.isInlineClassBoxingMethodDescriptor(state: Generation return desc == Type.getMethodDescriptor(ownerType, unboxedType) } +private fun MethodInsnNode.isMultiFieldValueClassBoxingMethodDescriptor(state: GenerationState): Boolean { + if (name != KotlinTypeMapper.BOX_JVM_METHOD_NAME) return false + + val ownerType = Type.getObjectType(owner) + val multiFieldValueClassUnboxInfo = getMultiFieldValueClassUnboxInfo(ownerType, state) ?: return false + return desc == Type.getMethodDescriptor(ownerType, *multiFieldValueClassUnboxInfo.unboxedTypes.toTypedArray()) +} + private fun MethodInsnNode.isInlineClassUnboxingMethodDescriptor(state: GenerationState): Boolean { if (name != KotlinTypeMapper.UNBOX_JVM_METHOD_NAME) return false @@ -313,6 +331,14 @@ private fun MethodInsnNode.isInlineClassUnboxingMethodDescriptor(state: Generati return desc == Type.getMethodDescriptor(unboxedType) } +private fun MethodInsnNode.isMultiFieldValueClassUnboxingMethodDescriptor(state: GenerationState): Boolean { + val ownerType = Type.getObjectType(owner) + val multiFieldValueClassUnboxInfo = getMultiFieldValueClassUnboxInfo(ownerType, state) ?: return false + return multiFieldValueClassUnboxInfo.unboxedTypesAndMethodNamesAndFieldNames.any { (type, methodName) -> + name == methodName && desc == Type.getMethodDescriptor(type) + } +} + fun AbstractInsnNode.isNextMethodCallOfProgressionIterator(values: List) = values.firstOrNull() is ProgressionIteratorBasicValue && isMethodInsnWith(Opcodes.INVOKEINTERFACE) { @@ -349,8 +375,8 @@ fun areSameTypedPrimitiveBoxedValues(values: List): Boolean { val (v1, v2) = values return v1 is BoxedBasicValue && v2 is BoxedBasicValue && - v1.descriptor.unboxedType == v2.descriptor.unboxedType && - !v1.descriptor.isInlineClassValue && !v2.descriptor.isInlineClassValue + !v1.descriptor.isValueClassValue && !v2.descriptor.isValueClassValue && + v1.descriptor.unboxedTypes.single() == v2.descriptor.unboxedTypes.single() } fun AbstractInsnNode.isAreEqualIntrinsic() = @@ -362,8 +388,10 @@ fun AbstractInsnNode.isAreEqualIntrinsic() = private val shouldUseEqualsForWrappers = setOf(Type.DOUBLE_TYPE, Type.FLOAT_TYPE, AsmTypes.JAVA_CLASS_TYPE) -fun canValuesBeUnboxedForAreEqual(values: List, generationState: GenerationState): Boolean = - values.none { getUnboxedType(it.type, generationState) in shouldUseEqualsForWrappers } +fun canValuesBeUnboxedForAreEqual(values: List, generationState: GenerationState): Boolean = values.none { + val unboxedType = getUnboxedTypes(it.type, generationState, getMultiFieldValueClassUnboxInfo(it.type, generationState)).singleOrNull() + unboxedType == null || unboxedType in shouldUseEqualsForWrappers +} fun AbstractInsnNode.isJavaLangComparableCompareToForSameTypedBoxedValues(values: List) = isJavaLangComparableCompareTo() && areSameTypedPrimitiveBoxedValues(values) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxingInterpreter.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxingInterpreter.kt index 41a0361a6bd..a37d1f219fd 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxingInterpreter.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxingInterpreter.kt @@ -20,16 +20,13 @@ import com.google.common.collect.ImmutableSet import org.jetbrains.kotlin.codegen.state.GenerationState import org.jetbrains.org.objectweb.asm.Opcodes import org.jetbrains.org.objectweb.asm.Type -import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode -import org.jetbrains.org.objectweb.asm.tree.InsnList -import org.jetbrains.org.objectweb.asm.tree.TypeInsnNode -import org.jetbrains.org.objectweb.asm.tree.VarInsnNode +import org.jetbrains.org.objectweb.asm.tree.* import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue internal class RedundantBoxingInterpreter( - insnList: InsnList, + methodNode: MethodNode, generationState: GenerationState -) : BoxingInterpreter(insnList, generationState) { +) : BoxingInterpreter(methodNode.instructions, generationState) { val candidatesBoxedValues = RedundantBoxedValuesCollection() @@ -81,6 +78,7 @@ internal class RedundantBoxingInterpreter( override fun onUnboxing(insn: AbstractInsnNode, value: BoxedBasicValue, resultType: Type) { value.descriptor.run { + val unboxedType = getUnboxTypeOrOtherwiseMethodReturnType(insn as? MethodInsnNode) if (unboxedType == resultType) addAssociatedInsn(value, insn) else @@ -142,7 +140,7 @@ internal class RedundantBoxingInterpreter( Type.getInternalName(Any::class.java) -> true Type.getInternalName(Number::class.java) -> - PRIMITIVE_TYPES_SORTS_WITH_WRAPPER_EXTENDS_NUMBER.contains(value.descriptor.unboxedType.sort) + value.descriptor.unboxedTypes.singleOrNull()?.sort?.let { PRIMITIVE_TYPES_SORTS_WITH_WRAPPER_EXTENDS_NUMBER.contains(it) } == true "java/lang/Comparable" -> true else -> diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxingMethodTransformer.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxingMethodTransformer.kt index 4c8ac07cc14..76538ce8554 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxingMethodTransformer.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/boxing/RedundantBoxingMethodTransformer.kt @@ -41,7 +41,7 @@ class RedundantBoxingMethodTransformer(private val generationState: GenerationSt if (insns.none { it.isBoxing(generationState) || it.isMethodInsnWith(Opcodes.INVOKEINTERFACE) { name == "next" } }) return - val interpreter = RedundantBoxingInterpreter(node.instructions, generationState) + val interpreter = RedundantBoxingInterpreter(node, generationState) val frames = BoxingAnalyzer(internalClassName, node, interpreter).analyze() interpretPopInstructionsForBoxedValues(interpreter, node, frames) @@ -55,14 +55,34 @@ class RedundantBoxingMethodTransformer(private val generationState: GenerationSt // has side effect on valuesToOptimize and frames, containing BoxedBasicValues that are unsafe to remove removeValuesClashingWithVariables(valuesToOptimize, node, frames) - adaptLocalVariableTableForBoxedValues(node, frames) + // cannot replace them inplace because replaced variables indexes are known after remapping + val variablesForReplacement = adaptLocalSingleVariableTableForBoxedValuesAndPrepareMultiVariables(node, frames) node.remapLocalVariables(buildVariablesRemapping(valuesToOptimize, node)) + replaceVariables(node, variablesForReplacement) + + sortAdaptableInstructionsForBoxedValues(node, valuesToOptimize) + adaptInstructionsForBoxedValues(node, valuesToOptimize) } } + private fun sortAdaptableInstructionsForBoxedValues(node: MethodNode, valuesToOptimize: RedundantBoxedValuesCollection) { + val indexes = node.instructions.withIndex().associate { (index, insn) -> insn to index } + for (value in valuesToOptimize) { + value.sortAssociatedInsns(indexes) + value.sortUnboxingWithCastInsns(indexes) + } + } + + private fun replaceVariables(node: MethodNode, variablesForReplacement: Map>) { + if (variablesForReplacement.isEmpty()) return + node.localVariables = node.localVariables.flatMap { oldVar -> + variablesForReplacement[oldVar]?.also { newVars -> for (newVar in newVars) newVar.index += oldVar.index } ?: listOf(oldVar) + }.toMutableList() + } + private fun interpretPopInstructionsForBoxedValues( interpreter: RedundantBoxingInterpreter, node: MethodNode, @@ -114,7 +134,7 @@ class RedundantBoxingMethodTransformer(private val generationState: GenerationSt if (boxed.isEmpty()) continue val firstBoxed = boxed.first().descriptor - if (isUnsafeToRemoveBoxingForConnectedValues(variableValues, firstBoxed.unboxedType)) { + if (isUnsafeToRemoveBoxingForConnectedValues(variableValues, firstBoxed.unboxedTypes)) { for (value in boxed) { val descriptor = value.descriptor if (descriptor.isSafeToRemove) { @@ -137,16 +157,19 @@ class RedundantBoxingMethodTransformer(private val generationState: GenerationSt } } - private fun isUnsafeToRemoveBoxingForConnectedValues(usedValues: List, unboxedType: Type): Boolean = + private fun isUnsafeToRemoveBoxingForConnectedValues(usedValues: List, unboxedTypes: List): Boolean = usedValues.any { input -> if (input === StrictBasicValue.UNINITIALIZED_VALUE) return@any false if (input !is CleanBoxedValue) return@any true val descriptor = input.descriptor - !descriptor.isSafeToRemove || descriptor.unboxedType != unboxedType + !descriptor.isSafeToRemove || descriptor.unboxedTypes != unboxedTypes } - private fun adaptLocalVariableTableForBoxedValues(node: MethodNode, frames: Array?>) { + private fun adaptLocalSingleVariableTableForBoxedValuesAndPrepareMultiVariables( + node: MethodNode, frames: Array?> + ): Map> { + val localVariablesReplacement = mutableMapOf>() for (localVariableNode in node.localVariables) { if (Type.getType(localVariableNode.desc).sort != Type.OBJECT) { continue @@ -157,9 +180,24 @@ class RedundantBoxingMethodTransformer(private val generationState: GenerationSt val descriptor = value.descriptor if (!descriptor.isSafeToRemove) continue - localVariableNode.desc = descriptor.unboxedType.descriptor + val unboxedType = descriptor.unboxedTypes.singleOrNull() + if (unboxedType == null) { + var offset = 0 + localVariablesReplacement[localVariableNode] = + descriptor.multiFieldValueClassUnboxInfo!!.unboxedTypesAndMethodNamesAndFieldNames.map { (type, _, fieldName) -> + val newVarName = "${localVariableNode.name}-$fieldName" + val newStart = localVariableNode.start + val newEnd = localVariableNode.end + val newOffset = offset + offset += type.size + LocalVariableNode(newVarName, type.descriptor, null, newStart, newEnd, newOffset) + } + } else { + localVariableNode.desc = unboxedType.descriptor + } } } + return localVariablesReplacement } private fun getValuesStoredOrLoadedToVariable( @@ -197,22 +235,24 @@ class RedundantBoxingMethodTransformer(private val generationState: GenerationSt } private fun buildVariablesRemapping(values: RedundantBoxedValuesCollection, node: MethodNode): IntArray { - val doubleSizedVars = HashSet() + val wideVars2SizeMinusOne = HashMap() for (valueDescriptor in values) { - if (valueDescriptor.isDoubleSize()) { - doubleSizedVars.addAll(valueDescriptor.getVariablesIndexes()) + val size = valueDescriptor.getTotalUnboxSize() + if (size < 2) continue + for (index in valueDescriptor.getVariablesIndexes()) { + wideVars2SizeMinusOne.merge(index, size - 1, ::maxOf) } } - node.maxLocals += doubleSizedVars.size + node.maxLocals += wideVars2SizeMinusOne.values.sum() val remapping = IntArray(node.maxLocals) for (i in remapping.indices) { remapping[i] = i } - for (varIndex in doubleSizedVars) { + for ((varIndex, shift) in wideVars2SizeMinusOne) { for (i in varIndex + 1..remapping.lastIndex) { - remapping[i]++ + remapping[i] += shift } } @@ -235,9 +275,11 @@ class RedundantBoxingMethodTransformer(private val generationState: GenerationSt adaptCastInstruction(node, value, cast) } + var extraSlotsUsed = 0 for (insn in value.getAssociatedInsns()) { - adaptInstruction(node, insn, value) + extraSlotsUsed = maxOf(extraSlotsUsed, adaptInstruction(node, insn, value)) } + node.maxLocals += extraSlotsUsed } private fun adaptBoxingInstruction(node: MethodNode, value: BoxedValueDescriptor) { @@ -268,7 +310,9 @@ class RedundantBoxingMethodTransformer(private val generationState: GenerationSt ) { val castInsn = castWithType.getFirst() val castInsnsListener = MethodNode(Opcodes.API_VERSION) - InstructionAdapter(castInsnsListener).cast(value.unboxedType, castWithType.getSecond()) + InstructionAdapter(castInsnsListener) + .cast(value.getUnboxTypeOrOtherwiseMethodReturnType(castInsn as? MethodInsnNode), castWithType.getSecond()) + for (insn in castInsnsListener.instructions.toArray()) { node.instructions.insertBefore(castInsn, insn) @@ -279,30 +323,75 @@ class RedundantBoxingMethodTransformer(private val generationState: GenerationSt private fun adaptInstruction( node: MethodNode, insn: AbstractInsnNode, value: BoxedValueDescriptor - ) { - val isDoubleSize = value.isDoubleSize() + ): Int { + var usedExtraSlots = 0 when (insn.opcode) { - Opcodes.POP -> - if (isDoubleSize) { - node.instructions.set(insn, InsnNode(Opcodes.POP2)) - } + Opcodes.POP -> { + val newPops = makePops(value.unboxedTypes) + node.instructions.insert(insn, newPops) + node.instructions.remove(insn) + } - Opcodes.DUP -> - if (isDoubleSize) { - node.instructions.set(insn, InsnNode(Opcodes.DUP2)) + Opcodes.DUP -> when (value.getTotalUnboxSize()) { + 1 -> Unit + 2 -> node.instructions.set(insn, InsnNode(Opcodes.DUP2)) + else -> { + usedExtraSlots = value.getTotalUnboxSize() + var currentSlot = node.maxLocals + val slotIndices = value.unboxedTypes.map { type -> currentSlot.also { currentSlot += type.size } } + for ((type, index) in (value.unboxedTypes zip slotIndices).asReversed()) { + node.instructions.insertBefore(insn, VarInsnNode(type.getOpcode(Opcodes.ISTORE), index)) + } + repeat(2) { + for ((type, index) in (value.unboxedTypes zip slotIndices)) { + node.instructions.insertBefore(insn, VarInsnNode(type.getOpcode(Opcodes.ILOAD), index)) + } + } + node.instructions.remove(insn) } + } Opcodes.ASTORE, Opcodes.ALOAD -> { - val storeOpcode = value.unboxedType.getOpcode(if (insn.opcode == Opcodes.ASTORE) Opcodes.ISTORE else Opcodes.ILOAD) - node.instructions.set(insn, VarInsnNode(storeOpcode, (insn as VarInsnNode).`var`)) + val isStore = insn.opcode == Opcodes.ASTORE + val singleUnboxedType = value.unboxedTypes.singleOrNull() + if (singleUnboxedType == null) { + val newInstructions = mutableListOf() + var offset = 0 + for (unboxedType in value.unboxedTypes) { + val opcode = unboxedType.getOpcode(if (isStore) Opcodes.ISTORE else Opcodes.ILOAD) + val newIndex = (insn as VarInsnNode).`var` + offset + newInstructions.add(VarInsnNode(opcode, newIndex)) + offset += unboxedType.size + } + if (isStore) { + val previousInstructions = generateSequence(insn.previous) { it.previous } + .take(value.unboxedTypes.size).toList().asReversed() + if (value.unboxedTypes.map { it.getOpcode(Opcodes.ILOAD) } == previousInstructions.map { it.opcode }) { + // help optimizer and put each xSTORE after the corresponding xLOAD + for ((load, store) in previousInstructions zip newInstructions) { + newInstructions.remove(store) + node.instructions.insert(load, store) + } + } else { + for (newInstruction in newInstructions.asReversed()) { + node.instructions.insertBefore(insn, newInstruction) + } + } + } else { + for (newInstruction in newInstructions) { + node.instructions.insertBefore(insn, newInstruction) + } + } + node.instructions.remove(insn) + } else { + val storeOpcode = singleUnboxedType.getOpcode(if (isStore) Opcodes.ISTORE else Opcodes.ILOAD) + node.instructions.set(insn, VarInsnNode(storeOpcode, (insn as VarInsnNode).`var`)) + } } Opcodes.INSTANCEOF -> { - node.instructions.insertBefore( - insn, - InsnNode(if (isDoubleSize) Opcodes.POP2 else Opcodes.POP) - ) + node.instructions.insertBefore(insn, makePops(value.unboxedTypes)) node.instructions.set(insn, InsnNode(Opcodes.ICONST_1)) } @@ -328,13 +417,63 @@ class RedundantBoxingMethodTransformer(private val generationState: GenerationSt } } - Opcodes.CHECKCAST, - Opcodes.INVOKEVIRTUAL -> + Opcodes.CHECKCAST -> node.instructions.remove(insn) + Opcodes.INVOKEVIRTUAL -> { + if (value.unboxedTypes.size != 1) { + val unboxMethodCall = insn as MethodInsnNode + val unboxMethodIndex = value.multiFieldValueClassUnboxInfo!!.unboxedMethodNames.indexOf(unboxMethodCall.name) + val unboxedType = value.unboxedTypes[unboxMethodIndex] + + var canRemoveInsns = true + var savedToVariable = false + for ((i, type) in value.unboxedTypes.withIndex().toList().asReversed()) { + fun canRemoveInsn(includeDup: Boolean): Boolean { + if (!canRemoveInsns) return false + val insnToCheck = if (i < unboxMethodIndex) unboxMethodCall.previous.previous else unboxMethodCall.previous + val result = when (insnToCheck.opcode) { + type.getOpcode(Opcodes.ILOAD) -> true + Opcodes.DUP2 -> includeDup && type.size == 2 + Opcodes.DUP -> includeDup && type.size == 1 + else -> false + } + + canRemoveInsns = result + return result + } + + fun insertPopInstruction() = + node.instructions.insertBefore(unboxMethodCall, InsnNode(if (type.size == 2) Opcodes.POP2 else Opcodes.POP)) + + fun saveToVariableIfNecessary() { + if (savedToVariable) return + if (i > unboxMethodIndex) return + savedToVariable = true + usedExtraSlots = unboxedType.size + node.instructions.insertBefore(insn, VarInsnNode(unboxedType.getOpcode(Opcodes.ISTORE), node.maxLocals)) + } + + if (i == unboxMethodIndex) { + if (unboxMethodIndex > 0 && !canRemoveInsn(includeDup = false)) { + saveToVariableIfNecessary() + } + } else if (canRemoveInsn(includeDup = i > unboxMethodIndex)) { + node.instructions.remove(if (i < unboxMethodIndex) unboxMethodCall.previous.previous else unboxMethodCall.previous) + } else { + saveToVariableIfNecessary() + insertPopInstruction() + } + } + if (savedToVariable) { + node.instructions.insertBefore(insn, VarInsnNode(unboxedType.getOpcode(Opcodes.ILOAD), node.maxLocals)) + } + } node.instructions.remove(insn) + } else -> throwCannotAdaptInstruction(insn) } + return usedExtraSlots } private fun throwCannotAdaptInstruction(insn: AbstractInsnNode): Nothing = @@ -345,14 +484,14 @@ class RedundantBoxingMethodTransformer(private val generationState: GenerationSt insn: AbstractInsnNode, value: BoxedValueDescriptor ) { - val unboxedType = value.unboxedType + val unboxedType = value.unboxedTypes.singleOrNull() - when (unboxedType.sort) { + when (unboxedType?.sort) { Type.BOOLEAN, Type.BYTE, Type.SHORT, Type.INT, Type.CHAR -> adaptAreEqualIntrinsicForInt(node, insn) Type.LONG -> adaptAreEqualIntrinsicForLong(node, insn) - Type.OBJECT -> { + Type.OBJECT, null -> { } else -> throw AssertionError("Unexpected unboxed type kind: $unboxedType") @@ -427,7 +566,7 @@ class RedundantBoxingMethodTransformer(private val generationState: GenerationSt insn: AbstractInsnNode, value: BoxedValueDescriptor ) { - val unboxedType = value.unboxedType + val unboxedType = value.unboxedTypes.single() when (unboxedType.sort) { Type.BOOLEAN, Type.BYTE, Type.SHORT, Type.INT, Type.CHAR -> diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/common/FastMethodAnalyzer.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/common/FastMethodAnalyzer.kt index af57507a80f..84e1786a113 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/common/FastMethodAnalyzer.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/common/FastMethodAnalyzer.kt @@ -236,6 +236,11 @@ open class FastMethodAnalyzer } } + /** + * Updates frame at the index [dest] with its old value if provided and previous control flow node frame [frame]. + * Reuses old frame when possible and when [canReuse] is true. + * If updated, adds the frame to the queue + */ private fun mergeControlFlowEdge(dest: Int, frame: Frame, canReuse: Boolean = false) { val oldFrame = frames[dest] val changes = when { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt index ec00914025d..24c505c4c9e 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt @@ -9,7 +9,6 @@ import com.intellij.openapi.project.Project import com.intellij.openapi.util.ModificationTracker import com.intellij.psi.PsiElement import org.jetbrains.kotlin.codegen.* -import org.jetbrains.kotlin.codegen.`when`.MappingsClassesForWhenByEnum import org.jetbrains.kotlin.codegen.binding.CodegenBinding import org.jetbrains.kotlin.codegen.context.CodegenContext import org.jetbrains.kotlin.codegen.context.RootContext @@ -20,9 +19,13 @@ import org.jetbrains.kotlin.codegen.inline.InlineCache import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicMethods import org.jetbrains.kotlin.codegen.optimization.OptimizationClassBuilderFactory import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings +import org.jetbrains.kotlin.codegen.`when`.MappingsClassesForWhenByEnum import org.jetbrains.kotlin.config.* import org.jetbrains.kotlin.config.LanguageVersion.* -import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.descriptors.DeclarationDescriptor +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.descriptors.ScriptDescriptor import org.jetbrains.kotlin.diagnostics.Diagnostic import org.jetbrains.kotlin.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory @@ -354,6 +357,14 @@ class GenerationState private constructor( val globalSerializationBindings = JvmSerializationBindings() var mapInlineClass: (ClassDescriptor) -> Type = { descriptor -> typeMapper.mapType(descriptor.defaultType) } + class MultiFieldValueClassUnboxInfo(val unboxedTypesAndMethodNamesAndFieldNames: List>) { + val unboxedTypes = unboxedTypesAndMethodNamesAndFieldNames.map { (type, _, _) -> type } + val unboxedMethodNames = unboxedTypesAndMethodNamesAndFieldNames.map { (_, methodName, _) -> methodName } + val unboxedFieldNames = unboxedTypesAndMethodNamesAndFieldNames.map { (_, _, fieldName) -> fieldName } + } + + var multiFieldValueClassUnboxInfo: (ClassDescriptor) -> MultiFieldValueClassUnboxInfo? = { null } + val typeApproximator: TypeApproximator? = if (languageVersionSettings.supportsFeature(LanguageFeature.NewInference)) TypeApproximator(module.builtIns, languageVersionSettings) 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 39b35387f7d..475e899b239 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 @@ -50501,6 +50501,12 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT runTest("compiler/testData/codegen/box/valueClasses/functionReferences.kt"); } + @Test + @TestMetadata("inlineFunctions.kt") + public void testInlineFunctions() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/inlineFunctions.kt"); + } + @Test @TestMetadata("mfvcBothEqualsOverride.kt") public void testMfvcBothEqualsOverride() throws Exception { diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt index 29e99d952a3..1107b900c9b 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt @@ -413,7 +413,9 @@ class ExpressionCodegen( get() = origin != IrDeclarationOrigin.IR_TEMPORARY_VARIABLE && origin != IrDeclarationOrigin.FOR_LOOP_ITERATOR && origin != IrDeclarationOrigin.UNDERSCORE_PARAMETER && - origin != IrDeclarationOrigin.DESTRUCTURED_OBJECT_PARAMETER + origin != IrDeclarationOrigin.DESTRUCTURED_OBJECT_PARAMETER && + origin != JvmLoweredDeclarationOrigin.TEMPORARY_MULTI_FIELD_VALUE_CLASS_VARIABLE && + origin != JvmLoweredDeclarationOrigin.TEMPORARY_MULTI_FIELD_VALUE_CLASS_PARAMETER private fun writeLocalVariablesInTable(info: BlockInfo, endLabel: Label) { info.variables.forEach { 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 823fcd253e0..797195847cd 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 @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.backend.jvm.lower import org.jetbrains.kotlin.backend.common.ScopeWithIr -import org.jetbrains.kotlin.backend.common.lower.createIrBuilder +import org.jetbrains.kotlin.backend.common.ir.inline import org.jetbrains.kotlin.backend.common.lower.irCatch import org.jetbrains.kotlin.backend.common.pop import org.jetbrains.kotlin.backend.common.push @@ -36,6 +36,7 @@ import org.jetbrains.kotlin.ir.types.* import org.jetbrains.kotlin.ir.util.* import org.jetbrains.kotlin.ir.visitors.* import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.utils.addIfNotNull internal class JvmMultiFieldValueClassLowering( context: JvmBackendContext, @@ -382,7 +383,7 @@ internal class JvmMultiFieldValueClassLowering( symbol = IrAnonymousInitializerSymbolImpl() ).apply { parent = irClass - body = context.createIrBuilder(symbol).irBlockBody { + body = context.createJvmIrBuilder(symbol).irBlockBody { +irSetField( irClass.thisReceiver!!.takeUnless { element.isStatic }?.let { irGet(it) }, element, initializer.expression, origin = UNSAFE_MFVC_SET_ORIGIN @@ -407,7 +408,7 @@ internal class JvmMultiFieldValueClassLowering( } allScopes.push(createScope(replacement)) - replacement.body = context.createIrBuilder(replacement.symbol).irBlockBody { + replacement.body = context.createJvmIrBuilder(replacement.symbol).irBlockBody { val thisVar = irTemporary(irType = replacement.returnType, nameHint = "\$this") constructor.body?.statements?.forEach { statement -> +statement.transformStatement(object : IrElementTransformerVoid() { @@ -499,7 +500,7 @@ internal class JvmMultiFieldValueClassLowering( override fun createBridgeBody(source: IrSimpleFunction, target: IrSimpleFunction, original: IrFunction, inverted: Boolean) { allScopes.push(createScope(source)) - source.body = context.createIrBuilder(source.symbol, source.startOffset, source.endOffset).run { + source.body = context.createJvmIrBuilder(source.symbol).run { val sourceExplicitParameters = source.explicitParameters val targetExplicitParameters = target.explicitParameters irExprBody(irBlock { @@ -691,7 +692,7 @@ internal class JvmMultiFieldValueClassLowering( } override fun visitParameter(parameter: IrValueParameter) { - if (parameter.origin != IrDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_PARAMETER) { + if (parameter.origin != JvmLoweredDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_PARAMETER) { super.visitParameter(parameter) } } @@ -703,7 +704,7 @@ internal class JvmMultiFieldValueClassLowering( val initializersBlocks = mfvc.declarations.filterIsInstance() val typeArguments = makeTypeParameterSubstitutionMap(mfvc, primaryConstructorImpl) - primaryConstructorImpl.body = context.createIrBuilder(primaryConstructorImpl.symbol).irBlockBody { + primaryConstructorImpl.body = context.createJvmIrBuilder(primaryConstructorImpl.symbol).irBlockBody { val mfvcNodeInstance = ValueDeclarationMfvcNodeInstance(rootMfvcNode, typeArguments, primaryConstructorImpl.valueParameters) valueDeclarationsRemapper.registerReplacement( @@ -734,8 +735,8 @@ internal class JvmMultiFieldValueClassLowering( require(irBlock.hasLambdaLikeOrigin() && irBlock.statements.size == 2) { "Illegal lambda: ${irBlock.dump()}" } val (originalFunction, ref) = irBlock.statements require(originalFunction is IrSimpleFunction && ref is IrFunctionReference && ref.symbol.owner == originalFunction) { "Illegal lambda: ${irBlock.dump()}" } - val replacement = originalFunction.getReplacement() require(originalFunction == irBlock.statements.first()) { "Illegal lambda: ${irBlock.dump()}" } + val replacement = originalFunction.getReplacement() if (replacement == null) { irBlock.statements[0] = visitFunctionNew(originalFunction) return irBlock @@ -745,31 +746,64 @@ internal class JvmMultiFieldValueClassLowering( "Expected ${replacement.render()}, got ${declarations?.map { it.render() }}" } } - postActionAfterTransformingClassDeclaration(replacement) - val newBlock = makeNewLambda(originalFunction, ref) - val newFunction = newBlock.statements[0] as IrFunction - replacement.origin = IrDeclarationOrigin.LOCAL_FUNCTION_FOR_LAMBDA - when (val body = newFunction.body) { - is IrBlockBody -> body.statements.add(0, replacement) - is IrExpressionBody -> body.expression = context.createJvmIrBuilder(newFunction.symbol).irBlock { - +replacement - +body.expression + return makeNewLambda(originalFunction, ref, makeBody = { wrapper -> + variablesToAdd[replacement]?.let { + variablesToAdd[wrapper] = it + variablesToAdd.remove(replacement) } - } - replacement.patchDeclarationParents(newFunction) - return newBlock + if (replacement in possibleExtraBoxUsageGenerated) { + possibleExtraBoxUsageGenerated.add(wrapper) + possibleExtraBoxUsageGenerated.remove(replacement) + } + with(context.createJvmIrBuilder(wrapper.symbol)) { + irExprBody(irBlock { + val newArguments: List = wrapper.explicitParameters.flatMap { parameter -> + if (!parameter.type.needsMfvcFlattening()) { + listOf(parameter) + } else { + // Old parameter value will be only used to set parameter of the lowered function, + // thus it is useless to show it in debugger + parameter.origin = JvmLoweredDeclarationOrigin.TEMPORARY_MULTI_FIELD_VALUE_CLASS_PARAMETER + val rootNode = replacements.getRootMfvcNode(parameter.type.erasedUpperBound) + rootNode.createInstanceFromBox(this, irGet(parameter), AccessType.AlwaysPublic, ::variablesSaver) + .makeFlattenedGetterExpressions(this, ::registerPossibleExtraBoxUsage) + .mapIndexed { index, expression -> + savableStandaloneVariableWithSetter( + expression = expression, + name = "${parameter.name.asString()}-${rootNode.leaves[index].fullFieldName}", + origin = JvmLoweredDeclarationOrigin.MULTI_FIELD_VALUE_CLASS_REPRESENTATION_VARIABLE, + saveVariable = ::variablesSaver, + ) + } + } + } + +replacement.inline(wrapper.parent, newArguments) + }) + } + }) } override fun visitFunctionReference(expression: IrFunctionReference): IrExpression { val originalFunction = expression.symbol.owner if (originalFunction.getReplacement() == null) return super.visitFunctionReference(expression) - return makeNewLambda(originalFunction, expression) + return makeNewLambda(originalFunction, expression, makeBody = { wrapper -> + with(context.createJvmIrBuilder(wrapper.symbol)) { + irExprBody(irCall(originalFunction).apply { + passTypeArgumentsFrom(wrapper) + for ((newParam, originalParam) in wrapper.explicitParameters zip originalFunction.explicitParameters) { + putArgument(originalParam, irGet(newParam)) + } + }).transform(this@JvmMultiFieldValueClassLowering, null) + } + }) } private fun IrFunction.getReplacement(): IrFunction? = replacements.getReplacementFunction(this) ?: (this as? IrConstructor)?.let { replacements.getReplacementForRegularClassConstructor(it) } - private fun makeNewLambda(originalFunction: IrFunction, expression: IrFunctionReference): IrContainerExpression { + private fun makeNewLambda( + originalFunction: IrFunction, expression: IrFunctionReference, makeBody: (wrapper: IrSimpleFunction) -> IrBody + ): IrContainerExpression { val currentDeclarationParent = currentDeclarationParent!! val wrapper = context.irFactory.buildFun { updateFrom(originalFunction) @@ -778,7 +812,7 @@ internal class JvmMultiFieldValueClassLowering( returnType = originalFunction.returnType name = originalFunction.name visibility = DescriptorVisibilities.LOCAL - }.apply newFunction@{ + }.apply { parent = currentDeclarationParent assert(typeParameters.isEmpty()) copyTypeParametersFrom(originalFunction) @@ -792,14 +826,7 @@ internal class JvmMultiFieldValueClassLowering( param.copyTo(this, index = index, type = param.type.substitute(substitutionMap)) } withinScope(this) { - body = with(context.createJvmIrBuilder(symbol)) { - irExprBody(irCall(originalFunction).apply { - passTypeArgumentsFrom(this@newFunction) - for ((newParam, originalParam) in explicitParameters zip originalFunction.explicitParameters) { - putArgument(originalParam, irGet(newParam)) - } - }).transform(this@JvmMultiFieldValueClassLowering, null) - } + body = makeBody(this) postActionAfterTransformingClassDeclaration(this) } } @@ -836,11 +863,14 @@ internal class JvmMultiFieldValueClassLowering( return when { function is IrConstructor && function.isPrimary && function.constructedClass.isMultiFieldValueClass && currentScope.origin != JvmLoweredDeclarationOrigin.SYNTHETIC_MULTI_FIELD_VALUE_CLASS_MEMBER -> { - context.createIrBuilder(currentScope.symbol).irBlock { + context.createJvmIrBuilder(currentScope.symbol, expression).irBlock { val rootNode = replacements.getRootMfvcNode(function.constructedClass) val instance = rootNode.createInstanceFromValueDeclarationsAndBoxType( this, function.constructedClassType as IrSimpleType, Name.identifier("constructor_tmp"), ::variablesSaver ) + for (valueDeclaration in instance.valueDeclarations) { + valueDeclaration.origin = JvmLoweredDeclarationOrigin.TEMPORARY_MULTI_FIELD_VALUE_CLASS_VARIABLE + } flattenExpressionTo(expression, instance) val getterExpression = instance.makeGetterExpression(this, ::registerPossibleExtraBoxUsage) valueDeclarationsRemapper.registerReplacement(getterExpression, instance) @@ -848,7 +878,7 @@ internal class JvmMultiFieldValueClassLowering( } } - replacement != null -> context.createIrBuilder(currentScope.symbol).irBlock { + replacement != null -> context.createJvmIrBuilder(currentScope.symbol, expression).irBlock { buildReplacement(function, expression, replacement) }.unwrapBlock() @@ -856,7 +886,7 @@ internal class JvmMultiFieldValueClassLowering( val newConstructor = (function as? IrConstructor) ?.let { replacements.getReplacementForRegularClassConstructor(it) } ?: return super.visitFunctionAccess(expression) - context.createIrBuilder(currentScope.symbol).irBlock { + context.createJvmIrBuilder(currentScope.symbol, expression).irBlock { buildReplacement(function, expression, newConstructor) }.unwrapBlock() } @@ -875,14 +905,14 @@ internal class JvmMultiFieldValueClassLowering( ) { require(callee.valueParameters.isEmpty()) { "Unexpected getter:\n${callee.dump()}" } expression.dispatchReceiver = expression.dispatchReceiver?.transform(this, null) - return context.createIrBuilder(getCurrentScopeSymbol()).irBlock { + return context.createJvmIrBuilder(getCurrentScopeSymbol(), expression).irBlock { with(valueDeclarationsRemapper) { addReplacement(expression) ?: return expression } }.unwrapBlock() } if (expression.isSpecializedMFVCEqEq) { - return context.createIrBuilder(getCurrentScopeSymbol()).irBlock { + return context.createJvmIrBuilder(getCurrentScopeSymbol(), expression).irBlock { val leftArgument = expression.getValueArgument(0)!! val rightArgument = expression.getValueArgument(1)!! val leftClass = leftArgument.type.erasedUpperBound @@ -971,7 +1001,7 @@ internal class JvmMultiFieldValueClassLowering( for (i in expression.arguments.indices) { val argument = expression.arguments[i] if (argument.type.needsMfvcFlattening()) { - expression.arguments[i] = context.createIrBuilder(getCurrentScopeSymbol()).run { + expression.arguments[i] = context.createJvmIrBuilder(getCurrentScopeSymbol(), expression).run { val toString = argument.type.erasedUpperBound.functions.single { it.isToString() } require(toString.typeParameters.isEmpty()) { "Bad toString: ${toString.render()}" } irCall(toString).apply { @@ -1087,7 +1117,7 @@ internal class JvmMultiFieldValueClassLowering( override fun visitGetField(expression: IrGetField): IrExpression { expression.receiver = expression.receiver?.transform(this, null) with(valueDeclarationsRemapper) { - return context.createIrBuilder(expression.symbol).irBlock { + return context.createJvmIrBuilder(expression.symbol, expression).irBlock { addReplacement(expression) ?: return expression }.unwrapBlock() } @@ -1096,7 +1126,7 @@ internal class JvmMultiFieldValueClassLowering( override fun visitSetField(expression: IrSetField): IrExpression { expression.receiver = expression.receiver?.transform(this, null) with(valueDeclarationsRemapper) { - return context.createIrBuilder(getCurrentScopeSymbol()).irBlock { + return context.createJvmIrBuilder(getCurrentScopeSymbol(), expression).irBlock { addReplacement(expression, safe = expression.origin != UNSAFE_MFVC_SET_ORIGIN) ?: return expression.also { it.value = it.value.transform(this@JvmMultiFieldValueClassLowering, null) } }.unwrapBlock() @@ -1105,22 +1135,23 @@ internal class JvmMultiFieldValueClassLowering( override fun visitGetValue(expression: IrGetValue): IrExpression = with(valueDeclarationsRemapper) { - context.createIrBuilder(getCurrentScopeSymbol()).makeReplacement(expression) ?: super.visitGetValue(expression) + context.createJvmIrBuilder(getCurrentScopeSymbol(), expression).makeReplacement(expression) ?: super.visitGetValue(expression) } - override fun visitSetValue(expression: IrSetValue): IrExpression = context.createIrBuilder(getCurrentScopeSymbol()).irBlock { - with(valueDeclarationsRemapper) { - addReplacement(expression, safe = expression.origin != UNSAFE_MFVC_SET_ORIGIN) - ?: return super.visitSetValue(expression) - } - }.unwrapBlock() + override fun visitSetValue(expression: IrSetValue): IrExpression = + context.createJvmIrBuilder(getCurrentScopeSymbol(), expression).irBlock { + with(valueDeclarationsRemapper) { + addReplacement(expression, safe = expression.origin != UNSAFE_MFVC_SET_ORIGIN) + ?: return super.visitSetValue(expression) + } + }.unwrapBlock() override fun visitVariable(declaration: IrVariable): IrStatement { val initializer = declaration.initializer if (declaration.type.needsMfvcFlattening()) { val irClass = declaration.type.erasedUpperBound val rootNode = replacements.getRootMfvcNode(irClass) - return context.createIrBuilder(getCurrentScopeSymbol()).irBlock { + return context.createJvmIrBuilder(getCurrentScopeSymbol(), declaration).irBlock { val instance = rootNode.createInstanceFromValueDeclarationsAndBoxType( this, declaration.type as IrSimpleType, declaration.name, ::variablesSaver ) @@ -1147,7 +1178,7 @@ internal class JvmMultiFieldValueClassLowering( val variables = rootMfvcNode.leaves.map { savableStandaloneVariable( type = it.type.substitute(typeArguments), - origin = IrDeclarationOrigin.MULTI_FIELD_VALUE_CLASS_REPRESENTATION_VARIABLE, + origin = IrDeclarationOrigin.IR_TEMPORARY_VARIABLE, saveVariable = ::variablesSaver ) } @@ -1191,12 +1222,7 @@ internal class JvmMultiFieldValueClassLowering( } if (expression is IrTry) { expression.tryResult = irBlock { flattenExpressionTo(expression.tryResult, instance) }.unwrapBlock() - expression.catches.replaceAll { - irCatch( - it.catchParameter, - irBlock { flattenExpressionTo(it.result, instance) }.unwrapBlock() - ) - } + expression.catches.replaceAll { irCatch(it.catchParameter, irBlock { flattenExpressionTo(it.result, instance) }.unwrapBlock()) } expression.finallyExpression = expression.finallyExpression?.transform(lowering, null) +expression return @@ -1414,63 +1440,62 @@ private fun IrBody.makeBodyWithAddedVariables(context: JvmBackendContext, variab */ private fun BlockOrBody.makeBodyWithAddedVariables(context: JvmBackendContext, variables: Set, symbol: IrSymbol): IrElement { if (variables.isEmpty()) return element + extractVariablesSettersToOuterPossibleBlock(variables) 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 element.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 getFirstInnerStatement(statement: IrStatement): IrStatement? = + if (statement is IrStatementContainer) statement.statements.first().let(::getFirstInnerStatement) else statement + + private fun removeFirstInnerStatement(statement: IrStatement): IrStatement? { + if (statement !is IrStatementContainer) return null + val innerResult = removeFirstInnerStatement(statement.statements[0]) + return when { + innerResult != null -> statement.also { statement.statements[0] = innerResult } + statement.statements.size > 1 -> statement.also { statement.statements.removeAt(0) } + else -> null } } - 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++ - } + private fun IrStatement.removeInnerEmptyBlocks() { + if (this !is IrContainerExpression || statements.isEmpty()) return + val emptyBlocks = statements.mapNotNull { + it.removeInnerEmptyBlocks() + if (it is IrContainerExpression && it.statements.isEmpty()) it else null } - require(removed <= toRemove) { "Removed: $removed, To remove: $toRemove" } - if (removedDirectly > 0) container.statements.replaceAll(container.statements.drop(removedDirectly)) - return removed + statements.removeAll(emptyBlocks) } private fun replaceSetVariableWithInitialization(variables: List, container: IrStatementContainer) { - val variablesSet = variables.toSet() - val statementsWithoutUsages = container.statements.takeWhile { !it.containsUsagesOf(variablesSet) } - container.statements.replaceAll(container.statements.drop(statementsWithoutUsages.size)) - val values = buildList { - for ((variable, statement) in variables.asSequence() zip getFlattenedStatements(container)) { - when { - variable.initializer != null -> break - statement !is IrSetValue -> break - statement.symbol.owner != variable -> break - else -> add(statement.value) + require(variables.all { it.initializer == null }) { "Variables must have no initializer" } + val variableFirstUsage = variables.associateWith { v -> container.statements.firstOrNull { it.containsUsagesOf(setOf(v)) } } + val variableDeclarationPerStatement = variableFirstUsage.entries + .mapNotNull { (variable, firstUsage) -> if (firstUsage == null) null else firstUsage to variable } + .groupBy({ (k, _) -> k }, { (_, v) -> v }) + if (variableDeclarationPerStatement.isEmpty()) return + val newStatements = buildList { + for (statement in container.statements) { + statement.removeInnerEmptyBlocks() + if (statement is IrContainerExpression && statement.statements.isEmpty()) continue + val varsBefore = variableDeclarationPerStatement[statement] + if (varsBefore != null) { + addAll(varsBefore) + val innerStatement = getFirstInnerStatement(statement) + if (innerStatement is IrSetValue) { + val assignedVariable = innerStatement.symbol.owner + if (assignedVariable is IrVariable && assignedVariable in varsBefore && assignedVariable.initializer == null) { + assignedVariable.initializer = innerStatement.value + addIfNotNull(removeFirstInnerStatement(statement)) + continue + } + } } + add(statement) } } - - for ((variable, value) in variables zip values) { - variable.initializer = value - } - removeFlattenedStatements(container, values.size) - container.statements.addAll(0, statementsWithoutUsages + variables) + container.statements.replaceAll(newStatements) } override fun visitBlock(expression: IrBlock): IrExpression { @@ -1505,6 +1530,41 @@ private fun BlockOrBody.makeBodyWithAddedVariables(context: JvmBackendContext, v }, null) } +private fun BlockOrBody.extractVariablesSettersToOuterPossibleBlock(variables: Set) { + element.acceptVoid(object : IrElementVisitorVoid { + override fun visitElement(element: IrElement) { + element.acceptChildrenVoid(this) + } + + override fun visitContainerExpression(expression: IrContainerExpression) { + super.visitContainerExpression(expression) + visitStatementContainer(expression) + } + + override fun visitBlockBody(body: IrBlockBody) { + super.visitBlockBody(body) + visitStatementContainer(body) + } + + private fun visitStatementContainer(container: IrStatementContainer) { + val newStatements = buildList { + for (statement in container.statements) { + if (statement is IrStatementContainer) { + val extracted = statement.statements.takeWhile { it is IrSetValue && it.symbol.owner in variables } + if (extracted.isNotEmpty()) { + statement.statements.replaceAll(statement.statements.drop(extracted.size)) + addAll(extracted) + } + if (statement.statements.isEmpty()) continue + } + add(statement) + } + } + container.statements.replaceAll(newStatements) + } + }) +} + private fun MutableList.replaceAll(replacement: List) { clear() addAll(replacement) 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 fbbaa991160..8c2ad2d0a15 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 @@ -159,6 +159,14 @@ class JvmBackendContext( state.mapInlineClass = { descriptor -> defaultTypeMapper.mapType(referenceClass(descriptor).defaultType) } + + state.multiFieldValueClassUnboxInfo = lambda@{ descriptor -> + val irClass = symbolTable.lazyWrapper.referenceClass(descriptor).owner + val node = multiFieldValueClassReplacements.getRootMfvcNodeOrNull(irClass) ?: return@lambda null + val leavesInfo = + node.leaves.map { Triple(defaultTypeMapper.mapType(it.type), it.fullMethodName.asString(), it.fullFieldName.asString()) } + GenerationState.MultiFieldValueClassUnboxInfo(leavesInfo) + } } fun referenceClass(descriptor: ClassDescriptor): IrClassSymbol = diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLoweredDeclarationOrigin.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLoweredDeclarationOrigin.kt index 09626dcdef8..c4529acaa96 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLoweredDeclarationOrigin.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmLoweredDeclarationOrigin.kt @@ -15,8 +15,6 @@ interface JvmLoweredDeclarationOrigin : IrDeclarationOrigin { object FIELD_FOR_OUTER_THIS : IrDeclarationOriginImpl("FIELD_FOR_OUTER_THIS") object LAMBDA_IMPL : IrDeclarationOriginImpl("LAMBDA_IMPL") object FUNCTION_REFERENCE_IMPL : IrDeclarationOriginImpl("FUNCTION_REFERENCE_IMPL", isSynthetic = true) - object MFVC_PRIMARY_CONSTRUCTOR_REFERENCE_HELPER : - IrDeclarationOriginImpl("MFVC_PRIMARY_CONSTRUCTOR_REFERENCE_HELPER", isSynthetic = true) object SYNTHETIC_ACCESSOR : IrDeclarationOriginImpl("SYNTHETIC_ACCESSOR", isSynthetic = true) object SYNTHETIC_ACCESSOR_FOR_HIDDEN_CONSTRUCTOR : IrDeclarationOriginImpl("SYNTHETIC_ACCESSOR_FOR_HIDDEN_CONSTRUCTOR", isSynthetic = true) @@ -40,6 +38,10 @@ interface JvmLoweredDeclarationOrigin : IrDeclarationOrigin { object STATIC_INLINE_CLASS_CONSTRUCTOR : IrDeclarationOriginImpl("STATIC_INLINE_CLASS_CONSTRUCTOR") object STATIC_MULTI_FIELD_VALUE_CLASS_CONSTRUCTOR : IrDeclarationOriginImpl("STATIC_MULTI_FIELD_VALUE_CLASS_CONSTRUCTOR") object GENERATED_ASSERTION_ENABLED_FIELD : IrDeclarationOriginImpl("GENERATED_ASSERTION_ENABLED_FIELD", isSynthetic = true) + object GENERATED_MULTI_FIELD_VALUE_CLASS_PARAMETER : IrDeclarationOriginImpl("GENERATED_MULTI_FIELD_VALUE_CLASS_PARAMETER") + object TEMPORARY_MULTI_FIELD_VALUE_CLASS_PARAMETER : IrDeclarationOriginImpl("TEMPORARY_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 GENERATED_EXTENDED_MAIN : IrDeclarationOriginImpl("GENERATED_EXTENDED_MAIN", isSynthetic = true) object SUSPEND_IMPL_STATIC_FUNCTION : IrDeclarationOriginImpl("SUSPEND_IMPL_STATIC_FUNCTION", isSynthetic = true) object INTERFACE_COMPANION_PRIVATE_INSTANCE : IrDeclarationOriginImpl("INTERFACE_COMPANION_PRIVATE_INSTANCE", isSynthetic = true) 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 148eb6106ff..b1e124d9845 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 @@ -142,7 +142,7 @@ class MemoizedMultiFieldValueClassReplacements( newFlattenedParameters.add(newParameters) } newFlattenedParameters += sourceFunction.valueParameters.drop(sourceFunction.contextReceiverParametersCount) - .grouped(name = null, substitutionMap, targetFunction, IrDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_PARAMETER) + .grouped(name = null, substitutionMap, targetFunction, JvmLoweredDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_PARAMETER) return newFlattenedParameters } 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 index 547c9aa282d..cd78392bcc6 100644 --- 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 @@ -58,7 +58,7 @@ fun MfvcNode.createInstanceFromValueDeclarations( scope.savableStandaloneVariable( type = it.type, name = listOf(name, it.fullFieldName).joinToString("-"), - origin = IrDeclarationOrigin.MULTI_FIELD_VALUE_CLASS_REPRESENTATION_VARIABLE, + origin = JvmLoweredDeclarationOrigin.MULTI_FIELD_VALUE_CLASS_REPRESENTATION_VARIABLE, saveVariable = saveVariable ) } 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 index 74ab005ba52..ece7f922229 100644 --- 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 @@ -103,7 +103,7 @@ internal class ExpressionCopierImpl( } else SavedToVariable( scope.savableStandaloneVariableWithSetter( this@orSavedToVariable, - origin = IrDeclarationOrigin.TEMPORARY_MULTI_FIELD_VALUE_CLASS_VARIABLE, + origin = JvmLoweredDeclarationOrigin.TEMPORARY_MULTI_FIELD_VALUE_CLASS_VARIABLE, saveVariable = saveVariable, isTemporary = true, ) @@ -178,7 +178,7 @@ class ReceiverBasedMfvcNodeInstance( val value = makeGetterExpression(scope, registerPossibleExtraBoxCreation = { /* The box is definitely useful */ }) val asVariable = scope.savableStandaloneVariableWithSetter( value, - origin = IrDeclarationOrigin.GENERATED_MULTI_FIELD_VALUE_CLASS_PARAMETER, + origin = JvmLoweredDeclarationOrigin.TEMPORARY_MULTI_FIELD_VALUE_CLASS_VARIABLE, saveVariable = saveVariable, isTemporary = true, ) @@ -243,7 +243,9 @@ fun IrBuilderWithScope.savableStandaloneVariable( name: String? = null, isMutable: Boolean = false, origin: IrDeclarationOrigin, - isTemporary: Boolean = origin == IrDeclarationOrigin.IR_TEMPORARY_VARIABLE, + isTemporary: Boolean = origin == IrDeclarationOrigin.IR_TEMPORARY_VARIABLE + || origin == JvmLoweredDeclarationOrigin.TEMPORARY_MULTI_FIELD_VALUE_CLASS_VARIABLE + || origin == JvmLoweredDeclarationOrigin.TEMPORARY_MULTI_FIELD_VALUE_CLASS_PARAMETER, saveVariable: (IrVariable) -> Unit, ): IrVariable { val variable = if (isTemporary || name == null) scope.createTemporaryVariableDeclaration( diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt index 91d5b647d0c..cd00046c221 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt @@ -43,9 +43,6 @@ interface IrDeclarationOrigin { object GENERATED_DATA_CLASS_MEMBER : IrDeclarationOriginImpl("GENERATED_DATA_CLASS_MEMBER") object GENERATED_SINGLE_FIELD_VALUE_CLASS_MEMBER : IrDeclarationOriginImpl("GENERATED_SINGLE_FIELD_VALUE_CLASS_MEMBER") object GENERATED_MULTI_FIELD_VALUE_CLASS_MEMBER : IrDeclarationOriginImpl("GENERATED_MULTI_FIELD_VALUE_CLASS_MEMBER") - object GENERATED_MULTI_FIELD_VALUE_CLASS_PARAMETER : IrDeclarationOriginImpl("GENERATED_MULTI_FIELD_VALUE_CLASS_PARAMETER") - object TEMPORARY_MULTI_FIELD_VALUE_CLASS_VARIABLE : IrDeclarationOriginImpl("TEMPORARY_MULTI_FIELD_VALUE_CLASS_VARIABLE") - object MULTI_FIELD_VALUE_CLASS_REPRESENTATION_VARIABLE : IrDeclarationOriginImpl("MULTI_FIELD_VALUE_CLASS_REPRESENTATION_VARIABLE") object LOCAL_FUNCTION : IrDeclarationOriginImpl("LOCAL_FUNCTION") object LOCAL_FUNCTION_FOR_LAMBDA : IrDeclarationOriginImpl("LOCAL_FUNCTION_FOR_LAMBDA") object CATCH_PARAMETER : IrDeclarationOriginImpl("CATCH_PARAMETER") diff --git a/compiler/testData/codegen/box/valueClasses/classFlattening.txt b/compiler/testData/codegen/box/valueClasses/classFlattening.txt index 51dfa6d08b5..58d90848496 100644 --- a/compiler/testData/codegen/box/valueClasses/classFlattening.txt +++ b/compiler/testData/codegen/box/valueClasses/classFlattening.txt @@ -1,7 +1,6 @@ @kotlin.Metadata public final class ClassFlatteningKt { // source: 'classFlattening.kt' - private final static method box$lambda$3$lambda$2(p0: int, p1: int, p2: java.lang.String, p3: int, p4: int, p5: java.lang.String, p6: int, p7: int, p8: java.lang.String): void 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 diff --git a/compiler/testData/codegen/box/valueClasses/defaultParameters.txt b/compiler/testData/codegen/box/valueClasses/defaultParameters.txt index 58bbe083dcb..b818a8c91df 100644 --- a/compiler/testData/codegen/box/valueClasses/defaultParameters.txt +++ b/compiler/testData/codegen/box/valueClasses/defaultParameters.txt @@ -63,7 +63,6 @@ public final class DefaultParametersKt { public final static @org.jetbrains.annotations.NotNull method complexFun-552ch2I(p0: double, p1: double, p2: double, p3: double, p4: double, p5: double): java.lang.String public synthetic static method complexInlineFun-552ch2I$default(p0: double, p1: double, p2: double, p3: double, p4: double, p5: double, p6: int, p7: java.lang.Object): java.lang.String public final static @org.jetbrains.annotations.NotNull method complexInlineFun-552ch2I(p0: double, p1: double, p2: double, p3: double, p4: double, p5: double): java.lang.String - public final inner class kotlin/jvm/internal/Ref$DoubleRef } @kotlin.Metadata diff --git a/compiler/testData/codegen/box/valueClasses/functionReferences.fir.txt b/compiler/testData/codegen/box/valueClasses/functionReferences.fir.txt deleted file mode 100644 index 4204919b5cf..00000000000 --- a/compiler/testData/codegen/box/valueClasses/functionReferences.fir.txt +++ /dev/null @@ -1,2066 +0,0 @@ -@kotlin.Metadata -public final class A { - // source: 'test.kt' - private final field point-x: double - private final field point-y: double - public method (p0: double, p1: double): void - public final method f-GPBa7dw(p0: double, p1: double, p2: double): double - public final @org.jetbrains.annotations.NotNull method getPoint(): DPoint - public synthetic final method getPoint-x(): double - public synthetic final method getPoint-y(): double -} - -@kotlin.Metadata -synthetic final class AnotherKt$any1$1 { - // source: 'another.kt' - enclosing method AnotherKt.any1()Ljava/lang/Object; - public final static field INSTANCE: AnotherKt$any1$1 - inner (anonymous) class AnotherKt$any1$1 - static method (): void - method (): void - private final static method _init_$lambda$0(p0: double, p1: double): DPoint - public final @org.jetbrains.annotations.NotNull method invoke(p0: double, p1: double): DPoint - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class AnotherKt$any2$1 { - // source: 'another.kt' - enclosing method AnotherKt.any2-sUp7gFk(DD)Ljava/lang/Object; - inner (anonymous) class AnotherKt$any2$1 - method (p0: java.lang.Object): void - private final static method _init_$f(p0: DPoint, p1: double): double - public final @org.jetbrains.annotations.NotNull method invoke(p0: double): java.lang.Double - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class AnotherKt$any2$2 { - // source: 'another.kt' - enclosing method AnotherKt.any2()Ljava/lang/Object; - public final static field INSTANCE: AnotherKt$any2$2 - inner (anonymous) class AnotherKt$any2$2 - static method (): void - method (): void - private final static method _init_$f(p0: DPoint, p1: double): double - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double -} - -@kotlin.Metadata -synthetic final class AnotherKt$any3$1 { - // source: 'another.kt' - enclosing method AnotherKt.any3-sUp7gFk(DD)Ljava/lang/Object; - inner (anonymous) class AnotherKt$any3$1 - method (p0: java.lang.Object): void - private final static method _init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class AnotherKt$any3$2 { - // source: 'another.kt' - enclosing method AnotherKt.any3()Ljava/lang/Object; - public final static field INSTANCE: AnotherKt$any3$2 - inner (anonymous) class AnotherKt$any3$2 - static method (): void - method (): void - private final static method _init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class AnotherKt$any4$1 { - // source: 'another.kt' - enclosing method AnotherKt.any4-sUp7gFk(DD)Ljava/lang/Object; - inner (anonymous) class AnotherKt$any4$1 - method (p0: java.lang.Object): void - private final static method _init_$suspendedInline(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class AnotherKt$any4$2 { - // source: 'another.kt' - enclosing method AnotherKt.any4()Ljava/lang/Object; - public final static field INSTANCE: AnotherKt$any4$2 - inner (anonymous) class AnotherKt$any4$2 - static method (): void - method (): void - private final static method _init_$suspendedInline(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class AnotherKt$any5$1 { - // source: 'another.kt' - enclosing method AnotherKt.any5-sUp7gFk(DD)Ljava/lang/Object; - inner (anonymous) class AnotherKt$any5$1 - method (p0: java.lang.Object): void - private final static method _init_$functionWithInlineClass(p0: DPoint, p1: DPoint, p2: int): int - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final method invoke-Qn1smSk(p0: double, p1: double, p2: int): int -} - -@kotlin.Metadata -synthetic final class AnotherKt$any5$2 { - // source: 'another.kt' - enclosing method AnotherKt.any5()Ljava/lang/Object; - public final static field INSTANCE: AnotherKt$any5$2 - inner (anonymous) class AnotherKt$any5$2 - static method (): void - method (): void - private final static method _init_$functionWithInlineClass(p0: DPoint, p1: DPoint, p2: int): int - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object - public final method invoke-jXDDuk8(p0: double, p1: double, p2: double, p3: double, p4: int): int -} - -@kotlin.Metadata -synthetic final class AnotherKt$any6$1 { - // source: 'another.kt' - enclosing method AnotherKt.any6-sUp7gFk(DD)Ljava/lang/Object; - inner (anonymous) class AnotherKt$any6$1 - method (p0: java.lang.Object): void - private final static method _init_$extensionFunction(p0: DPoint, p1: double): double - public final @org.jetbrains.annotations.NotNull method invoke(p0: double): java.lang.Double - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class AnotherKt$any6$2 { - // source: 'another.kt' - enclosing method AnotherKt.any6()Ljava/lang/Object; - public final static field INSTANCE: AnotherKt$any6$2 - inner (anonymous) class AnotherKt$any6$2 - static method (): void - method (): void - private final static method _init_$extensionFunction(p0: DPoint, p1: double): double - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double -} - -@kotlin.Metadata -synthetic final class AnotherKt$any7$1 { - // source: 'another.kt' - enclosing method AnotherKt.any7-sUp7gFk(DD)Ljava/lang/Object; - inner (anonymous) class AnotherKt$any7$1 - method (p0: java.lang.Object): void - private final static method _init_$suspendFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspendFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-lIoT8es(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class AnotherKt$any7$2 { - // source: 'another.kt' - enclosing method AnotherKt.any7()Ljava/lang/Object; - public final static field INSTANCE: AnotherKt$any7$2 - inner (anonymous) class AnotherKt$any7$2 - static method (): void - method (): void - private final static method _init_$suspendFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspendFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-552ch2I(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class AnotherKt$any8$1 { - // source: 'another.kt' - enclosing method AnotherKt.any8-sUp7gFk(DD)Ljava/lang/Object; - inner (anonymous) class AnotherKt$any8$1 - method (p0: java.lang.Object): void - private final static method _init_$suspendInlineFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspendInlineFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-lIoT8es(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class AnotherKt$any8$2 { - // source: 'another.kt' - enclosing method AnotherKt.any8()Ljava/lang/Object; - public final static field INSTANCE: AnotherKt$any8$2 - inner (anonymous) class AnotherKt$any8$2 - static method (): void - method (): void - private final static method _init_$suspendInlineFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspendInlineFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-552ch2I(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -public final class AnotherKt { - // source: 'another.kt' - inner (anonymous) class AnotherKt$any1$1 - inner (anonymous) class AnotherKt$any2$1 - inner (anonymous) class AnotherKt$any2$2 - inner (anonymous) class AnotherKt$any3$1 - inner (anonymous) class AnotherKt$any3$2 - inner (anonymous) class AnotherKt$any4$1 - inner (anonymous) class AnotherKt$any4$2 - inner (anonymous) class AnotherKt$any5$1 - inner (anonymous) class AnotherKt$any5$2 - inner (anonymous) class AnotherKt$any6$1 - inner (anonymous) class AnotherKt$any6$2 - inner (anonymous) class AnotherKt$any7$1 - inner (anonymous) class AnotherKt$any7$2 - inner (anonymous) class AnotherKt$any8$1 - inner (anonymous) class AnotherKt$any8$2 - public final static @org.jetbrains.annotations.NotNull method any1(): java.lang.Object - public final static @org.jetbrains.annotations.NotNull method any2(): java.lang.Object - public final static @org.jetbrains.annotations.NotNull method any2-sUp7gFk(p0: double, p1: double): java.lang.Object - public final static @org.jetbrains.annotations.NotNull method any3(): java.lang.Object - public final static @org.jetbrains.annotations.NotNull method any3-sUp7gFk(p0: double, p1: double): java.lang.Object - public final static @org.jetbrains.annotations.NotNull method any4(): java.lang.Object - public final static @org.jetbrains.annotations.NotNull method any4-sUp7gFk(p0: double, p1: double): java.lang.Object - public final static @org.jetbrains.annotations.NotNull method any5(): java.lang.Object - public final static @org.jetbrains.annotations.NotNull method any5-sUp7gFk(p0: double, p1: double): java.lang.Object - public final static @org.jetbrains.annotations.NotNull method any6(): java.lang.Object - public final static @org.jetbrains.annotations.NotNull method any6-sUp7gFk(p0: double, p1: double): java.lang.Object - public final static @org.jetbrains.annotations.NotNull method any7(): java.lang.Object - public final static @org.jetbrains.annotations.NotNull method any7-sUp7gFk(p0: double, p1: double): java.lang.Object - public final static @org.jetbrains.annotations.NotNull method any8(): java.lang.Object - public final static @org.jetbrains.annotations.NotNull method any8-sUp7gFk(p0: double, p1: double): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method requiresF-lIoT8es(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: F, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -public final class CallerKt { - // source: 'caller.kt' - public final static method runSuspend(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class DPoint$suspendFunctionWithLambda$1 { - // source: 'test.kt' - enclosing method DPoint.suspendFunctionWithLambda-lIoT8es(DDDDLkotlin/jvm/functions/Function2;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; - field D$0: double - field D$1: double - field L$0: java.lang.Object - field label: int - synthetic field result: java.lang.Object - inner (anonymous) class DPoint$suspendFunctionWithLambda$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class DPoint$suspendInlineFunctionWithLambda$1 { - // source: 'test.kt' - enclosing method DPoint.suspendInlineFunctionWithLambda-lIoT8es(DDDDLkotlin/jvm/functions/Function2;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; - field D$0: double - field D$1: double - field L$0: java.lang.Object - field label: int - synthetic field result: java.lang.Object - inner (anonymous) class DPoint$suspendInlineFunctionWithLambda$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.jvm.JvmInline -@kotlin.Metadata -public final class DPoint { - // source: 'test.kt' - private final field x: double - private final field y: double - inner (anonymous) class DPoint$suspendFunctionWithLambda$1 - inner (anonymous) class DPoint$suspendInlineFunctionWithLambda$1 - 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 static method f-impl(p0: double, p1: double, p2: double): double - public final static method functionWithInlineClass-Qn1smSk(p0: double, p1: double, p2: double, p3: double, p4: int): int - public final method getX(): double - public final method getY(): double - public method hashCode(): int - public static method hashCode-impl(p0: double, p1: double): int - public final static @org.jetbrains.annotations.Nullable method suspendFunctionWithLambda-lIoT8es(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method suspendInlineFunctionWithLambda-lIoT8es(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method suspended-impl(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object - private final static method suspendedInline-impl$$forInline(p0: double, p1: double, p2: kotlin.coroutines.Continuation): java.lang.Object - public final static @org.jetbrains.annotations.Nullable method suspendedInline-impl(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object - public @org.jetbrains.annotations.NotNull method toString(): java.lang.String - public static method toString-impl(p0: double, p1: double): java.lang.String - public synthetic final method unbox-impl-x(): double - public synthetic final method unbox-impl-y(): double -} - -@kotlin.Metadata -public interface F { - // source: 'another.kt' - public abstract @org.jetbrains.annotations.Nullable method run-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -final class RunSuspend { - // source: 'caller.kt' - private @org.jetbrains.annotations.Nullable field result: kotlin.Result - public method (): void - public final method await(): void - public final @org.jetbrains.annotations.NotNull method getContext(): kotlin.coroutines.CoroutineContext - public final @org.jetbrains.annotations.Nullable method getResult-xLWZpok(): kotlin.Result - public final method resumeWith(@org.jetbrains.annotations.NotNull p0: java.lang.Object): void - public final method setResult(@org.jetbrains.annotations.Nullable p0: kotlin.Result): void -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$10 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$10 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$100 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$100 - inner (anonymous) class TestKt$box$100 - static method (): void - method (): void - private final static method _init_$g(p0: DPoint, p1: double): double - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double -} - -@kotlin.Metadata -synthetic final class TestKt$box$101 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$101 - inner (anonymous) class TestKt$box$101 - static method (): void - method (): void - private final static method _init_$g(p0: DPoint, p1: double): double - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double -} - -@kotlin.Metadata -synthetic final class TestKt$box$102 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$102 - method (p0: java.lang.Object): void - private final static method _init_$f(p0: A, p1: DPoint, p2: double): double - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double -} - -@kotlin.Metadata -synthetic final class TestKt$box$103 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$103 - method (p0: java.lang.Object): void - private final static method _init_$f(p0: A, p1: DPoint, p2: double): double - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double -} - -@kotlin.Metadata -synthetic final class TestKt$box$104 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$104 - inner (anonymous) class TestKt$box$104 - static method (): void - method (): void - private final static method _init_$f(p0: A, p1: DPoint, p2: double): double - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.NotNull method invoke-lIoT8es(@org.jetbrains.annotations.NotNull p0: A, p1: double, p2: double, p3: double): java.lang.Double -} - -@kotlin.Metadata -synthetic final class TestKt$box$105 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$105 - inner (anonymous) class TestKt$box$105 - static method (): void - method (): void - private final static method _init_$f(p0: A, p1: DPoint, p2: double): double - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.NotNull method invoke-lIoT8es(@org.jetbrains.annotations.NotNull p0: A, p1: double, p2: double, p3: double): java.lang.Double -} - -@kotlin.Metadata -synthetic final class TestKt$box$106 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$106 - inner (anonymous) class TestKt$box$106 - static method (): void - method (): void - private final static method _init_$plus(p0: DPoint, p1: DPoint): DPoint - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double, p3: double): DPoint -} - -@kotlin.Metadata -synthetic final class TestKt$box$107 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$107 - inner (anonymous) class TestKt$box$107 - static method (): void - method (): void - private final static method _init_$plus(p0: DPoint, p1: DPoint): DPoint - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double, p3: double): DPoint -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$11 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$11 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -final class TestKt$box$110$1 { - // source: 'test.kt' - enclosing method TestKt$box$110.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - public final static field INSTANCE: TestKt$box$110$1 - inner (anonymous) class TestKt$box$110 - inner (anonymous) class TestKt$box$110$1 - static method (): void - method (): void - public final @org.jetbrains.annotations.Nullable method run-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$110 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$110 - inner (anonymous) class TestKt$box$110$1 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -final class TestKt$box$111$1 { - // source: 'test.kt' - enclosing method TestKt$box$111.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - public final static field INSTANCE: TestKt$box$111$1 - inner (anonymous) class TestKt$box$111 - inner (anonymous) class TestKt$box$111$1 - static method (): void - method (): void - public final @org.jetbrains.annotations.Nullable method run-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$111 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$111 - inner (anonymous) class TestKt$box$111$1 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$12$1 { - // source: 'test.kt' - enclosing method TestKt$box$12.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - public final static field INSTANCE: TestKt$box$12$1 - inner (anonymous) class TestKt$box$12 - inner (anonymous) class TestKt$box$12$1 - static method (): void - method (): void - private final static method _init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$12 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$12 - inner (anonymous) class TestKt$box$12$1 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$13$2 { - // source: 'test.kt' - enclosing method TestKt$box$13.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - public final static field INSTANCE: TestKt$box$13$2 - inner (anonymous) class TestKt$box$13 - inner (anonymous) class TestKt$box$13$2 - static method (): void - method (): void - private final static method _init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$13 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$13 - inner (anonymous) class TestKt$box$13$2 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$14$2 { - // source: 'test.kt' - enclosing method TestKt$box$14.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - public final static field INSTANCE: TestKt$box$14$2 - inner (anonymous) class TestKt$box$14 - inner (anonymous) class TestKt$box$14$2 - static method (): void - method (): void - private final static method _init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$14 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$14 - inner (anonymous) class TestKt$box$14$2 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$15$1 { - // source: 'test.kt' - enclosing method TestKt$box$15.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - public final static field INSTANCE: TestKt$box$15$1 - inner (anonymous) class TestKt$box$15 - inner (anonymous) class TestKt$box$15$1 - static method (): void - method (): void - private final static method _init_$suspendedInline(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$15 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$15 - inner (anonymous) class TestKt$box$15$1 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$16$2 { - // source: 'test.kt' - enclosing method TestKt$box$16.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - public final static field INSTANCE: TestKt$box$16$2 - inner (anonymous) class TestKt$box$16 - inner (anonymous) class TestKt$box$16$2 - static method (): void - method (): void - private final static method _init_$suspendedInline(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$16 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$16 - inner (anonymous) class TestKt$box$16$2 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$17$2 { - // source: 'test.kt' - enclosing method TestKt$box$17.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - public final static field INSTANCE: TestKt$box$17$2 - inner (anonymous) class TestKt$box$17 - inner (anonymous) class TestKt$box$17$2 - static method (): void - method (): void - private final static method _init_$suspendedInline(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$17 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$17 - inner (anonymous) class TestKt$box$17$2 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$18$1 { - // source: 'test.kt' - enclosing method TestKt$box$18.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - synthetic field L$0: java.lang.Object - field label: int - inner (anonymous) class TestKt$box$18 - inner (anonymous) class TestKt$box$18$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$18 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$18 - inner (anonymous) class TestKt$box$18$1 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$19$2 { - // source: 'test.kt' - enclosing method TestKt$box$19.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - synthetic field L$0: java.lang.Object - field label: int - inner (anonymous) class TestKt$box$19 - inner (anonymous) class TestKt$box$19$2 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$19 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$19 - inner (anonymous) class TestKt$box$19$2 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$20$2 { - // source: 'test.kt' - enclosing method TestKt$box$20.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - synthetic field L$0: java.lang.Object - field label: int - inner (anonymous) class TestKt$box$20 - inner (anonymous) class TestKt$box$20$2 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$20 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$20 - inner (anonymous) class TestKt$box$20$2 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$21$1 { - // source: 'test.kt' - enclosing method TestKt$box$21.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - synthetic field L$0: java.lang.Object - field label: int - inner (anonymous) class TestKt$box$21 - inner (anonymous) class TestKt$box$21$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$21 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$21 - inner (anonymous) class TestKt$box$21$1 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$22$2 { - // source: 'test.kt' - enclosing method TestKt$box$22.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - synthetic field L$0: java.lang.Object - field label: int - inner (anonymous) class TestKt$box$22 - inner (anonymous) class TestKt$box$22$2 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$22 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$22 - inner (anonymous) class TestKt$box$22$2 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$23$2 { - // source: 'test.kt' - enclosing method TestKt$box$23.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - synthetic field L$0: java.lang.Object - field label: int - inner (anonymous) class TestKt$box$23 - inner (anonymous) class TestKt$box$23$2 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$23 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$23 - inner (anonymous) class TestKt$box$23$2 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$24$1 { - // source: 'test.kt' - enclosing method TestKt$box$24.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - public final static field INSTANCE: TestKt$box$24$1 - inner (anonymous) class TestKt$box$24 - inner (anonymous) class TestKt$box$24$1 - static method (): void - method (): void - private final static method _init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$24 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$24 - inner (anonymous) class TestKt$box$24$1 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$25$2 { - // source: 'test.kt' - enclosing method TestKt$box$25.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - public final static field INSTANCE: TestKt$box$25$2 - inner (anonymous) class TestKt$box$25 - inner (anonymous) class TestKt$box$25$2 - static method (): void - method (): void - private final static method _init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$25 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$25 - inner (anonymous) class TestKt$box$25$2 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$26$2 { - // source: 'test.kt' - enclosing method TestKt$box$26.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - public final static field INSTANCE: TestKt$box$26$2 - inner (anonymous) class TestKt$box$26 - inner (anonymous) class TestKt$box$26$2 - static method (): void - method (): void - private final static method _init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$26 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$26 - inner (anonymous) class TestKt$box$26$2 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$27$1 { - // source: 'test.kt' - enclosing method TestKt$box$27.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - public final static field INSTANCE: TestKt$box$27$1 - inner (anonymous) class TestKt$box$27 - inner (anonymous) class TestKt$box$27$1 - static method (): void - method (): void - private final static method _init_$suspendedInline(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$27 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$27 - inner (anonymous) class TestKt$box$27$1 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$28$2 { - // source: 'test.kt' - enclosing method TestKt$box$28.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - public final static field INSTANCE: TestKt$box$28$2 - inner (anonymous) class TestKt$box$28 - inner (anonymous) class TestKt$box$28$2 - static method (): void - method (): void - private final static method _init_$suspendedInline(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$28 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$28 - inner (anonymous) class TestKt$box$28$2 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$29$2 { - // source: 'test.kt' - enclosing method TestKt$box$29.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - public final static field INSTANCE: TestKt$box$29$2 - inner (anonymous) class TestKt$box$29 - inner (anonymous) class TestKt$box$29$2 - static method (): void - method (): void - private final static method _init_$suspendedInline(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$29 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$29 - inner (anonymous) class TestKt$box$29$2 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$30$1 { - // source: 'test.kt' - enclosing method TestKt$box$30.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - synthetic field L$0: java.lang.Object - field label: int - inner (anonymous) class TestKt$box$30 - inner (anonymous) class TestKt$box$30$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$30 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$30 - inner (anonymous) class TestKt$box$30$1 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$31$2 { - // source: 'test.kt' - enclosing method TestKt$box$31.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - synthetic field L$0: java.lang.Object - field label: int - inner (anonymous) class TestKt$box$31 - inner (anonymous) class TestKt$box$31$2 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$31 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$31 - inner (anonymous) class TestKt$box$31$2 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$32$2 { - // source: 'test.kt' - enclosing method TestKt$box$32.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - synthetic field L$0: java.lang.Object - field label: int - inner (anonymous) class TestKt$box$32 - inner (anonymous) class TestKt$box$32$2 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$32 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$32 - inner (anonymous) class TestKt$box$32$2 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$33$1 { - // source: 'test.kt' - enclosing method TestKt$box$33.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - synthetic field L$0: java.lang.Object - field label: int - inner (anonymous) class TestKt$box$33 - inner (anonymous) class TestKt$box$33$1 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$33 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$33 - inner (anonymous) class TestKt$box$33$1 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$34$2 { - // source: 'test.kt' - enclosing method TestKt$box$34.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - synthetic field L$0: java.lang.Object - field label: int - inner (anonymous) class TestKt$box$34 - inner (anonymous) class TestKt$box$34$2 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$34 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$34 - inner (anonymous) class TestKt$box$34$2 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$35$2 { - // source: 'test.kt' - enclosing method TestKt$box$35.invokeSuspend(Ljava/lang/Object;)Ljava/lang/Object; - synthetic field L$0: java.lang.Object - field label: int - inner (anonymous) class TestKt$box$35 - inner (anonymous) class TestKt$box$35$2 - method (p0: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.Nullable p0: java.lang.Object, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.Nullable p2: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$35 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$35 - inner (anonymous) class TestKt$box$35$2 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$47 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$47 - inner (anonymous) class TestKt$box$47 - static method (): void - method (): void - private final static method _init_$plus(p0: DPoint, p1: DPoint): DPoint - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double, p3: double): DPoint -} - -@kotlin.Metadata -final class TestKt$box$48 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$48 - inner (anonymous) class TestKt$box$48 - static method (): void - method (): void - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double, p3: double): DPoint -} - -@kotlin.Metadata -final class TestKt$box$51 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$51 - inner (anonymous) class TestKt$box$51 - static method (): void - method (): void - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double, p3: double): DPoint -} - -@kotlin.Metadata -synthetic final class TestKt$box$53 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$53 - inner (anonymous) class TestKt$box$53 - static method (): void - method (): void - private final static method _init_$lambda$0(p0: double, p1: double): DPoint - public final @org.jetbrains.annotations.NotNull method invoke(p0: double, p1: double): DPoint - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$55 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$55 - inner (anonymous) class TestKt$box$55 - static method (): void - method (): void - private final static method _init_$lambda$0(p0: double, p1: double): DPoint - public final @org.jetbrains.annotations.NotNull method invoke(p0: double, p1: double): DPoint - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$56 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$56 - inner (anonymous) class TestKt$box$56 - static method (): void - method (): void - private final static method _init_$lambda$0(p0: double, p1: double): DPoint - public final @org.jetbrains.annotations.NotNull method invoke(p0: double, p1: double): DPoint - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$57 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$57 - inner (anonymous) class TestKt$box$57 - static method (): void - method (): void - private final static method _init_$lambda$0(p0: double, p1: double): DPoint - public final @org.jetbrains.annotations.NotNull method invoke(p0: double, p1: double): DPoint - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$58 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$58 - method (p0: java.lang.Object): void - private final static method _init_$f(p0: DPoint, p1: double): double - public final @org.jetbrains.annotations.NotNull method invoke(p0: double): java.lang.Double - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$59 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$59 - method (p0: java.lang.Object): void - private final static method _init_$f(p0: DPoint, p1: double): double - public final @org.jetbrains.annotations.NotNull method invoke(p0: double): java.lang.Double - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$6 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$6 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$60 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$60 - inner (anonymous) class TestKt$box$60 - static method (): void - method (): void - private final static method _init_$f(p0: DPoint, p1: double): double - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double -} - -@kotlin.Metadata -synthetic final class TestKt$box$61 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$61 - inner (anonymous) class TestKt$box$61 - static method (): void - method (): void - private final static method _init_$f(p0: DPoint, p1: double): double - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double -} - -@kotlin.Metadata -synthetic final class TestKt$box$62 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$62 - method (p0: java.lang.Object): void - private final static method _init_$f(p0: DPoint, p1: double): double - public final @org.jetbrains.annotations.NotNull method invoke(p0: double): java.lang.Double - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$63 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$63 - inner (anonymous) class TestKt$box$63 - static method (): void - method (): void - private final static method _init_$f(p0: DPoint, p1: double): double - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double -} - -@kotlin.Metadata -synthetic final class TestKt$box$64 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$64 - method (p0: java.lang.Object): void - private final static method _init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$65 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$65 - method (p0: java.lang.Object): void - private final static method _init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$66 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$66 - inner (anonymous) class TestKt$box$66 - static method (): void - method (): void - private final static method _init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$67 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$67 - inner (anonymous) class TestKt$box$67 - static method (): void - method (): void - private final static method _init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$68 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$68 - method (p0: java.lang.Object): void - private final static method _init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$69 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$69 - inner (anonymous) class TestKt$box$69 - static method (): void - method (): void - private final static method _init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspended(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$7 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$7 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$70 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$70 - method (p0: java.lang.Object): void - private final static method _init_$suspendedInline(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$71 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$71 - method (p0: java.lang.Object): void - private final static method _init_$suspendedInline(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$72 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$72 - inner (anonymous) class TestKt$box$72 - static method (): void - method (): void - private final static method _init_$suspendedInline(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$73 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$73 - inner (anonymous) class TestKt$box$73 - static method (): void - method (): void - private final static method _init_$suspendedInline(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$74 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$74 - method (p0: java.lang.Object): void - private final static method _init_$suspendedInline(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$75 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$75 - inner (anonymous) class TestKt$box$75 - static method (): void - method (): void - private final static method _init_$suspendedInline(p0: DPoint, p1: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$76 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$76 - method (p0: java.lang.Object): void - private final static method _init_$functionWithInlineClass(p0: DPoint, p1: DPoint, p2: int): int - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final method invoke-Qn1smSk(p0: double, p1: double, p2: int): int -} - -@kotlin.Metadata -synthetic final class TestKt$box$77 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$77 - method (p0: java.lang.Object): void - private final static method _init_$functionWithInlineClass(p0: DPoint, p1: DPoint, p2: int): int - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final method invoke-Qn1smSk(p0: double, p1: double, p2: int): int -} - -@kotlin.Metadata -synthetic final class TestKt$box$78 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$78 - inner (anonymous) class TestKt$box$78 - static method (): void - method (): void - private final static method _init_$functionWithInlineClass(p0: DPoint, p1: DPoint, p2: int): int - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object - public final method invoke-jXDDuk8(p0: double, p1: double, p2: double, p3: double, p4: int): int -} - -@kotlin.Metadata -synthetic final class TestKt$box$79 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$79 - inner (anonymous) class TestKt$box$79 - static method (): void - method (): void - private final static method _init_$functionWithInlineClass(p0: DPoint, p1: DPoint, p2: int): int - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object - public final method invoke-jXDDuk8(p0: double, p1: double, p2: double, p3: double, p4: int): int -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$8 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$8 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$80 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$80 - method (p0: java.lang.Object): void - private final static method _init_$functionWithInlineClass(p0: DPoint, p1: DPoint, p2: int): int - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final method invoke-Qn1smSk(p0: double, p1: double, p2: int): int -} - -@kotlin.Metadata -synthetic final class TestKt$box$81 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$81 - inner (anonymous) class TestKt$box$81 - static method (): void - method (): void - private final static method _init_$functionWithInlineClass(p0: DPoint, p1: DPoint, p2: int): int - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object - public final method invoke-jXDDuk8(p0: double, p1: double, p2: double, p3: double, p4: int): int -} - -@kotlin.Metadata -synthetic final class TestKt$box$82 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$82 - method (p0: java.lang.Object): void - private final static method _init_$extensionFunction(p0: DPoint, p1: double): double - public final @org.jetbrains.annotations.NotNull method invoke(p0: double): java.lang.Double - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$83 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$83 - method (p0: java.lang.Object): void - private final static method _init_$extensionFunction(p0: DPoint, p1: double): double - public final @org.jetbrains.annotations.NotNull method invoke(p0: double): java.lang.Double - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$84 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$84 - inner (anonymous) class TestKt$box$84 - static method (): void - method (): void - private final static method _init_$extensionFunction(p0: DPoint, p1: double): double - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double -} - -@kotlin.Metadata -synthetic final class TestKt$box$85 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$85 - inner (anonymous) class TestKt$box$85 - static method (): void - method (): void - private final static method _init_$extensionFunction(p0: DPoint, p1: double): double - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double -} - -@kotlin.Metadata -synthetic final class TestKt$box$86 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$86 - method (p0: java.lang.Object): void - private final static method _init_$extensionFunction(p0: DPoint, p1: double): double - public final @org.jetbrains.annotations.NotNull method invoke(p0: double): java.lang.Double - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$87 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$87 - inner (anonymous) class TestKt$box$87 - static method (): void - method (): void - private final static method _init_$extensionFunction(p0: DPoint, p1: double): double - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.NotNull method invoke-GPBa7dw(p0: double, p1: double, p2: double): java.lang.Double -} - -@kotlin.Metadata -synthetic final class TestKt$box$88 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$88 - method (p0: java.lang.Object): void - private final static method _init_$suspendFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspendFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-lIoT8es(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$89 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$89 - method (p0: java.lang.Object): void - private final static method _init_$suspendFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspendFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-lIoT8es(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.coroutines.jvm.internal.DebugMetadata -@kotlin.Metadata -final class TestKt$box$9 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - synthetic final field $dPoint-x: double - synthetic final field $dPoint-y: double - field label: int - inner (anonymous) class TestKt$box$9 - method (p0: double, p1: double, p2: kotlin.coroutines.Continuation): void - public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation - public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$90 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$90 - inner (anonymous) class TestKt$box$90 - static method (): void - method (): void - private final static method _init_$suspendFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspendFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-552ch2I(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$91 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$91 - inner (anonymous) class TestKt$box$91 - static method (): void - method (): void - private final static method _init_$suspendFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspendFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-552ch2I(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$92 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$92 - method (p0: java.lang.Object): void - private final static method _init_$suspendFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspendFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-lIoT8es(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$93 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$93 - inner (anonymous) class TestKt$box$93 - static method (): void - method (): void - private final static method _init_$suspendFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspendFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-552ch2I(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$94 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$94 - method (p0: java.lang.Object): void - private final static method _init_$suspendInlineFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspendInlineFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-lIoT8es(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$95 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$95 - method (p0: java.lang.Object): void - private final static method _init_$suspendInlineFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspendInlineFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-lIoT8es(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$96 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$96 - inner (anonymous) class TestKt$box$96 - static method (): void - method (): void - private final static method _init_$suspendInlineFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspendInlineFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-552ch2I(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$97 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$97 - inner (anonymous) class TestKt$box$97 - static method (): void - method (): void - private final static method _init_$suspendInlineFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspendInlineFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-552ch2I(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$98 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - inner (anonymous) class TestKt$box$98 - method (p0: java.lang.Object): void - private final static method _init_$suspendInlineFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspendInlineFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-lIoT8es(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -synthetic final class TestKt$box$99 { - // source: 'test.kt' - enclosing method TestKt.box()Ljava/lang/String; - public final static field INSTANCE: TestKt$box$99 - inner (anonymous) class TestKt$box$99 - static method (): void - method (): void - private final static method _init_$suspendInlineFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic final static method access$_init_$suspendInlineFunctionWithLambda(p0: DPoint, p1: DPoint, p2: kotlin.jvm.functions.Function2, p3: kotlin.coroutines.Continuation): java.lang.Object - public synthetic bridge method invoke(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object, p3: java.lang.Object): java.lang.Object - public final @org.jetbrains.annotations.Nullable method invoke-552ch2I(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p5: kotlin.coroutines.Continuation): java.lang.Object -} - -@kotlin.Metadata -public final class TestKt { - // source: 'test.kt' - inner (anonymous) class TestKt$box$10 - inner (anonymous) class TestKt$box$100 - inner (anonymous) class TestKt$box$101 - inner (anonymous) class TestKt$box$102 - inner (anonymous) class TestKt$box$103 - inner (anonymous) class TestKt$box$104 - inner (anonymous) class TestKt$box$105 - inner (anonymous) class TestKt$box$106 - inner (anonymous) class TestKt$box$107 - inner (anonymous) class TestKt$box$11 - inner (anonymous) class TestKt$box$110 - inner (anonymous) class TestKt$box$111 - inner (anonymous) class TestKt$box$12 - inner (anonymous) class TestKt$box$13 - inner (anonymous) class TestKt$box$14 - inner (anonymous) class TestKt$box$15 - inner (anonymous) class TestKt$box$16 - inner (anonymous) class TestKt$box$17 - inner (anonymous) class TestKt$box$18 - inner (anonymous) class TestKt$box$19 - inner (anonymous) class TestKt$box$20 - inner (anonymous) class TestKt$box$21 - inner (anonymous) class TestKt$box$22 - inner (anonymous) class TestKt$box$23 - inner (anonymous) class TestKt$box$24 - inner (anonymous) class TestKt$box$25 - inner (anonymous) class TestKt$box$26 - inner (anonymous) class TestKt$box$27 - inner (anonymous) class TestKt$box$28 - inner (anonymous) class TestKt$box$29 - inner (anonymous) class TestKt$box$30 - inner (anonymous) class TestKt$box$31 - inner (anonymous) class TestKt$box$32 - inner (anonymous) class TestKt$box$33 - inner (anonymous) class TestKt$box$34 - inner (anonymous) class TestKt$box$35 - inner (anonymous) class TestKt$box$47 - inner (anonymous) class TestKt$box$48 - inner (anonymous) class TestKt$box$51 - inner (anonymous) class TestKt$box$53 - inner (anonymous) class TestKt$box$55 - inner (anonymous) class TestKt$box$56 - inner (anonymous) class TestKt$box$57 - inner (anonymous) class TestKt$box$58 - inner (anonymous) class TestKt$box$59 - inner (anonymous) class TestKt$box$6 - inner (anonymous) class TestKt$box$60 - inner (anonymous) class TestKt$box$61 - inner (anonymous) class TestKt$box$62 - inner (anonymous) class TestKt$box$63 - inner (anonymous) class TestKt$box$64 - inner (anonymous) class TestKt$box$65 - inner (anonymous) class TestKt$box$66 - inner (anonymous) class TestKt$box$67 - inner (anonymous) class TestKt$box$68 - inner (anonymous) class TestKt$box$69 - inner (anonymous) class TestKt$box$7 - inner (anonymous) class TestKt$box$70 - inner (anonymous) class TestKt$box$71 - inner (anonymous) class TestKt$box$72 - inner (anonymous) class TestKt$box$73 - inner (anonymous) class TestKt$box$74 - inner (anonymous) class TestKt$box$75 - inner (anonymous) class TestKt$box$76 - inner (anonymous) class TestKt$box$77 - inner (anonymous) class TestKt$box$78 - inner (anonymous) class TestKt$box$79 - inner (anonymous) class TestKt$box$8 - inner (anonymous) class TestKt$box$80 - inner (anonymous) class TestKt$box$81 - inner (anonymous) class TestKt$box$82 - inner (anonymous) class TestKt$box$83 - inner (anonymous) class TestKt$box$84 - inner (anonymous) class TestKt$box$85 - inner (anonymous) class TestKt$box$86 - inner (anonymous) class TestKt$box$87 - inner (anonymous) class TestKt$box$88 - inner (anonymous) class TestKt$box$89 - inner (anonymous) class TestKt$box$9 - inner (anonymous) class TestKt$box$90 - inner (anonymous) class TestKt$box$91 - inner (anonymous) class TestKt$box$92 - inner (anonymous) class TestKt$box$93 - inner (anonymous) class TestKt$box$94 - inner (anonymous) class TestKt$box$95 - inner (anonymous) class TestKt$box$96 - inner (anonymous) class TestKt$box$97 - inner (anonymous) class TestKt$box$98 - inner (anonymous) class TestKt$box$99 - private final static method box$lambda$2$lambda$1(p0: double, p1: double, p2: double, p3: double): DPoint - private final static method box$lambda$4$lambda$3(p0: double, p1: double, p2: double, p3: double): DPoint - private final static method box$lambda$7$lambda$6(p0: double, p1: double): DPoint - private final static method box$stub_for_inlining$0$stub_for_inlining(p0: double, p1: double, p2: double, p3: double): DPoint - private final static method box$stub_for_inlining$9$stub_for_inlining$8(p0: double, p1: double): DPoint - public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String - public final static @org.jetbrains.annotations.NotNull method consume-lIoT8es(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2): DPoint - public final static @org.jetbrains.annotations.NotNull method consumeInline-lIoT8es(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2): DPoint - public final static method extensionFunction-GPBa7dw(p0: double, p1: double, p2: double): double - public final static method g-GPBa7dw(p0: double, p1: double, p2: double): double - public final static method id(p0: java.lang.Object): java.lang.Object - public final static @org.jetbrains.annotations.NotNull method makeDPoint(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2): DPoint - public final static @org.jetbrains.annotations.NotNull method makeDPointInline(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.jvm.functions.Function2): DPoint - public final static @org.jetbrains.annotations.NotNull method plus-GPBa7dw(p0: double, p1: double, p2: double, p3: double): DPoint -} diff --git a/compiler/testData/codegen/box/valueClasses/functionReferences.kt b/compiler/testData/codegen/box/valueClasses/functionReferences.kt index bb2f9ae7959..495d136418b 100644 --- a/compiler/testData/codegen/box/valueClasses/functionReferences.kt +++ b/compiler/testData/codegen/box/valueClasses/functionReferences.kt @@ -3,38 +3,13 @@ // WITH_COROUTINES // TARGET_BACKEND: JVM_IR // LANGUAGE: +ValueClasses +// FIR_IDENTICAL // FILE: caller.kt import kotlin.coroutines.* fun runSuspend(block: suspend () -> Unit) { - val run = RunSuspend() - block.startCoroutine(run) - run.await() -} - -private class RunSuspend : Continuation { - override val context: CoroutineContext - get() = EmptyCoroutineContext - - var result: Result? = null - - override fun resumeWith(result: Result) = synchronized(this) { - this.result = result - @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN") (this as Object).notifyAll() - } - - fun await() = synchronized(this) { - while (true) { - when (val result = this.result) { - null -> @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN") (this as Object).wait() - else -> { - result.getOrThrow() // throw up failure - return - } - } - } - } + block.startCoroutine(Continuation(EmptyCoroutineContext) { it.getOrThrow() }) } // FILE: test.kt diff --git a/compiler/testData/codegen/box/valueClasses/functionReferences.txt b/compiler/testData/codegen/box/valueClasses/functionReferences.txt index 34b417d7e86..f023de46e26 100644 --- a/compiler/testData/codegen/box/valueClasses/functionReferences.txt +++ b/compiler/testData/codegen/box/valueClasses/functionReferences.txt @@ -233,6 +233,17 @@ public final class AnotherKt { public final static @org.jetbrains.annotations.Nullable method requiresF-lIoT8es(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: F, @org.jetbrains.annotations.NotNull p3: kotlin.coroutines.Continuation): java.lang.Object } +@kotlin.Metadata +public final class CallerKt$runSuspend$$inlined$Continuation$1 { + // source: 'Continuation.kt' + enclosing method CallerKt.runSuspend(Lkotlin/jvm/functions/Function1;)V + synthetic final field $context: kotlin.coroutines.CoroutineContext + inner (anonymous) class CallerKt$runSuspend$$inlined$Continuation$1 + public method (p0: kotlin.coroutines.CoroutineContext): void + public @org.jetbrains.annotations.NotNull method getContext(): kotlin.coroutines.CoroutineContext + public method resumeWith(@org.jetbrains.annotations.NotNull p0: java.lang.Object): void +} + @kotlin.Metadata public final class CallerKt { // source: 'caller.kt' @@ -306,18 +317,6 @@ public interface F { public abstract @org.jetbrains.annotations.Nullable method run-GPBa7dw(p0: double, p1: double, @org.jetbrains.annotations.NotNull p2: kotlin.coroutines.Continuation): java.lang.Object } -@kotlin.Metadata -final class RunSuspend { - // source: 'caller.kt' - private @org.jetbrains.annotations.Nullable field result: kotlin.Result - public method (): void - public final method await(): void - public @org.jetbrains.annotations.NotNull method getContext(): kotlin.coroutines.CoroutineContext - public final @org.jetbrains.annotations.Nullable method getResult-xLWZpok(): kotlin.Result - public method resumeWith(@org.jetbrains.annotations.NotNull p0: java.lang.Object): void - public final method setResult(@org.jetbrains.annotations.Nullable p0: kotlin.Result): void -} - @kotlin.coroutines.jvm.internal.DebugMetadata @kotlin.Metadata final class TestKt$box$10 { @@ -2049,11 +2048,6 @@ public final class TestKt { inner (anonymous) class TestKt$box$97 inner (anonymous) class TestKt$box$98 inner (anonymous) class TestKt$box$99 - private final static method box$lambda$2$lambda$1(p0: double, p1: double, p2: double, p3: double): DPoint - private final static method box$lambda$4$lambda$3(p0: double, p1: double, p2: double, p3: double): DPoint - private final static method box$lambda$7$lambda$6(p0: double, p1: double): DPoint - private final static method box$stub_for_inlining$0$stub_for_inlining(p0: double, p1: double, p2: double, p3: double): DPoint - private final static method box$stub_for_inlining$9$stub_for_inlining$8(p0: double, p1: double): DPoint public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String public final static @org.jetbrains.annotations.NotNull method consume-lIoT8es(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2): DPoint public final static @org.jetbrains.annotations.NotNull method consumeInline-lIoT8es(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function2): DPoint diff --git a/compiler/testData/codegen/box/valueClasses/inlineFunctions.kt b/compiler/testData/codegen/box/valueClasses/inlineFunctions.kt new file mode 100644 index 00000000000..3417bb5092b --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/inlineFunctions.kt @@ -0,0 +1,85 @@ +// LANGUAGE: +ValueClasses +// TARGET_BACKEND: JVM_IR +// CHECK_BYTECODE_LISTING +// WITH_STDLIB +// CHECK_BYTECODE_TEXT +// FIR_IDENTICAL + +// FILE: caller.kt +import kotlin.coroutines.* + +fun runSuspend(block: suspend () -> Unit) { + block.startCoroutine(Continuation(EmptyCoroutineContext) { it.getOrThrow() }) +} + +// FILE: dependency.kt + +@JvmInline +value class DPoint(val x: Double, val y: Double) + +@JvmInline +value class DSegment(val p1: DPoint, val p2: DPoint) + + +inline fun DSegment.myLet(f: (DSegment) -> DPoint) = f(this) + +// FILE: test.kt +import kotlin.coroutines.suspendCoroutine +import kotlin.coroutines.resume + +fun supply(x: Any?) = Unit + +fun box(): String { + val point = DPoint(1.0, 2.0) + val pointX2 = DPoint(2.0, 4.0) + val segment = DSegment(point, pointX2) + + supply("a") + point.let { it.x } + supply("b") + point.let { it } + supply("c") + run { DPoint (1.0, 2.0) } + supply("d") + val x = run { DPoint(100.0, 200.0) } + supply("e") + require(x == DPoint(100.0, 200.0)) + supply("f") + point.let { DPoint(2 * it.x, 2 * it.y) } + supply("g") + require(point == point.let { it }) + supply("h") + require(pointX2 == point.let { DPoint(2 * it.x, 2 * it.y) }) + supply("i") + segment.myLet { it.p1 } + supply("j") + segment.myLet { it.p2 } + supply("k") + require(segment.myLet { it.p1 } == point) + supply("l") + require(segment.myLet { it.p2 } == pointX2) + supply("m") + require(segment.let { it.let { it } } == segment) + supply("n") + var a = 1 + segment.let { a++ } + val b = segment.let { ++a } + require(a == 3) + supply("o") + runSuspend { require(suspendFun() == DPoint(1.0, 2.0).toString()) } + supply("p") + + return "OK" +} + +suspend fun f() = suspendCoroutine { it.resume(Unit) } +suspend fun suspendFun(): String { + val x = run { f(); DPoint(1.0, 2.0) } + return x.toString() +} + +// @TestKt.class: +// 0 valueOf +// 0 INVOKE(STATIC|VIRTUAL) (DPoint|DSegment).*\.(un)?box +// 0 INVOKE(STATIC|VIRTUAL) .*(stub_for_inlining|lambda) +// 0 DCONST_0 diff --git a/compiler/testData/codegen/box/valueClasses/inlineFunctions.txt b/compiler/testData/codegen/box/valueClasses/inlineFunctions.txt new file mode 100644 index 00000000000..523f165bb82 --- /dev/null +++ b/compiler/testData/codegen/box/valueClasses/inlineFunctions.txt @@ -0,0 +1,110 @@ +@kotlin.Metadata +public final class CallerKt$runSuspend$$inlined$Continuation$1 { + // source: 'Continuation.kt' + enclosing method CallerKt.runSuspend(Lkotlin/jvm/functions/Function1;)V + synthetic final field $context: kotlin.coroutines.CoroutineContext + inner (anonymous) class CallerKt$runSuspend$$inlined$Continuation$1 + public method (p0: kotlin.coroutines.CoroutineContext): void + public @org.jetbrains.annotations.NotNull method getContext(): kotlin.coroutines.CoroutineContext + public method resumeWith(@org.jetbrains.annotations.NotNull p0: java.lang.Object): void +} + +@kotlin.Metadata +public final class CallerKt { + // source: 'caller.kt' + public final static method runSuspend(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class DPoint { + // source: 'dependency.kt' + private final field x: double + private final field y: 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 method hashCode(): int + public static method hashCode-impl(p0: double, p1: double): int + public @org.jetbrains.annotations.NotNull method toString(): java.lang.String + public static method toString-impl(p0: double, p1: double): java.lang.String + public synthetic final method unbox-impl-x(): double + public synthetic final method unbox-impl-y(): double +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class DSegment { + // source: 'dependency.kt' + private final field p1-x: double + private final field p1-y: double + private final field p2-x: double + private final field p2-y: 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 @org.jetbrains.annotations.NotNull method getP1(): DPoint + public final @org.jetbrains.annotations.NotNull method getP2(): 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-impl-p1(): DPoint + public synthetic final method unbox-impl-p1-x(): double + public synthetic final method unbox-impl-p1-y(): double + public synthetic final method unbox-impl-p2(): DPoint + public synthetic final method unbox-impl-p2-x(): double + public synthetic final method unbox-impl-p2-y(): double +} + +@kotlin.Metadata +public final class DependencyKt { + // source: 'dependency.kt' + public final static @org.jetbrains.annotations.NotNull method myLet-GPBa7dw(p0: double, p1: double, p2: double, p3: double, @org.jetbrains.annotations.NotNull p4: kotlin.jvm.functions.Function1): DPoint +} + +@kotlin.coroutines.jvm.internal.DebugMetadata +@kotlin.Metadata +final class TestKt$box$13 { + // source: 'test.kt' + enclosing method TestKt.box()Ljava/lang/String; + field label: int + inner (anonymous) class TestKt$box$13 + method (p0: kotlin.coroutines.Continuation): void + public final @org.jetbrains.annotations.NotNull method create(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): kotlin.coroutines.Continuation + public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.Nullable p0: kotlin.coroutines.Continuation): java.lang.Object + public synthetic bridge method invoke(p0: java.lang.Object): java.lang.Object + public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object +} + +@kotlin.coroutines.jvm.internal.DebugMetadata +@kotlin.Metadata +final class TestKt$suspendFun$1 { + // source: 'test.kt' + enclosing method TestKt.suspendFun(Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + field label: int + synthetic field result: java.lang.Object + inner (anonymous) class TestKt$suspendFun$1 + method (p0: kotlin.coroutines.Continuation): void + public final @org.jetbrains.annotations.Nullable method invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object +} + +@kotlin.Metadata +public final class TestKt { + // source: 'test.kt' + inner (anonymous) class TestKt$box$13 + inner (anonymous) class TestKt$suspendFun$1 + public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String + public final static @org.jetbrains.annotations.Nullable method f(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object + public final static method supply(@org.jetbrains.annotations.Nullable p0: java.lang.Object): void + public final static @org.jetbrains.annotations.Nullable method suspendFun(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object + public final inner class kotlin/jvm/internal/Ref$IntRef +} diff --git a/compiler/testData/codegen/bytecodeText/valueClasses/mfvcReassignments.kt b/compiler/testData/codegen/bytecodeText/valueClasses/mfvcReassignments.kt index 87a5d596b52..9cf50864596 100644 --- a/compiler/testData/codegen/bytecodeText/valueClasses/mfvcReassignments.kt +++ b/compiler/testData/codegen/bytecodeText/valueClasses/mfvcReassignments.kt @@ -12,13 +12,23 @@ class Box(var value: DPoint) fun supplier(index: Int) {} // to make usage of the argument fun supplier(index: Int, x: DPoint) {} // to make usage of the argument + +fun `1`() = 1.0 +fun `2`() = 2.0 +fun `3`() = 3.0 +fun `4`() = 4.0 +fun `5`() = 5.0 +fun `6`() = 6.0 +fun `7`() = 7.0 +fun `8`() = 8.0 + fun reassignVariable(x: DPoint, box: Box) { supplier(100) - var p = DPoint(1.0, 2.0) // should not use temporary variables + var p = DPoint(`1`(), `2`()) // should not use temporary variables supplier(101, p) p = p // should not use temporary variables supplier(102, p) - p = DPoint(3.0, 4.0) // should use tempVars + p = DPoint(`3`(), `4`()) // should use tempVars supplier(103, p) p = x // should not use temporary variables supplier(104, p) @@ -30,13 +40,13 @@ fun reassignVariable(x: DPoint, box: Box) { fun reassignField(x: DPoint, box: Box) { supplier(107) - val p = DPoint(5.0, 6.0) + val p = DPoint(`5`(), `6`()) supplier(108, p) var b = Box(p) // should not use temporary variables supplier(109) b.value = b.value // should not use temporary variables supplier(110) - b.value = DPoint(7.0, 8.0) // should use tempVars + b.value = DPoint(`7`(), `8`()) // should use tempVars supplier(111) b.value = x // should not use temporary variables supplier(112) diff --git a/compiler/testData/codegen/bytecodeText/valueClasses/passingMFVC2Functions.kt b/compiler/testData/codegen/bytecodeText/valueClasses/passingMFVC2Functions.kt index b0ef7b2a3a3..8425a4ea769 100644 --- a/compiler/testData/codegen/bytecodeText/valueClasses/passingMFVC2Functions.kt +++ b/compiler/testData/codegen/bytecodeText/valueClasses/passingMFVC2Functions.kt @@ -7,12 +7,17 @@ @JvmInline value class DPoint(val x: Double, val y: Double) +fun `1`() = 1.0 +fun `2`() = 2.0 +fun `3`() = 3.0 +fun `4`() = 4.0 + fun acceptBoxed(x: Any?) {} fun acceptFlattened(x: DPoint) {} -fun returnBoxed() = DPoint(3.0, 4.0) +fun returnBoxed() = DPoint(`3`(), `4`()) fun testFlattened2Boxed() { - acceptBoxed(DPoint(1.0, 2.0)) + acceptBoxed(DPoint(`1`(), `2`())) } fun testBoxed2Boxed() { @@ -20,7 +25,7 @@ fun testBoxed2Boxed() { } fun testFlattened2Flattened() { - acceptFlattened(DPoint(1.0, 2.0)) + acceptFlattened(DPoint(`1`(), `2`())) } fun testBoxed2Flattened() { @@ -28,8 +33,8 @@ fun testBoxed2Flattened() { } fun testIgnoredFlattened() { - DPoint(1.0, 2.0) - DPoint(1.0, 2.0) + DPoint(`1`(), `2`()) + DPoint(`1`(), `2`()) } fun testIgnoredBoxed() { @@ -38,8 +43,8 @@ fun testIgnoredBoxed() { object Init { init { - DPoint(1.0, 2.0) - DPoint(1.0, 2.0) + DPoint(`1`(), `2`()) + DPoint(`1`(), `2`()) } } 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 c75b4becd3b..24ab14bde7e 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 @@ -50501,6 +50501,12 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/valueClasses/functionReferences.kt"); } + @Test + @TestMetadata("inlineFunctions.kt") + public void testInlineFunctions() throws Exception { + runTest("compiler/testData/codegen/box/valueClasses/inlineFunctions.kt"); + } + @Test @TestMetadata("mfvcBothEqualsOverride.kt") public void testMfvcBothEqualsOverride() throws Exception {