diff --git a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirMetadataSerializer.kt b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirMetadataSerializer.kt index 0240266d929..1ee23b198fe 100644 --- a/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirMetadataSerializer.kt +++ b/compiler/fir/fir2ir/jvm-backend/src/org/jetbrains/kotlin/fir/backend/jvm/FirMetadataSerializer.kt @@ -7,8 +7,6 @@ package org.jetbrains.kotlin.fir.backend.jvm import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin -import org.jetbrains.kotlin.backend.jvm.mapping.IrTypeMapper -import org.jetbrains.kotlin.backend.jvm.mapping.mapClass import org.jetbrains.kotlin.backend.jvm.metadata.MetadataSerializer import org.jetbrains.kotlin.codegen.ClassBuilderMode import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings @@ -35,11 +33,9 @@ import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.ir.declarations.IrClass import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin import org.jetbrains.kotlin.ir.declarations.MetadataSource -import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmNameResolver import org.jetbrains.kotlin.metadata.jvm.serialization.JvmStringTable import org.jetbrains.kotlin.modules.TargetId import org.jetbrains.kotlin.name.ClassId -import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.protobuf.MessageLite import org.jetbrains.kotlin.types.AbstractTypeApproximator import org.jetbrains.kotlin.types.TypeApproximatorConfiguration @@ -61,7 +57,7 @@ fun makeFirMetadataSerializerForIrClass( } ?: emptyList() val firSerializerExtension = FirJvmSerializerExtension( session, serializationBindings, context.state, irClass.metadata, localDelegatedProperties, - approximator, context.typeMapper, components + approximator, context.defaultTypeMapper, components ) return FirMetadataSerializer( context.state.globalSerializationBindings, diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBytecodeTextTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBytecodeTextTestGenerated.java index 3104b4e8bd5..f5d041886ce 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBytecodeTextTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBytecodeTextTestGenerated.java @@ -4042,6 +4042,12 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @Test + @TestMetadata("kt27936.kt") + public void testKt27936() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/innerClasses/kt27936.kt"); + } + @Test @TestMetadata("nestedClassInAnnotationArgument.kt") public void testNestedClassInAnnotationArgument() throws Exception { diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt index b021d3e1167..b3a89cfc0dd 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt @@ -49,12 +49,12 @@ import org.jetbrains.org.objectweb.asm.TypeReference import java.lang.annotation.RetentionPolicy abstract class AnnotationCodegen( - private val innerClassConsumer: InnerClassConsumer, - private val context: JvmBackendContext, + private val classCodegen: ClassCodegen, private val skipNullabilityAnnotations: Boolean = false ) { - private val typeMapper = context.typeMapper - private val methodSignatureMapper = context.methodSignatureMapper + private val context = classCodegen.context + private val typeMapper = classCodegen.typeMapper + private val methodSignatureMapper = classCodegen.methodSignatureMapper /** * @param returnType can be null if not applicable (e.g. [annotated] is a class) @@ -195,7 +195,7 @@ abstract class AnnotationCodegen( // (Otherwise we would've resolved the entry to the actual annotation class.) if (annotationClass.isOptionalAnnotationClass) return null - innerClassConsumer.addInnerClassInfoFromAnnotation(annotationClass) + classCodegen.addInnerClassInfo(annotationClass) val asmTypeDescriptor = typeMapper.mapType(annotation.type).descriptor val annotationVisitor = @@ -249,7 +249,7 @@ abstract class AnnotationCodegen( val annotationClassType = callee.returnType val internalAnnName = typeMapper.mapType(annotationClassType).descriptor val visitor = annotationVisitor.visitAnnotation(name, internalAnnName) - annotationClassType.classOrNull?.owner?.let(innerClassConsumer::addInnerClassInfoFromAnnotation) + annotationClassType.classOrNull?.owner?.let(classCodegen::addInnerClassInfo) genAnnotationArguments(value, visitor) visitor.visitEnd() } @@ -259,7 +259,7 @@ abstract class AnnotationCodegen( is IrGetEnumValue -> { val enumEntry = value.symbol.owner val enumClass = enumEntry.parentAsClass - innerClassConsumer.addInnerClassInfoFromAnnotation(enumClass) + classCodegen.addInnerClassInfo(enumClass) annotationVisitor.visitEnum(name, typeMapper.mapClass(enumClass).descriptor, enumEntry.name.asString()) } is IrVararg -> { // array constructor @@ -271,7 +271,7 @@ abstract class AnnotationCodegen( } is IrClassReference -> { val classType = value.classType - classType.classOrNull?.owner?.let(innerClassConsumer::addInnerClassInfoFromAnnotation) + classType.classOrNull?.owner?.let(classCodegen::addInnerClassInfo) val mappedType = if (classType.isInlineClassType()) typeMapper.mapClass(classType.erasedUpperBound) else typeMapper.mapType(classType) @@ -294,7 +294,7 @@ abstract class AnnotationCodegen( ) { if (context.state.target != JVM_1_6) { typeParameterContainer.typeParameters.forEachIndexed { index, typeParameter -> - object : AnnotationCodegen(classCodegen, context, true) { + object : AnnotationCodegen(classCodegen, true) { override fun visitAnnotation(descr: String, visible: Boolean): AnnotationVisitor { return visitor( @@ -318,7 +318,7 @@ abstract class AnnotationCodegen( typeParameter.superTypes.forEach { superType -> val isClassOrTypeParameter = !superType.isInterface() && !superType.isAnnotation() val superIndex = if (isClassOrTypeParameter) 0 else superInterfaceIndex++ - object : AnnotationCodegen(classCodegen, context, true) { + object : AnnotationCodegen(classCodegen, true) { override fun visitAnnotation(descr: String, visible: Boolean): AnnotationVisitor { throw RuntimeException( "Error during generation: only type annotations should be presented on type parameters bounds: " + @@ -406,7 +406,7 @@ abstract class AnnotationCodegen( return } val infos: Iterable> = - IrTypeAnnotationCollector(context.typeMapper.typeSystem).collectTypeAnnotations(type) + IrTypeAnnotationCollector(classCodegen.typeMapper.typeSystem).collectTypeAnnotations(type) for (info in infos) { for (annotation in info.annotations) { genAnnotation(annotation, info.path, true) @@ -435,10 +435,6 @@ abstract class AnnotationCodegen( } -interface InnerClassConsumer { - fun addInnerClassInfoFromAnnotation(innerClass: IrClass) -} - private fun isBareTypeParameterWithNullableUpperBound(type: IrType): Boolean { return type.classifierOrNull?.owner is IrTypeParameter && !type.isMarkedNullable() && type.isNullable() } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt index 5acc310b47d..c18234ac942 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt @@ -11,13 +11,17 @@ import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin import org.jetbrains.kotlin.backend.jvm.MultifileFacadeFileEntry import org.jetbrains.kotlin.backend.jvm.ir.* +import org.jetbrains.kotlin.backend.jvm.mapping.IrTypeMapper +import org.jetbrains.kotlin.backend.jvm.mapping.MethodSignatureMapper import org.jetbrains.kotlin.backend.jvm.mapping.mapClass import org.jetbrains.kotlin.backend.jvm.mapping.mapType import org.jetbrains.kotlin.backend.jvm.metadata.MetadataSerializer +import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap.mapKotlinToJava import org.jetbrains.kotlin.codegen.DescriptorAsmUtil import org.jetbrains.kotlin.codegen.VersionIndependentOpcodes import org.jetbrains.kotlin.codegen.addRecordComponent import org.jetbrains.kotlin.codegen.inline.* +import org.jetbrains.kotlin.codegen.signature.JvmSignatureWriter import org.jetbrains.kotlin.codegen.writeKotlinMetadata import org.jetbrains.kotlin.config.JvmAnalysisFlags import org.jetbrains.kotlin.config.JvmTarget @@ -35,14 +39,14 @@ import org.jetbrains.kotlin.ir.expressions.IrExpression import org.jetbrains.kotlin.ir.expressions.impl.IrBlockBodyImpl import org.jetbrains.kotlin.ir.expressions.impl.IrSetFieldImpl import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol -import org.jetbrains.kotlin.ir.types.IrSimpleType -import org.jetbrains.kotlin.ir.types.IrType -import org.jetbrains.kotlin.ir.types.IrTypeProjection -import org.jetbrains.kotlin.ir.types.classifierOrFail +import org.jetbrains.kotlin.ir.types.* import org.jetbrains.kotlin.ir.util.* import org.jetbrains.kotlin.load.java.JvmAnnotationNames +import org.jetbrains.kotlin.load.kotlin.TypeMappingMode import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader +import org.jetbrains.kotlin.load.kotlin.internalName import org.jetbrains.kotlin.metadata.jvm.deserialization.BitEncoding +import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.JvmNames.JVM_RECORD_ANNOTATION_FQ_NAME import org.jetbrains.kotlin.name.JvmNames.JVM_SYNTHETIC_ANNOTATION_FQ_NAME import org.jetbrains.kotlin.name.JvmNames.TRANSIENT_ANNOTATION_FQ_NAME @@ -64,7 +68,7 @@ class ClassCodegen private constructor( val irClass: IrClass, val context: JvmBackendContext, private val parentFunction: IrFunction?, -) : InnerClassConsumer { +) { // We need to avoid recursive calls to getOrCreate() from within the constructor to prevent lockups // in ConcurrentHashMap context.classCodegens. private val parentClassCodegen by lazy { @@ -78,13 +82,29 @@ class ClassCodegen private constructor( } private val state get() = context.state - private val typeMapper get() = context.typeMapper + + // TODO: the order of entries in this set depends on the order in which methods are generated; this means it is unstable + // under incremental compilation, as calls to `inline fun`s declared in this class cause them to be generated out of order. + private val innerClasses = linkedSetOf() + + val typeMapper = object : IrTypeMapper(context) { + override fun mapType(type: IrType, mode: TypeMappingMode, sw: JvmSignatureWriter?): Type { + var t = type + while (t.isArray()) { + t = t.getArrayElementType(context.irBuiltIns) + } + t.classOrNull?.owner?.let(::addInnerClassInfo) + return super.mapType(type, mode, sw) + } + } + + val methodSignatureMapper = MethodSignatureMapper(context, typeMapper) val type: Type = typeMapper.mapClass(irClass) val reifiedTypeParametersUsages = ReifiedTypeParametersUsages() - private val jvmSignatureClashDetector = JvmSignatureClashDetector(irClass, type, context) + private val jvmSignatureClashDetector = JvmSignatureClashDetector(this) private val classOrigin = irClass.descriptorOrigin @@ -105,10 +125,6 @@ class ClassCodegen private constructor( ) } - // TODO: the order of entries in this set depends on the order in which methods are generated; this means it is unstable - // under incremental compilation, as calls to `inline fun`s declared in this class cause them to be generated out of order. - private val innerClasses = linkedSetOf() - // TODO: the names produced by generators in this map depend on the order in which methods are generated; see above. private val regeneratedObjectNameGenerators = mutableMapOf() @@ -166,7 +182,7 @@ class ClassCodegen private constructor( } } - object : AnnotationCodegen(this@ClassCodegen, context) { + object : AnnotationCodegen(this@ClassCodegen) { override fun visitAnnotation(descr: String, visible: Boolean): AnnotationVisitor { return visitor.visitor.visitAnnotation(descr, visible) } @@ -184,8 +200,6 @@ class ClassCodegen private constructor( generateKotlinMetadataAnnotation() - generateInnerAndOuterClasses() - if (withinInline || !smap.isTrivial) { visitor.visitSMAP(smap, !context.state.languageVersionSettings.supportsFeature(LanguageFeature.CorrectSourceMappingSyntax)) } else { @@ -196,6 +210,8 @@ class ClassCodegen private constructor( addReifiedParametersFromSignature() + generateInnerAndOuterClasses() + visitor.done() jvmSignatureClashDetector.reportErrors(classOrigin) } @@ -345,7 +361,7 @@ class ClassCodegen private constructor( val fieldType = typeMapper.mapType(field) val fieldSignature = if (field.origin == IrDeclarationOrigin.PROPERTY_DELEGATE) null - else context.methodSignatureMapper.mapFieldSignature(field) + else methodSignatureMapper.mapFieldSignature(field) val fieldName = field.name.asString() val flags = field.computeFieldFlags(context, state.languageVersionSettings) val fv = visitor.newField( @@ -359,7 +375,7 @@ class ClassCodegen private constructor( val skipNullabilityAnnotations = flags and (Opcodes.ACC_SYNTHETIC or Opcodes.ACC_ENUM) != 0 || (field.origin == IrDeclarationOrigin.FIELD_FOR_OBJECT_INSTANCE && irClass.isSyntheticSingleton) - object : AnnotationCodegen(this@ClassCodegen, context, skipNullabilityAnnotations) { + object : AnnotationCodegen(this@ClassCodegen, skipNullabilityAnnotations) { override fun visitAnnotation(descr: String, visible: Boolean): AnnotationVisitor { return fv.visitAnnotation(descr, visible) } @@ -474,28 +490,38 @@ class ClassCodegen private constructor( ?: error("Class in a non-static initializer found, but container has no constructors: ${containerClass.render()}") } else parentFunction if (enclosingFunction != null || irClass.isAnonymousInnerClass) { - val method = enclosingFunction?.let(context.methodSignatureMapper::mapAsmMethod)?.takeIf { it.name != "" } + val method = enclosingFunction?.let(methodSignatureMapper::mapAsmMethod)?.takeIf { it.name != "" } visitor.visitOuterClass(parentClassCodegen!!.type.internalName, method?.name, method?.descriptor) } } for (klass in innerClasses) { - val innerClass = typeMapper.classInternalName(klass) + val innerJavaClassId = klass.mapToJava() + val innerClass = innerJavaClassId?.internalName ?: typeMapper.classInternalName(klass) val outerClass = if (klass.isSamWrapper || klass.isAnnotationImplementation || klass.attributeOwnerId in context.isEnclosedInConstructor) null else { when (val parent = klass.parent) { - is IrClass -> typeMapper.classInternalName(parent) + is IrClass -> { + val outerJavaClassId = parent.mapToJava() + if (innerJavaClassId?.packageFqName != outerJavaClassId?.packageFqName) { + continue + } + outerJavaClassId?.internalName ?: typeMapper.classInternalName(parent) + } + else -> null } } - val innerName = if (klass.isAnonymousInnerClass) null else klass.name.asString() + val innerName = if (klass.isAnonymousInnerClass) null else innerJavaClassId?.shortClassName?.asString() ?: klass.name.asString() val accessFlags = klass.calculateInnerClassAccessFlags(context) visitor.visitInnerClass(innerClass, outerClass, innerName, accessFlags) } } + private fun IrClass.mapToJava(): ClassId? = fqNameWhenAvailable?.toUnsafe()?.let(::mapKotlinToJava) + private val IrClass.isAnonymousInnerClass: Boolean get() = isSamWrapper || name.isSpecial || isAnnotationImplementation // NB '' is treated as anonymous inner class here @@ -508,13 +534,10 @@ class ClassCodegen private constructor( private val IrClass.isAnnotationImplementation: Boolean get() = origin == ANNOTATION_IMPLEMENTATION - override fun addInnerClassInfoFromAnnotation(innerClass: IrClass) { - // It's necessary for proper recovering of classId by plain string JVM descriptor when loading annotations - // See FileBasedKotlinClass.convertAnnotationVisitor - generateSequence(innerClass) { it.parent as? IrDeclaration }.takeWhile { !it.isTopLevelDeclaration }.forEach { - if (it is IrClass) { - innerClasses.add(it) - } + fun addInnerClassInfo(innerClass: IrClass) { + var c = innerClass + while (!c.isTopLevelDeclaration && innerClasses.add(c)) { + c = c.parentClassOrNull ?: break } } 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 42f1aa1db72..061bb85d07f 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 @@ -150,8 +150,8 @@ class ExpressionCodegen( get() = generateSequence(irFunction) { context.enclosingMethodOverride[it] }.last() val context = classCodegen.context - val typeMapper = context.typeMapper - val methodSignatureMapper = context.methodSignatureMapper + val typeMapper = classCodegen.typeMapper + val methodSignatureMapper = classCodegen.methodSignatureMapper val state = context.state @@ -1479,7 +1479,7 @@ class ExpressionCodegen( val reifiedTypeInliner = ReifiedTypeInliner( mappings, - IrInlineIntrinsicsSupport(context, typeMapper, element, irFunction.fileParent), + IrInlineIntrinsicsSupport(classCodegen, element, irFunction.fileParent), context.typeSystem, state.languageVersionSettings, state.unifiedNullChecks, diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt index 3d71e542ff6..2dfce611950 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.backend.jvm.codegen import org.jetbrains.kotlin.backend.common.lower.BOUND_RECEIVER_PARAMETER import org.jetbrains.kotlin.backend.common.lower.BOUND_VALUE_PARAMETER -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin import org.jetbrains.kotlin.backend.jvm.ir.* import org.jetbrains.kotlin.backend.jvm.mapping.mapType @@ -48,7 +47,7 @@ class FunctionCodegen(private val irFunction: IrFunction, private val classCodeg } private fun doGenerate(reifiedTypeParameters: ReifiedTypeParametersUsages): SMAPAndMethodNode { - val signature = context.methodSignatureMapper.mapSignatureWithGeneric(irFunction) + val signature = classCodegen.methodSignatureMapper.mapSignatureWithGeneric(irFunction) val flags = irFunction.calculateMethodFlags() val isSynthetic = flags.and(Opcodes.ACC_SYNTHETIC) != 0 val methodNode = MethodNode( @@ -72,7 +71,7 @@ class FunctionCodegen(private val irFunction: IrFunction, private val classCodeg if (irFunction.origin !in methodOriginsWithoutAnnotations) { val skipNullabilityAnnotations = flags and Opcodes.ACC_PRIVATE != 0 || flags and Opcodes.ACC_SYNTHETIC != 0 - object : AnnotationCodegen(classCodegen, context, skipNullabilityAnnotations) { + object : AnnotationCodegen(classCodegen, skipNullabilityAnnotations) { override fun visitAnnotation(descr: String, visible: Boolean): AnnotationVisitor { return methodVisitor.visitAnnotation(descr, visible) } @@ -95,7 +94,7 @@ class FunctionCodegen(private val irFunction: IrFunction, private val classCodeg } if (shouldGenerateAnnotationsOnValueParameters()) { - generateParameterAnnotations(irFunction, methodVisitor, signature, classCodegen, context, skipNullabilityAnnotations) + generateParameterAnnotations(irFunction, methodVisitor, signature, classCodegen, skipNullabilityAnnotations) } } @@ -214,13 +213,13 @@ class FunctionCodegen(private val irFunction: IrFunction, private val classCodeg // @Throws(vararg exceptionClasses: KClass) val exceptionClasses = function.getAnnotation(JVM_THROWS_ANNOTATION_FQ_NAME)?.getValueArgument(0) ?: return null return (exceptionClasses as IrVararg).elements.map { exceptionClass -> - context.typeMapper.mapType((exceptionClass as IrClassReference).classType).internalName + classCodegen.typeMapper.mapType((exceptionClass as IrClassReference).classType).internalName } } private fun generateAnnotationDefaultValueIfNeeded(methodVisitor: MethodVisitor) { getAnnotationDefaultValueExpression()?.let { defaultValueExpression -> - val annotationCodegen = object : AnnotationCodegen(classCodegen, context) { + val annotationCodegen = object : AnnotationCodegen(classCodegen) { override fun visitAnnotation(descr: String, visible: Boolean): AnnotationVisitor { return methodVisitor.visitAnnotationDefault() } @@ -247,18 +246,18 @@ class FunctionCodegen(private val irFunction: IrFunction, private val classCodeg val frameMap = IrFrameMap() val receiver = if (this is IrConstructor) parentAsClass.thisReceiver else dispatchReceiverParameter receiver?.let { - frameMap.enter(it, context.typeMapper.mapTypeAsDeclaration(it.type)) + frameMap.enter(it, classCodegen.typeMapper.mapTypeAsDeclaration(it.type)) } val contextReceivers = valueParameters.subList(0, contextReceiverParametersCount) for (contextReceiver in contextReceivers) { - frameMap.enter(contextReceiver, context.typeMapper.mapType(contextReceiver.type)) + frameMap.enter(contextReceiver, classCodegen.typeMapper.mapType(contextReceiver.type)) } extensionReceiverParameter?.let { - frameMap.enter(it, context.typeMapper.mapType(it)) + frameMap.enter(it, classCodegen.typeMapper.mapType(it)) } val regularParameters = valueParameters.subList(contextReceiverParametersCount, valueParameters.size) for (parameter in regularParameters) { - frameMap.enter(parameter, context.typeMapper.mapType(parameter.type)) + frameMap.enter(parameter, classCodegen.typeMapper.mapType(parameter.type)) } return frameMap } @@ -268,8 +267,7 @@ class FunctionCodegen(private val irFunction: IrFunction, private val classCodeg irFunction: IrFunction, mv: MethodVisitor, jvmSignature: JvmMethodSignature, - innerClassConsumer: InnerClassConsumer, - context: JvmBackendContext, + classCodegen: ClassCodegen, skipNullabilityAnnotations: Boolean = false ) { val iterator = irFunction.valueParameters.iterator() @@ -286,7 +284,7 @@ class FunctionCodegen(private val irFunction: IrFunction, private val classCodeg } if (annotated != null && !kind.isSkippedInGenericSignature && !annotated.isSyntheticMarkerParameter()) { - object : AnnotationCodegen(innerClassConsumer, context, skipNullabilityAnnotations) { + object : AnnotationCodegen(classCodegen, skipNullabilityAnnotations) { override fun visitAnnotation(descr: String, visible: Boolean): AnnotationVisitor { return mv.visitParameterAnnotation( i - syntheticParameterCount, diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineIntrinsicsSupport.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineIntrinsicsSupport.kt index fe95f658fa4..9ddfe72ed53 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineIntrinsicsSupport.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineIntrinsicsSupport.kt @@ -5,11 +5,9 @@ package org.jetbrains.kotlin.backend.jvm.codegen -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.backend.jvm.intrinsics.SignatureString import org.jetbrains.kotlin.backend.jvm.ir.getCallableReferenceOwnerKClassType import org.jetbrains.kotlin.backend.jvm.ir.getCallableReferenceTopLevelFlag -import org.jetbrains.kotlin.backend.jvm.mapping.IrTypeMapper import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.codegen.inline.ReifiedTypeInliner @@ -35,16 +33,15 @@ import org.jetbrains.org.objectweb.asm.Type.VOID_TYPE import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter class IrInlineIntrinsicsSupport( - private val context: JvmBackendContext, - private val typeMapper: IrTypeMapper, + private val classCodegen: ClassCodegen, private val reportErrorsOn: IrExpression, private val containingFile: IrFile, ) : ReifiedTypeInliner.IntrinsicsSupport { override val state: GenerationState - get() = context.state + get() = classCodegen.context.state override fun putClassInstance(v: InstructionAdapter, type: IrType) { - ExpressionCodegen.generateClassInstance(v, type, typeMapper, wrapPrimitives = false) + ExpressionCodegen.generateClassInstance(v, type, classCodegen.typeMapper, wrapPrimitives = false) } override fun generateTypeParameterContainer(v: InstructionAdapter, typeParameter: TypeParameterMarker) { @@ -53,7 +50,7 @@ class IrInlineIntrinsicsSupport( when (val parent = typeParameter.owner.parent) { is IrClass -> putClassInstance(v, parent.defaultType).also { AsmUtil.wrapJavaClassIntoKClass(v) } is IrSimpleFunction -> { - check(context.state.generateOptimizedCallableReferenceSuperClasses) { + check(classCodegen.context.state.generateOptimizedCallableReferenceSuperClasses) { "typeOf() of a non-reified type parameter is only allowed if optimized callable references are enabled.\n" + "Please make sure API version is set to 1.4, and -Xno-optimized-callable-references is NOT used.\n" + "Container: $parent" @@ -93,10 +90,10 @@ class IrInlineIntrinsicsSupport( if (withArity) { v.iconst(function.allParametersCount) } - putClassInstance(v, declaration.parent.getCallableReferenceOwnerKClassType(context)) + putClassInstance(v, declaration.parent.getCallableReferenceOwnerKClassType(classCodegen.context)) v.aconst(declaration.name.asString()) // TODO: generate correct signature for functions and property accessors which have inline class types in the signature. - SignatureString.generateSignatureString(v, function, context) + SignatureString.generateSignatureString(v, function, classCodegen) v.iconst(declaration.getCallableReferenceTopLevelFlag()) val parameterTypes = (if (withArity) listOf(INT_TYPE) else emptyList()) + @@ -116,11 +113,11 @@ class IrInlineIntrinsicsSupport( override fun toKotlinType(type: IrType): KotlinType = type.toIrBasedKotlinType() override fun reportSuspendTypeUnsupported() { - context.ktDiagnosticReporter.at(reportErrorsOn, containingFile).report(JvmBackendErrors.TYPEOF_SUSPEND_TYPE) + classCodegen.context.ktDiagnosticReporter.at(reportErrorsOn, containingFile).report(JvmBackendErrors.TYPEOF_SUSPEND_TYPE) } override fun reportNonReifiedTypeParameterWithRecursiveBoundUnsupported(typeParameterName: Name) { - context.ktDiagnosticReporter.at(reportErrorsOn, containingFile) + classCodegen.context.ktDiagnosticReporter.at(reportErrorsOn, containingFile) .report(JvmBackendErrors.TYPEOF_NON_REIFIED_TYPE_PARAMETER_WITH_RECURSIVE_BOUND, typeParameterName.asString()) } } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/JvmSignatureClashDetector.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/JvmSignatureClashDetector.kt index 3f2e8bc5dbf..fdf9c21cdad 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/JvmSignatureClashDetector.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/JvmSignatureClashDetector.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.backend.jvm.codegen import org.jetbrains.kotlin.backend.common.lower.ANNOTATION_IMPLEMENTATION import org.jetbrains.kotlin.backend.common.psi.PsiSourceManager -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin import org.jetbrains.kotlin.descriptors.DescriptorVisibilities import org.jetbrains.kotlin.diagnostics.KtDiagnosticFactory1 @@ -17,12 +16,9 @@ import org.jetbrains.kotlin.ir.util.file import org.jetbrains.kotlin.ir.util.isFakeOverride import org.jetbrains.kotlin.resolve.jvm.diagnostics.* import org.jetbrains.kotlin.utils.SmartSet -import org.jetbrains.org.objectweb.asm.Type class JvmSignatureClashDetector( - private val irClass: IrClass, - private val type: Type, - private val context: JvmBackendContext + private val classCodegen: ClassCodegen ) { private val methodsBySignature = LinkedHashMap>() private val fieldsBySignature = LinkedHashMap>() @@ -46,7 +42,7 @@ class JvmSignatureClashDetector( } private fun mapRawSignature(irFunction: IrFunction): RawSignature { - val jvmSignature = context.methodSignatureMapper.mapSignatureSkipGeneric(irFunction) + val jvmSignature = classCodegen.methodSignatureMapper.mapSignatureSkipGeneric(irFunction) return RawSignature(jvmSignature.asmMethod.name, jvmSignature.asmMethod.descriptor, MemberKind.METHOD) } @@ -88,10 +84,10 @@ class JvmSignatureClashDetector( when { realMethodsCount == 0 && (fakeOverridesCount > 1 || specialOverridesCount > 1) -> - if (irClass.origin != JvmLoweredDeclarationOrigin.DEFAULT_IMPLS) { + if (classCodegen.irClass.origin != JvmLoweredDeclarationOrigin.DEFAULT_IMPLS) { reportJvmSignatureClash( JvmBackendErrors.CONFLICTING_INHERITED_JVM_DECLARATIONS, - listOf(irClass), + listOf(classCodegen.irClass), conflictingJvmDeclarationsData ) } @@ -99,7 +95,7 @@ class JvmSignatureClashDetector( fakeOverridesCount == 0 && specialOverridesCount == 0 -> { // In IFoo$DefaultImpls we should report errors only if there are private methods among conflicting ones // (otherwise such errors would be reported twice: once for IFoo and once for IFoo$DefaultImpls). - if (irClass.origin != JvmLoweredDeclarationOrigin.DEFAULT_IMPLS || + if (classCodegen.irClass.origin != JvmLoweredDeclarationOrigin.DEFAULT_IMPLS || methods.any { DescriptorVisibilities.isPrivate(it.visibility) } ) { reportJvmSignatureClash( @@ -111,7 +107,7 @@ class JvmSignatureClashDetector( } else -> - if (irClass.origin != JvmLoweredDeclarationOrigin.DEFAULT_IMPLS) { + if (classCodegen.irClass.origin != JvmLoweredDeclarationOrigin.DEFAULT_IMPLS) { reportJvmSignatureClash( JvmBackendErrors.ACCIDENTAL_OVERRIDE, methods.filter { !it.isFakeOverride && !it.isSpecialOverride() }, @@ -128,7 +124,7 @@ class JvmSignatureClashDetector( val methods = knownMethods.filter { !it.isFakeOverride && !it.isSpecialOverride() } if (methods.isEmpty()) continue val conflictingJvmDeclarationsData = ConflictingJvmDeclarationsData( - type.internalName, classOrigin, predefinedSignature, + classCodegen.type.internalName, classOrigin, predefinedSignature, methods.map { it.getJvmDeclarationOrigin() } + JvmDeclarationOrigin(JvmDeclarationOriginKind.OTHER, null, null) ) reportJvmSignatureClash(JvmBackendErrors.ACCIDENTAL_OVERRIDE, methods, conflictingJvmDeclarationsData) @@ -149,7 +145,7 @@ class JvmSignatureClashDetector( conflictingJvmDeclarationsData: ConflictingJvmDeclarationsData ) { irDeclarations.mapNotNullTo(LinkedHashSet()) { irDeclaration -> - context.ktDiagnosticReporter.atFirstValidFrom(irDeclaration, irClass, containingIrFile = irDeclaration.file) + classCodegen.context.ktDiagnosticReporter.atFirstValidFrom(irDeclaration, classCodegen.irClass, containingIrFile = irDeclaration.file) }.forEach { it.report(diagnosticFactory1, conflictingJvmDeclarationsData) } @@ -161,7 +157,7 @@ class JvmSignatureClashDetector( methods: Collection ): ConflictingJvmDeclarationsData = ConflictingJvmDeclarationsData( - type.internalName, + classCodegen.type.internalName, classOrigin, rawSignature, methods.map { it.getJvmDeclarationOrigin() } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/irCodegenUtils.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/irCodegenUtils.kt index d127b7d8728..d0584144982 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/irCodegenUtils.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/codegen/irCodegenUtils.kt @@ -87,7 +87,7 @@ fun JvmBackendContext.getSourceMapper(declaration: IrClass): SourceMapper { return SourceMapper( SourceInfo( sourceFileName, - typeMapper.mapClass(declaration).internalName, + defaultTypeMapper.mapClass(declaration).internalName, endLineNumber + 1 ) ) diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayIterator.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayIterator.kt index b7d775048f1..566d9d203a6 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayIterator.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArrayIterator.kt @@ -16,7 +16,7 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.backend.jvm.mapping.mapClass import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression @@ -27,10 +27,10 @@ object ArrayIterator : IntrinsicMethod() { override fun toCallable( expression: IrFunctionAccessExpression, signature: JvmMethodSignature, - context: JvmBackendContext + classCodegen: ClassCodegen ): IrIntrinsicFunction { - val owner = context.typeMapper.mapClass(expression.symbol.owner.parentAsClass) - return IrIntrinsicFunction.create(expression, signature, context, owner) { + val owner = classCodegen.typeMapper.mapClass(expression.symbol.owner.parentAsClass) + return IrIntrinsicFunction.create(expression, signature, classCodegen, owner) { val methodSignature = "(${owner.descriptor})${signature.returnType.descriptor}" val intrinsicOwner = if (AsmUtil.isPrimitive(owner.elementType)) diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArraySize.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArraySize.kt index f9a10633185..d132052d009 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArraySize.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ArraySize.kt @@ -16,15 +16,14 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature object ArraySize : IntrinsicMethod() { - override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, context: JvmBackendContext): IrIntrinsicFunction { - return IrIntrinsicFunction.create(expression, signature, context) { + override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen): IrIntrinsicFunction { + return IrIntrinsicFunction.create(expression, signature, classCodegen) { it.arraylength() } } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/BinaryOp.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/BinaryOp.kt index f3a7cb05a77..7ddddba0808 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/BinaryOp.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/BinaryOp.kt @@ -16,7 +16,7 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.codegen.AsmUtil.numberFunctionOperandType import org.jetbrains.kotlin.codegen.StackValue import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression @@ -34,7 +34,7 @@ class BinaryOp(private val opcode: Int) : IntrinsicMethod() { override fun toCallable( expression: IrFunctionAccessExpression, signature: JvmMethodSignature, - context: JvmBackendContext + classCodegen: ClassCodegen ): IrIntrinsicFunction { val returnType = signature.returnType val intermediateResultType = numberFunctionOperandType(returnType) @@ -44,7 +44,7 @@ class BinaryOp(private val opcode: Int) : IntrinsicMethod() { listOf(Type.CHAR_TYPE, signature.valueParameters[0].asmType) } - return IrIntrinsicFunction.create(expression, signature, context, argTypes) { + return IrIntrinsicFunction.create(expression, signature, classCodegen, argTypes) { it.visitInsn(returnType.getOpcode(opcode)) StackValue.coerce(intermediateResultType, returnType, it) } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Clone.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Clone.kt index 4e18defecd6..35a06397cd3 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Clone.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Clone.kt @@ -16,7 +16,7 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.ir.expressions.IrCall import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression import org.jetbrains.kotlin.resolve.jvm.AsmTypes @@ -31,15 +31,15 @@ object Clone : IntrinsicMethod() { override fun toCallable( expression: IrFunctionAccessExpression, signature: JvmMethodSignature, - context: JvmBackendContext + classCodegen: ClassCodegen ): IrIntrinsicFunction { val isSuperCall = expression is IrCall && expression.superQualifierSymbol != null val opcode = if (isSuperCall) Opcodes.INVOKESPECIAL else Opcodes.INVOKEVIRTUAL val newSignature = signature.newReturnType(AsmTypes.OBJECT_TYPE) - val argTypes0 = expression.argTypes(context) + val argTypes0 = expression.argTypes(classCodegen) // Don't upcast receiver to java.lang.Cloneable, since 'clone' is protected in java.lang.Object. val argTypes = if (isSuperCall || argTypes0[0] == CLONEABLE_TYPE) listOf(AsmTypes.OBJECT_TYPE) else argTypes0 - return IrIntrinsicFunction.create(expression, newSignature, context, argTypes) { mv -> + return IrIntrinsicFunction.create(expression, newSignature, classCodegen, argTypes) { mv -> mv.visitMethodInsn(opcode, "java/lang/Object", "clone", "()Ljava/lang/Object;", false) } } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/CompareTo.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/CompareTo.kt index 4f977066928..3910d8e2263 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/CompareTo.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/CompareTo.kt @@ -17,7 +17,6 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics import com.intellij.psi.tree.IElementType -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.backend.jvm.JvmSymbols import org.jetbrains.kotlin.backend.jvm.codegen.* import org.jetbrains.kotlin.backend.jvm.ir.isSmartcastFromHigherThanNullable @@ -40,7 +39,7 @@ import org.jetbrains.org.objectweb.asm.Type import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter object CompareTo : IntrinsicMethod() { - private fun genInvoke(type: Type?, v: InstructionAdapter, context: JvmBackendContext) { + private fun genInvoke(type: Type?, v: InstructionAdapter, classCodegen: ClassCodegen) { when (type) { Type.CHAR_TYPE, Type.BYTE_TYPE, Type.SHORT_TYPE, Type.INT_TYPE -> v.invokestatic(JvmSymbols.INTRINSICS_CLASS_NAME, "compare", "(II)I", false) @@ -50,7 +49,7 @@ object CompareTo : IntrinsicMethod() { Type.BOOLEAN_TYPE -> { // We could support it for JVM target 1.6, but it's prohibited now anyway (except for stdlib, which doesn't have such code), // so throwing an exception instead. - check(context.state.target >= JvmTarget.JVM_1_8) { + check(classCodegen.context.state.target >= JvmTarget.JVM_1_8) { "Cannot generate boolean comparison for JVM target 1.6" } v.invokestatic("java/lang/Boolean", "compare", "(ZZ)I", false) @@ -62,16 +61,16 @@ object CompareTo : IntrinsicMethod() { override fun toCallable( expression: IrFunctionAccessExpression, signature: JvmMethodSignature, - context: JvmBackendContext + classCodegen: ClassCodegen ): IrIntrinsicFunction { val callee = expression.symbol.owner val calleeParameter = callee.dispatchReceiverParameter ?: callee.extensionReceiverParameter!! val parameterType = comparisonOperandType( - context.typeMapper.mapType(calleeParameter.type), + classCodegen.typeMapper.mapType(calleeParameter.type), signature.valueParameters.single().asmType, ) - return IrIntrinsicFunction.create(expression, signature, context, listOf(parameterType, parameterType)) { - genInvoke(parameterType, it, context) + return IrIntrinsicFunction.create(expression, signature, classCodegen, listOf(parameterType, parameterType)) { + genInvoke(parameterType, it, classCodegen) } } } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Equals.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Equals.kt index 8abab998e6a..23d8bf17e61 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Equals.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Equals.kt @@ -6,7 +6,6 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics import com.intellij.psi.tree.IElementType -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.backend.jvm.codegen.* import org.jetbrains.kotlin.backend.jvm.ir.isSmartcastFromHigherThanNullable import org.jetbrains.kotlin.backend.jvm.ir.receiverAndArgs @@ -155,12 +154,12 @@ class Ieee754Equals(val operandType: Type) : IntrinsicMethod() { override fun toCallable( expression: IrFunctionAccessExpression, signature: JvmMethodSignature, - context: JvmBackendContext + classCodegen: ClassCodegen ): IrIntrinsicFunction { class Ieee754AreEqual( val left: Type, val right: Type - ) : IrIntrinsicFunction(expression, signature, context, listOf(left, right)) { + ) : IrIntrinsicFunction(expression, signature, classCodegen, listOf(left, right)) { override fun genInvokeInstruction(v: InstructionAdapter) { v.invokestatic( IntrinsicMethods.INTRINSICS_CLASS_NAME, "areEqual", @@ -185,15 +184,15 @@ class Ieee754Equals(val operandType: Type) : IntrinsicMethod() { val arg1isNullable = arg1Type.isNullable() val useNonIEEE754Comparison = - !context.state.languageVersionSettings.supportsFeature(LanguageFeature.ProperIeee754Comparisons) - && (arg0.isSmartcastFromHigherThanNullable(context) || arg1.isSmartcastFromHigherThanNullable(context)) + !classCodegen.context.state.languageVersionSettings.supportsFeature(LanguageFeature.ProperIeee754Comparisons) + && (arg0.isSmartcastFromHigherThanNullable(classCodegen.context) || arg1.isSmartcastFromHigherThanNullable(classCodegen.context)) return when { useNonIEEE754Comparison -> Ieee754AreEqual(AsmTypes.OBJECT_TYPE, AsmTypes.OBJECT_TYPE) !arg0isNullable && !arg1isNullable -> - object : IrIntrinsicFunction(expression, signature, context, listOf(operandType, operandType)) { + object : IrIntrinsicFunction(expression, signature, classCodegen, listOf(operandType, operandType)) { override fun genInvokeInstruction(v: InstructionAdapter) { StackValue.cmp(KtTokens.EQEQ, operandType, StackValue.onStack(operandType), StackValue.onStack(operandType)) .put(Type.BOOLEAN_TYPE, v) diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Increment.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Increment.kt index 4ae701fb2b1..9394b5af676 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Increment.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Increment.kt @@ -16,14 +16,14 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.codegen.DescriptorAsmUtil.genIncrement import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature class Increment(private val myDelta: Int) : IntrinsicMethod() { - override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, context: JvmBackendContext): IrIntrinsicFunction { - return IrIntrinsicFunction.create(expression, signature, context) { + override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen): IrIntrinsicFunction { + return IrIntrinsicFunction.create(expression, signature, classCodegen) { genIncrement(signature.returnType, myDelta, it) } } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt index 372ed7494be..164a54502f0 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicMethod.kt @@ -6,14 +6,8 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics import org.jetbrains.kotlin.backend.jvm.IntrinsicMarker -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext -import org.jetbrains.kotlin.backend.jvm.codegen.BlockInfo -import org.jetbrains.kotlin.backend.jvm.codegen.ExpressionCodegen -import org.jetbrains.kotlin.backend.jvm.codegen.MaterialValue -import org.jetbrains.kotlin.backend.jvm.codegen.PromisedValue -import org.jetbrains.kotlin.ir.expressions.IrExpression +import org.jetbrains.kotlin.backend.jvm.codegen.* import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature import org.jetbrains.org.objectweb.asm.Type import org.jetbrains.org.objectweb.asm.commons.Method @@ -22,27 +16,19 @@ abstract class IntrinsicMethod : IntrinsicMarker { open fun toCallable( expression: IrFunctionAccessExpression, signature: JvmMethodSignature, - context: JvmBackendContext + classCodegen: ClassCodegen ): IrIntrinsicFunction = TODO("implement toCallable() or invoke() of $this") open fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue? = with(codegen) { val descriptor = methodSignatureMapper.mapSignatureSkipGeneric(expression.symbol.owner) - val stackValue = toCallable(expression, descriptor, context).invoke(mv, codegen, data, expression) + val stackValue = toCallable(expression, descriptor, codegen.classCodegen).invoke(mv, codegen, data, expression) stackValue.put(mv) return MaterialValue(this, stackValue.type, expression.type) } companion object { - fun calcReceiverType(call: IrMemberAccessExpression<*>, context: JvmBackendContext): Type { - return context.typeMapper.mapType(call.dispatchReceiver?.type ?: call.extensionReceiver!!.type) - } - - fun expressionType(expression: IrExpression, context: JvmBackendContext): Type { - return context.typeMapper.mapType(expression.type) - } - fun JvmMethodSignature.newReturnType(type: Type): JvmMethodSignature { val newMethod = with(asmMethod) { Method(name, type, argumentTypes) diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicShouldHaveBeenLowered.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicShouldHaveBeenLowered.kt index ad6613ff082..be7acd2c015 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicShouldHaveBeenLowered.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IntrinsicShouldHaveBeenLowered.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression import org.jetbrains.kotlin.ir.util.render import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature @@ -14,7 +14,7 @@ object IntrinsicShouldHaveBeenLowered : IntrinsicMethod() { override fun toCallable( expression: IrFunctionAccessExpression, signature: JvmMethodSignature, - context: JvmBackendContext + classCodegen: ClassCodegen ): IrIntrinsicFunction { error("Intrinsic should have been lowered: '${expression.symbol.owner.render()}'") } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Inv.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Inv.kt index c9a499a2f77..4dd7b19fdb9 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Inv.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/Inv.kt @@ -16,19 +16,18 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.codegen.AsmUtil.numberFunctionOperandType import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature import org.jetbrains.org.objectweb.asm.Type object Inv : IntrinsicMethod() { /*TODO new this type*/ - override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, context: JvmBackendContext): IrIntrinsicFunction { + override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen): IrIntrinsicFunction { val returnType = signature.returnType val type = numberFunctionOperandType(returnType) - return IrIntrinsicFunction.create(expression, signature, context, type) { + return IrIntrinsicFunction.create(expression, signature, classCodegen, type) { if (returnType == Type.LONG_TYPE) { it.lconst(-1) } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberHashCode.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberHashCode.kt index 4e35554cce5..3e969c73557 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberHashCode.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberHashCode.kt @@ -15,7 +15,7 @@ object IrDataClassArrayMemberHashCode : IntrinsicMethod() { override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue? = with(codegen) { val arrayType = expression.getValueArgument(0)!!.type - val asmArrayType = context.typeMapper.mapType(arrayType) + val asmArrayType = codegen.typeMapper.mapType(arrayType) gen(expression.getValueArgument(0)!!, asmArrayType, arrayType, data) val hashCodeArgumentDescriptor = if (arrayType.isPrimitiveArray()) asmArrayType.descriptor else "[Ljava/lang/Object;" mv.invokestatic("java/util/Arrays", "hashCode", "($hashCodeArgumentDescriptor)I", false) diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberToString.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberToString.kt index 4884d38c27a..162d58dccab 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberToString.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrDataClassArrayMemberToString.kt @@ -15,7 +15,7 @@ object IrDataClassArrayMemberToString : IntrinsicMethod() { override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue? = with(codegen) { val arrayType = expression.getValueArgument(0)!!.type - val asmArrayType = context.typeMapper.mapType(arrayType) + val asmArrayType = codegen.typeMapper.mapType(arrayType) gen(expression.getValueArgument(0)!!, asmArrayType, arrayType, data) val toStringArgumentDescriptor = if (arrayType.isPrimitiveArray()) asmArrayType.descriptor else "[Ljava/lang/Object;" mv.invokestatic("java/util/Arrays", "toString", "($toStringArgumentDescriptor)Ljava/lang/String;", false) diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIllegalArgumentException.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIllegalArgumentException.kt index a393f328c27..de6fde35609 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIllegalArgumentException.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIllegalArgumentException.kt @@ -16,8 +16,8 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.backend.jvm.codegen.BlockInfo +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.backend.jvm.codegen.ExpressionCodegen import org.jetbrains.kotlin.codegen.StackValue import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression @@ -32,9 +32,9 @@ object IrIllegalArgumentException : IntrinsicMethod() { override fun toCallable( expression: IrFunctionAccessExpression, signature: JvmMethodSignature, - context: JvmBackendContext + classCodegen: ClassCodegen ): IrIntrinsicFunction { - return object : IrIntrinsicFunction(expression, signature, context, listOf(JAVA_STRING_TYPE)) { + return object : IrIntrinsicFunction(expression, signature, classCodegen, listOf(JAVA_STRING_TYPE)) { override fun genInvokeInstruction(v: InstructionAdapter) { v.invokespecial( exceptionTypeDescriptor.internalName, diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicFunction.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicFunction.kt index 0131352c377..2fe37b6b3c3 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicFunction.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrIntrinsicFunction.kt @@ -5,8 +5,8 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.backend.jvm.codegen.BlockInfo +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.backend.jvm.codegen.ExpressionCodegen import org.jetbrains.kotlin.backend.jvm.mapping.mapClass import org.jetbrains.kotlin.codegen.AsmUtil @@ -27,8 +27,8 @@ import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter open class IrIntrinsicFunction( val expression: IrFunctionAccessExpression, val signature: JvmMethodSignature, - val context: JvmBackendContext, - val argsTypes: List = expression.argTypes(context) + val classCodegen: ClassCodegen, + val argsTypes: List = expression.argTypes(classCodegen) ) : Callable { override val owner: Type get() = TODO("not implemented") //To change initializer of created properties use File | Settings | File Templates. @@ -110,11 +110,11 @@ open class IrIntrinsicFunction( fun create( expression: IrFunctionAccessExpression, signature: JvmMethodSignature, - context: JvmBackendContext, - argsTypes: List = expression.argTypes(context), + classCodegen: ClassCodegen, + argsTypes: List = expression.argTypes(classCodegen), invokeInstruction: IrIntrinsicFunction.(InstructionAdapter) -> Unit ): IrIntrinsicFunction { - return object : IrIntrinsicFunction(expression, signature, context, argsTypes) { + return object : IrIntrinsicFunction(expression, signature, classCodegen, argsTypes) { override fun genInvokeInstruction(v: InstructionAdapter) = invokeInstruction(v) } @@ -122,11 +122,11 @@ open class IrIntrinsicFunction( fun createWithResult( expression: IrFunctionAccessExpression, signature: JvmMethodSignature, - context: JvmBackendContext, - argsTypes: List = expression.argTypes(context), + classCodegen: ClassCodegen, + argsTypes: List = expression.argTypes(classCodegen ), invokeInstruction: IrIntrinsicFunction.(InstructionAdapter) -> Type ): IrIntrinsicFunction { - return object : IrIntrinsicFunction(expression, signature, context, argsTypes) { + return object : IrIntrinsicFunction(expression, signature, classCodegen, argsTypes) { override fun genInvokeInstructionWithResult(v: InstructionAdapter) = invokeInstruction(v) } @@ -135,21 +135,21 @@ open class IrIntrinsicFunction( fun create( expression: IrFunctionAccessExpression, signature: JvmMethodSignature, - context: JvmBackendContext, + classCodegen: ClassCodegen, type: Type, invokeInstruction: IrIntrinsicFunction.(InstructionAdapter) -> Unit ): IrIntrinsicFunction { - return create(expression, signature, context, listOf(type), invokeInstruction) + return create(expression, signature, classCodegen, listOf(type), invokeInstruction) } } } -fun IrFunctionAccessExpression.argTypes(context: JvmBackendContext): ArrayList { +fun IrFunctionAccessExpression.argTypes(classCodegen: ClassCodegen): ArrayList { val callee = symbol.owner - val signature = context.methodSignatureMapper.mapSignatureSkipGeneric(callee) + val signature = classCodegen.methodSignatureMapper.mapSignatureSkipGeneric(callee) return arrayListOf().apply { if (dispatchReceiver != null) { - add(context.typeMapper.mapClass(callee.parentAsClass)) + add(classCodegen.typeMapper.mapClass(callee.parentAsClass)) } addAll(signature.asmMethod.argumentTypes) } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrNoWhenBranchMatchedException.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrNoWhenBranchMatchedException.kt index f2b3e357de1..ac5cb406c77 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrNoWhenBranchMatchedException.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IrNoWhenBranchMatchedException.kt @@ -16,15 +16,14 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.codegen.AsmUtil.genThrow import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature object IrNoWhenBranchMatchedException : IntrinsicMethod() { - override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, context: JvmBackendContext): IrIntrinsicFunction { - return IrIntrinsicFunction.create(expression, signature, context) { + override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen): IrIntrinsicFunction { + return IrIntrinsicFunction.create(expression, signature, classCodegen) { genThrow(it, "kotlin/NoWhenBranchMatchedException", null) } } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IsArrayOf.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IsArrayOf.kt index ff5a9e42992..80ecf7b2d9c 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IsArrayOf.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IsArrayOf.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression import org.jetbrains.kotlin.ir.types.typeWith import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature @@ -14,9 +14,9 @@ object IsArrayOf : IntrinsicMethod() { override fun toCallable( expression: IrFunctionAccessExpression, signature: JvmMethodSignature, - context: JvmBackendContext - ): IrIntrinsicFunction = IrIntrinsicFunction.create(expression, signature, context) { v -> - val arrayType = context.irBuiltIns.arrayClass.typeWith(expression.getTypeArgument(0)!!) - v.instanceOf(context.typeMapper.mapType(arrayType)) + classCodegen: ClassCodegen + ): IrIntrinsicFunction = IrIntrinsicFunction.create(expression, signature, classCodegen) { v -> + val arrayType = classCodegen.context.irBuiltIns.arrayClass.typeWith(expression.getTypeArgument(0)!!) + v.instanceOf(classCodegen.typeMapper.mapType(arrayType)) } } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IteratorNext.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IteratorNext.kt index 6ab782b5f35..12345a4a437 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IteratorNext.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/IteratorNext.kt @@ -16,25 +16,24 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.builtins.StandardNames.COLLECTIONS_PACKAGE_FQ_NAME import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.fileClasses.internalNameWithoutInnerClasses import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.resolve.jvm.AsmTypes import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature import org.jetbrains.org.objectweb.asm.Type object IteratorNext : IntrinsicMethod() { - override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, context: JvmBackendContext): IrIntrinsicFunction { + override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen): IrIntrinsicFunction { // If the array element type is unboxed primitive, do not unbox. Otherwise AsmUtil.unbox throws exception val type = if (AsmUtil.isBoxedPrimitiveType(signature.returnType)) AsmUtil.unboxType(signature.returnType) else signature.returnType val newSignature = signature.newReturnType(type) val primitiveClassName = getKotlinPrimitiveClassName(type) - return IrIntrinsicFunction.create(expression, newSignature, context, getPrimitiveIteratorType(primitiveClassName)) { + return IrIntrinsicFunction.create(expression, newSignature, classCodegen, getPrimitiveIteratorType(primitiveClassName)) { it.invokevirtual( getPrimitiveIteratorType(primitiveClassName).internalName, "next${primitiveClassName.asString()}", diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/JvmInvokeDynamic.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/JvmInvokeDynamic.kt index 5c39ff86b56..0462d738f06 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/JvmInvokeDynamic.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/JvmInvokeDynamic.kt @@ -109,7 +109,7 @@ object JvmInvokeDynamic : IntrinsicMethod() { } private fun generateMethodHandle(irRawFunctionReference: IrRawFunctionReference, codegen: ExpressionCodegen): Handle = - codegen.context.methodSignatureMapper.mapToMethodHandle(irRawFunctionReference.symbol.owner) + codegen.methodSignatureMapper.mapToMethodHandle(irRawFunctionReference.symbol.owner) private fun evalOriginalMethodType(irCall: IrCall, codegen: ExpressionCodegen): Type { val irRawFunRef = irCall.getValueArgument(0) as? IrRawFunctionReference diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/MonitorInstruction.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/MonitorInstruction.kt index ffcdaaadf77..3f5cd41b849 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/MonitorInstruction.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/MonitorInstruction.kt @@ -16,9 +16,8 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression import org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature import org.jetbrains.org.objectweb.asm.Opcodes @@ -33,8 +32,8 @@ class MonitorInstruction private constructor(private val opcode: Int) : Intrinsi } /*TODO void return type*/ - override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, context: JvmBackendContext): IrIntrinsicFunction { - return IrIntrinsicFunction.create(expression, signature, context, OBJECT_TYPE) { + override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen): IrIntrinsicFunction { + return IrIntrinsicFunction.create(expression, signature, classCodegen, OBJECT_TYPE) { it.visitInsn(opcode) } } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/NumberCast.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/NumberCast.kt index 9bf50c624b1..4024d00b51a 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/NumberCast.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/NumberCast.kt @@ -16,16 +16,15 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.codegen.StackValue import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature object NumberCast : IntrinsicMethod() { - override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, context: JvmBackendContext): IrIntrinsicFunction { - return IrIntrinsicFunction.create(expression, signature, context) { + override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen): IrIntrinsicFunction { + return IrIntrinsicFunction.create(expression, signature, classCodegen) { StackValue.coerce(argsTypes[0], signature.returnType, it) } } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeTo.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeTo.kt index 69fb6401712..4ce1014fe67 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeTo.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeTo.kt @@ -5,21 +5,21 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.backend.jvm.codegen.BlockInfo +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.backend.jvm.codegen.ExpressionCodegen import org.jetbrains.kotlin.codegen.StackValue import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature -import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter import org.jetbrains.org.objectweb.asm.Type +import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter object RangeTo : IntrinsicMethod() { override fun toCallable( - expression: IrFunctionAccessExpression, signature: JvmMethodSignature, context: JvmBackendContext + expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen ): IrIntrinsicFunction { val argType = mapRangeTypeToPrimitiveType(signature.returnType) - return object : IrIntrinsicFunction(expression, signature, context, listOf(argType) + signature.valueParameters.map { argType }) { + return object : IrIntrinsicFunction(expression, signature, classCodegen, listOf(argType) + signature.valueParameters.map { argType }) { override fun genInvokeInstruction(v: InstructionAdapter) { v.invokespecial( signature.returnType.internalName, diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeUntil.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeUntil.kt index aa2bc1039d3..a49833a942d 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeUntil.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/RangeUntil.kt @@ -5,17 +5,17 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature -import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter import org.jetbrains.org.objectweb.asm.Type +import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter object RangeUntil : IntrinsicMethod() { override fun toCallable( - expression: IrFunctionAccessExpression, signature: JvmMethodSignature, context: JvmBackendContext + expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen ): IrIntrinsicFunction { - return object : IrIntrinsicFunction(expression, signature, context) { + return object : IrIntrinsicFunction(expression, signature, classCodegen) { override fun genInvokeInstruction(v: InstructionAdapter) { v.invokestatic( "kotlin/ranges/RangesKt", "until", diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/SignatureString.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/SignatureString.kt index 7f1247e3ed7..1bd8897f3a1 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/SignatureString.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/SignatureString.kt @@ -5,11 +5,7 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext -import org.jetbrains.kotlin.backend.jvm.codegen.BlockInfo -import org.jetbrains.kotlin.backend.jvm.codegen.ExpressionCodegen -import org.jetbrains.kotlin.backend.jvm.codegen.MaterialValue -import org.jetbrains.kotlin.backend.jvm.codegen.PromisedValue +import org.jetbrains.kotlin.backend.jvm.codegen.* import org.jetbrains.kotlin.ir.declarations.IrFunction import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression @@ -26,16 +22,16 @@ import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter object SignatureString : IntrinsicMethod() { override fun invoke(expression: IrFunctionAccessExpression, codegen: ExpressionCodegen, data: BlockInfo): PromisedValue { val function = (expression.getValueArgument(0) as IrFunctionReference).symbol.owner - generateSignatureString(codegen.mv, function, codegen.context) + generateSignatureString(codegen.mv, function, codegen.classCodegen) return MaterialValue(codegen, AsmTypes.JAVA_STRING_TYPE, codegen.context.irBuiltIns.stringType) } - internal fun generateSignatureString(v: InstructionAdapter, function: IrFunction, context: JvmBackendContext) { + internal fun generateSignatureString(v: InstructionAdapter, function: IrFunction, codegen: ClassCodegen) { var resolved = if (function is IrSimpleFunction) function.collectRealOverrides().first() else function if (resolved.isSuspend) { - resolved = context.suspendFunctionOriginalToView[resolved] ?: resolved + resolved = codegen.context.suspendFunctionOriginalToView[resolved] ?: resolved } - val method = context.methodSignatureMapper.mapAsmMethod(resolved) + val method = codegen.methodSignatureMapper.mapAsmMethod(resolved) val descriptor = method.name + method.descriptor v.aconst(descriptor) } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/StringGetChar.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/StringGetChar.kt index 73f772e2a08..6912c006a8a 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/StringGetChar.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/StringGetChar.kt @@ -16,14 +16,13 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature object StringGetChar : IntrinsicMethod() { - override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, context: JvmBackendContext): IrIntrinsicFunction { - return IrIntrinsicFunction.create(expression, signature, context) { + override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen): IrIntrinsicFunction { + return IrIntrinsicFunction.create(expression, signature, classCodegen) { it.invokevirtual("java/lang/String", "charAt", "(I)C", false) } } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/StringPlus.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/StringPlus.kt index 92b081ba441..22196d61998 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/StringPlus.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/StringPlus.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicMethods import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression import org.jetbrains.kotlin.resolve.jvm.AsmTypes @@ -17,9 +17,9 @@ object StringPlus : IntrinsicMethod() { override fun toCallable( expression: IrFunctionAccessExpression, signature: JvmMethodSignature, - context: JvmBackendContext + classCodegen: ClassCodegen ): IrIntrinsicFunction = - IrIntrinsicFunction.create(expression, signature, context, listOf(AsmTypes.JAVA_STRING_TYPE, AsmTypes.OBJECT_TYPE)) { + IrIntrinsicFunction.create(expression, signature, classCodegen, listOf(AsmTypes.JAVA_STRING_TYPE, AsmTypes.OBJECT_TYPE)) { it.invokestatic( IntrinsicMethods.INTRINSICS_CLASS_NAME, "stringPlus", diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ThrowKotlinNothingValueException.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ThrowKotlinNothingValueException.kt index 3d30cadbbf8..219a3f64841 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ThrowKotlinNothingValueException.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/ThrowKotlinNothingValueException.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature import org.jetbrains.org.objectweb.asm.Type @@ -14,10 +14,10 @@ object ThrowKotlinNothingValueException : IntrinsicMethod() { override fun toCallable( expression: IrFunctionAccessExpression, signature: JvmMethodSignature, - context: JvmBackendContext + classCodegen: ClassCodegen ): IrIntrinsicFunction = - IrIntrinsicFunction.create(expression, signature, context) { mv -> - if (context.state.useKotlinNothingValueException) { + IrIntrinsicFunction.create(expression, signature, classCodegen) { mv -> + if (classCodegen.context.state.useKotlinNothingValueException) { mv.anew(Type.getObjectType("kotlin/KotlinNothingValueException")) mv.dup() mv.invokespecial("kotlin/KotlinNothingValueException", "", "()V", false) diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/TypeOf.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/TypeOf.kt index 3c2f4a84910..62e1165f020 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/TypeOf.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/TypeOf.kt @@ -20,7 +20,7 @@ object TypeOf : IntrinsicMethod() { if (putReifiedOperationMarkerIfTypeIsReifiedParameter(type, ReifiedTypeInliner.OperationKind.TYPE_OF)) { mv.aconst(null) // see ReifiedTypeInliner.processTypeOf } else { - val support = IrInlineIntrinsicsSupport(context, typeMapper, expression, codegen.irFunction.fileParent) + val support = IrInlineIntrinsicsSupport(codegen.classCodegen, expression, codegen.irFunction.fileParent) typeMapper.typeSystem.generateTypeOf(mv, type, support) } expression.onStack diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnaryMinus.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnaryMinus.kt index fecf1ffd591..3af8a2b08a4 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnaryMinus.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnaryMinus.kt @@ -16,17 +16,15 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.codegen.AsmUtil.numberFunctionOperandType -import org.jetbrains.kotlin.ir.expressions.IrCall import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature object UnaryMinus : IntrinsicMethod() { /*TODO return type*/ - override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, context: JvmBackendContext): IrIntrinsicFunction { - return IrIntrinsicFunction.create(expression, signature, context) { + override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen): IrIntrinsicFunction { + return IrIntrinsicFunction.create(expression, signature, classCodegen) { it.neg(numberFunctionOperandType(signature.returnType)) } } diff --git a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnaryPlus.kt b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnaryPlus.kt index 499b25c58fb..172b263887d 100644 --- a/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnaryPlus.kt +++ b/compiler/ir/backend.jvm/codegen/src/org/jetbrains/kotlin/backend/jvm/intrinsics/UnaryPlus.kt @@ -16,14 +16,13 @@ package org.jetbrains.kotlin.backend.jvm.intrinsics -import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen import org.jetbrains.kotlin.ir.expressions.IrFunctionAccessExpression -import org.jetbrains.kotlin.ir.expressions.IrMemberAccessExpression import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature object UnaryPlus : IntrinsicMethod() { - override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, context: JvmBackendContext): IrIntrinsicFunction { - return IrIntrinsicFunction.create(expression, signature, context) { + override fun toCallable(expression: IrFunctionAccessExpression, signature: JvmMethodSignature, classCodegen: ClassCodegen): IrIntrinsicFunction { + return IrIntrinsicFunction.create(expression, signature, classCodegen) { } } diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/AddContinuationLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/AddContinuationLowering.kt index bdf4bd0e6b1..de1ada4fd44 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/AddContinuationLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/AddContinuationLowering.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.backend.jvm.lower import org.jetbrains.kotlin.backend.common.FileLoweringPass -import org.jetbrains.kotlin.backend.common.ir.* +import org.jetbrains.kotlin.backend.common.ir.moveBodyTo import org.jetbrains.kotlin.backend.common.lower.LocalDeclarationsLowering import org.jetbrains.kotlin.backend.common.lower.createIrBuilder import org.jetbrains.kotlin.backend.common.peek @@ -328,7 +328,7 @@ private class AddContinuationLowering(context: JvmBackendContext) : SuspendLower if (flag.capturesCrossinline || function.isInline) { result += context.irFactory.buildFun { containerSource = view.containerSource - name = Name.identifier(context.methodSignatureMapper.mapFunctionName(view) + FOR_INLINE_SUFFIX) + name = Name.identifier(context.defaultMethodSignatureMapper.mapFunctionName(view) + FOR_INLINE_SUFFIX) returnType = view.returnType modality = view.modality isSuspend = view.isSuspend diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt index 30bd4401529..eb099727bfe 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/BridgeLowering.kt @@ -11,7 +11,9 @@ import org.jetbrains.kotlin.backend.common.lower.VariableRemapper import org.jetbrains.kotlin.backend.common.lower.createIrBuilder import org.jetbrains.kotlin.backend.common.lower.irNot import org.jetbrains.kotlin.backend.common.phaser.makeIrFilePhase -import org.jetbrains.kotlin.backend.jvm.* +import org.jetbrains.kotlin.backend.jvm.JvmBackendContext +import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin +import org.jetbrains.kotlin.backend.jvm.SpecialBridge import org.jetbrains.kotlin.backend.jvm.ir.* import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.descriptors.DescriptorVisibilities @@ -143,7 +145,7 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass // We should rewrite this static replacement as well ('remove' function itself is handled during special bridge processing). val remove = declaration.functions.find { val original = context.inlineClassReplacements.originalFunctionForStaticReplacement[it] - original != null && context.methodSignatureMapper.shouldBoxSingleValueParameterForSpecialCaseOfRemove(original) + original != null && context.defaultMethodSignatureMapper.shouldBoxSingleValueParameterForSpecialCaseOfRemove(original) } if (remove != null) { makeLastParameterNullable(remove) @@ -389,7 +391,7 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass // List of special bridge methods which were not implemented in Kotlin superclasses. private fun IrSimpleFunction.overriddenSpecialBridges(): List { - val targetJvmMethod = context.methodSignatureMapper.mapCalleeToAsmMethod(this) + val targetJvmMethod = context.defaultMethodSignatureMapper.mapCalleeToAsmMethod(this) return allOverridden() .filter { it.parentAsClass.isInterface || it.isFromJava() } .mapNotNull { it.specialBridgeOrNull } @@ -498,7 +500,7 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass overriddenSymbols = listOf(specialBridge.overridden.symbol) } - if (context.methodSignatureMapper.shouldBoxSingleValueParameterForSpecialCaseOfRemove(this)) { + if (context.defaultMethodSignatureMapper.shouldBoxSingleValueParameterForSpecialCaseOfRemove(this)) { makeLastParameterNullable(this) } } @@ -549,7 +551,7 @@ internal class BridgeLowering(val context: JvmBackendContext) : FileLoweringPass // If the signature of this method will be changed in the output to take a boxed argument instead of a primitive, // rewrite the argument so that code will be generated for a boxed argument and not a primitive. valueParameters = valueParameters.mapIndexed { i, p -> - if (AsmUtil.isPrimitive(context.typeMapper.mapType(p.type)) && ourSignature.argumentTypes[i].sort == Type.OBJECT) { + if (AsmUtil.isPrimitive(context.defaultTypeMapper.mapType(p.type)) && ourSignature.argumentTypes[i].sort == Type.OBJECT) { val newParameter = p.copyTo(this, type = p.type.makeNullable()) variableMap[p] = newParameter newParameter diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/CollectionStubMethodLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/CollectionStubMethodLowering.kt index 4e1fc6a9d3c..d620aaf8f40 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/CollectionStubMethodLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/CollectionStubMethodLowering.kt @@ -155,7 +155,7 @@ internal class CollectionStubMethodLowering(val context: JvmBackendContext) : Cl } private fun IrSimpleFunction.toJvmSignature(): String = - context.methodSignatureMapper.mapAsmMethod(this).toString() + context.defaultMethodSignatureMapper.mapAsmMethod(this).toString() private fun createStubMethod( function: IrSimpleFunction, diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FakeInliningLocalVariablesLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FakeInliningLocalVariablesLowering.kt index 784dccdd3f2..f3265da743b 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FakeInliningLocalVariablesLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/FakeInliningLocalVariablesLowering.kt @@ -37,7 +37,7 @@ internal class FakeInliningLocalVariablesLowering(val context: JvmBackendContext override fun visitFunction(declaration: IrFunction, data: IrDeclaration?) { super.visitFunction(declaration, data) if (declaration.isInline && !declaration.origin.isSynthetic && declaration.body != null && !declaration.isInlineOnly()) { - val currentFunctionName = context.methodSignatureMapper.mapFunctionName(declaration) + val currentFunctionName = context.defaultMethodSignatureMapper.mapFunctionName(declaration) val localName = "${JvmAbi.LOCAL_VARIABLE_NAME_PREFIX_INLINE_FUNCTION}$currentFunctionName" declaration.addFakeLocalVariable(localName) } @@ -45,7 +45,7 @@ internal class FakeInliningLocalVariablesLowering(val context: JvmBackendContext override fun visitInlineLambda(argument: IrFunctionReference, callee: IrFunction, parameter: IrValueParameter, scope: IrDeclaration) { val lambda = argument.symbol.owner - val argumentToFunctionName = context.methodSignatureMapper.mapFunctionName(callee) + val argumentToFunctionName = context.defaultMethodSignatureMapper.mapFunctionName(callee) val lambdaReferenceName = context.getLocalClassType(argument)!!.internalName.substringAfterLast("/") val localName = "${JvmAbi.LOCAL_VARIABLE_NAME_PREFIX_INLINE_ARGUMENT}-$argumentToFunctionName-$lambdaReferenceName" lambda.addFakeLocalVariable(localName) diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmBuiltInsLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmBuiltInsLowering.kt index 4915fd91b50..07a8caff4fe 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmBuiltInsLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmBuiltInsLowering.kt @@ -17,7 +17,9 @@ import org.jetbrains.kotlin.ir.expressions.IrCall import org.jetbrains.kotlin.ir.expressions.IrExpression import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol -import org.jetbrains.kotlin.ir.types.* +import org.jetbrains.kotlin.ir.types.IrType +import org.jetbrains.kotlin.ir.types.isInt +import org.jetbrains.kotlin.ir.types.isLong import org.jetbrains.kotlin.ir.util.dump import org.jetbrains.kotlin.ir.util.fqNameForIrSerialization import org.jetbrains.kotlin.ir.util.render @@ -113,8 +115,8 @@ class JvmBuiltInsLowering(val context: JvmBackendContext) : FileLoweringPass { private fun IrExpression.coerceIfPossible(toType: IrType): IrExpression? { // TODO maybe UnsafeCoerce could handle types with different, but coercible underlying representations. // See KT-43286 and related tests for details. - val fromJvmType = context.typeMapper.mapType(type) - val toJvmType = context.typeMapper.mapType(toType) + val fromJvmType = context.defaultTypeMapper.mapType(type) + val toJvmType = context.defaultTypeMapper.mapType(toType) return if (fromJvmType != toJvmType) null else diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmPropertiesLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmPropertiesLowering.kt index b3ef7cd3d8b..71f054ba1ba 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmPropertiesLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/JvmPropertiesLowering.kt @@ -29,7 +29,10 @@ import org.jetbrains.kotlin.ir.expressions.IrExpression import org.jetbrains.kotlin.ir.expressions.IrFieldAccessExpression import org.jetbrains.kotlin.ir.expressions.impl.IrBlockBodyImpl import org.jetbrains.kotlin.ir.expressions.impl.IrGetFieldImpl -import org.jetbrains.kotlin.ir.types.* +import org.jetbrains.kotlin.ir.types.IrType +import org.jetbrains.kotlin.ir.types.classifierOrNull +import org.jetbrains.kotlin.ir.types.isSubtypeOfClass +import org.jetbrains.kotlin.ir.types.makeNullable import org.jetbrains.kotlin.ir.util.* import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid import org.jetbrains.kotlin.load.java.JvmAbi @@ -222,7 +225,7 @@ class JvmPropertiesLowering(private val backendContext: JvmBackendContext) : IrE getter.extensionReceiverParameter?.type?.requiresMangling == true || (state.functionsWithInlineClassReturnTypesMangled && getter.hasMangledReturnType) val mangled = if (needsMangling) inlineClassReplacements.getReplacementFunction(getter) else null - methodSignatureMapper.mapFunctionName(mangled ?: getter) + defaultMethodSignatureMapper.mapFunctionName(mangled ?: getter) } else JvmAbi.getterName(property.name.asString()) } else { property.name.asString() diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt index 44f90c5388a..a151cd54adb 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/PropertyReferenceLowering.kt @@ -93,7 +93,7 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : IrEle // Plain Java fields do not have a getter, but can be referenced nonetheless. The signature should be the one // that a getter would have, if it existed. private val IrField.fakeGetterSignature: String - get() = "${JvmAbi.getterName(name.asString())}()${context.methodSignatureMapper.mapReturnType(this)}" + get() = "${JvmAbi.getterName(name.asString())}()${context.defaultMethodSignatureMapper.mapReturnType(this)}" private fun IrBuilderWithScope.computeSignatureString(expression: IrMemberAccessExpression<*>): IrExpression { if (expression is IrLocalDelegatedPropertyReference) { @@ -262,7 +262,7 @@ internal class PropertyReferenceLowering(val context: JvmBackendContext) : IrEle parentClassId?.let { containerId -> // This function was imported from a jar. Didn't run the inline class lowering yet though - have to map manually. val replaced = context.inlineClassReplacements.getReplacementFunction(this) ?: this - val signature = context.methodSignatureMapper.mapSignatureSkipGeneric(replaced) + val signature = context.defaultMethodSignatureMapper.mapSignatureSkipGeneric(replaced) val localIndex = signature.valueParameters.take(index + if (replaced.extensionReceiverParameter != null) 1 else 0) .sumOf { it.asmType.size } + (if (replaced.dispatchReceiverParameter != null) 1 else 0) // Null checks are removed during inlining, so we can ignore them. diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/ReflectiveAccess.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/ReflectiveAccess.kt index 1cde05f3b5e..c864d6846a4 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/ReflectiveAccess.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/ReflectiveAccess.kt @@ -14,7 +14,8 @@ import org.jetbrains.kotlin.backend.jvm.ir.* import org.jetbrains.kotlin.backend.jvm.lower.SyntheticAccessorLowering.Companion.isAccessible import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET import org.jetbrains.kotlin.ir.builders.* -import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.declarations.IrFile +import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.expressions.impl.IrClassReferenceImpl import org.jetbrains.kotlin.ir.symbols.IrClassSymbol @@ -511,7 +512,7 @@ internal class ReflectiveAccessLowering( // invokespecial via JDI from which it *is* possible to do the required // super call. private fun generateInvokeSpecialForCall(expression: IrCall, superQualifier: IrClassSymbol): IrExpression { - val jvmSignature = context.methodSignatureMapper.mapSignatureSkipGeneric(expression.symbol.owner) + val jvmSignature = context.defaultMethodSignatureMapper.mapSignatureSkipGeneric(expression.symbol.owner) val owner = superQualifier.owner val builder = context.createJvmIrBuilder(expression.symbol) diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SuspendLambdaLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SuspendLambdaLowering.kt index 7ffbbb247cd..4b28eb979d4 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SuspendLambdaLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SuspendLambdaLowering.kt @@ -177,7 +177,7 @@ private class SuspendLambdaLowering(context: JvmBackendContext) : SuspendLowerin val parametersFields = function.explicitParameters.map { val field = if (it in usedParams) addField { - val normalizedType = context.typeMapper.mapType(it.type).normalize() + val normalizedType = context.defaultTypeMapper.mapType(it.type).normalize() val index = varsCountByType[normalizedType]?.plus(1) ?: 0 varsCountByType[normalizedType] = index // Rename `$this` to avoid being caught by inlineCodegenUtils.isCapturedFieldName() diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt index 883ee516ddf..95fb7ccdf76 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt @@ -9,7 +9,6 @@ import org.jetbrains.kotlin.backend.common.FileLoweringPass import org.jetbrains.kotlin.backend.common.IrElementTransformerVoidWithContext import org.jetbrains.kotlin.backend.common.ScopeWithIr import org.jetbrains.kotlin.backend.common.descriptors.synthesizedString -import org.jetbrains.kotlin.backend.common.ir.* import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin import org.jetbrains.kotlin.backend.jvm.hasMangledParameters @@ -711,7 +710,7 @@ private class SyntheticAccessorTransformer( } private fun IrSimpleFunction.accessorName(superQualifier: IrClassSymbol?): Name { - val jvmName = context.methodSignatureMapper.mapFunctionName(this) + val jvmName = context.defaultMethodSignatureMapper.mapFunctionName(this) val suffix = when { // Accessors for top level functions never need a suffix. isTopLevel -> "" diff --git a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/TypeOperatorLowering.kt b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/TypeOperatorLowering.kt index 8aeb64dc045..add680a7006 100644 --- a/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/TypeOperatorLowering.kt +++ b/compiler/ir/backend.jvm/lower/src/org/jetbrains/kotlin/backend/jvm/lower/TypeOperatorLowering.kt @@ -350,9 +350,9 @@ private class TypeOperatorLowering(private val backendContext: JvmBackendContext private fun mapDeserializedLambda(info: SerializableMethodRefInfo) = DeserializedLambdaInfo( - functionalInterfaceClass = backendContext.typeMapper.mapType(info.samType).internalName, - implMethodHandle = backendContext.methodSignatureMapper.mapToMethodHandle(info.implFunSymbol.owner), - functionalInterfaceMethod = backendContext.methodSignatureMapper.mapAsmMethod(info.samMethodSymbol.owner) + functionalInterfaceClass = backendContext.defaultTypeMapper.mapType(info.samType).internalName, + implMethodHandle = backendContext.defaultMethodSignatureMapper.mapToMethodHandle(info.implFunSymbol.owner), + functionalInterfaceMethod = backendContext.defaultMethodSignatureMapper.mapAsmMethod(info.samMethodSymbol.owner) ) private fun JvmIrBuilder.generateSerializedLambdaEquals( @@ -569,12 +569,12 @@ private class TypeOperatorLowering(private val backendContext: JvmBackendContext samMethod: IrSimpleFunction, extraOverriddenMethods: List ): Collection { - val jvmInstanceMethod = backendContext.methodSignatureMapper.mapAsmMethod(instanceMethod) - val jvmSamMethod = backendContext.methodSignatureMapper.mapAsmMethod(samMethod) + val jvmInstanceMethod = backendContext.defaultMethodSignatureMapper.mapAsmMethod(instanceMethod) + val jvmSamMethod = backendContext.defaultMethodSignatureMapper.mapAsmMethod(samMethod) val signatureToNonFakeOverride = LinkedHashMap() for (overridden in extraOverriddenMethods) { - val jvmOverriddenMethod = backendContext.methodSignatureMapper.mapAsmMethod(overridden) + val jvmOverriddenMethod = backendContext.defaultMethodSignatureMapper.mapAsmMethod(overridden) if (jvmOverriddenMethod != jvmInstanceMethod && jvmOverriddenMethod != jvmSamMethod) { signatureToNonFakeOverride[jvmOverriddenMethod] = overridden } 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 0e792a5fd58..f7e30397a81 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 @@ -71,8 +71,8 @@ class JvmBackendContext( override val builtIns = state.module.builtIns override val typeSystem: IrTypeSystemContext = JvmIrTypeSystemContext(irBuiltIns) - val typeMapper = IrTypeMapper(this) - val methodSignatureMapper = MethodSignatureMapper(this) + val defaultTypeMapper = IrTypeMapper(this) + val defaultMethodSignatureMapper = MethodSignatureMapper(this, defaultTypeMapper) val innerClassesSupport = JvmInnerClassesSupport(irFactory) val cachedDeclarations = JvmCachedDeclarations( @@ -153,7 +153,7 @@ class JvmBackendContext( init { state.mapInlineClass = { descriptor -> - typeMapper.mapType(referenceClass(descriptor).defaultType) + defaultTypeMapper.mapType(referenceClass(descriptor).defaultType) } } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmCachedDeclarations.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmCachedDeclarations.kt index ca117002c54..0ee749810f4 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmCachedDeclarations.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmCachedDeclarations.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.backend.jvm -import org.jetbrains.kotlin.backend.common.ir.* import org.jetbrains.kotlin.backend.common.lower.createIrBuilder import org.jetbrains.kotlin.backend.jvm.ir.copyCorrespondingPropertyFrom import org.jetbrains.kotlin.backend.jvm.ir.createJvmIrBuilder @@ -135,7 +134,7 @@ class JvmCachedDeclarations( // The proxy needs to have the same name as what it is targeting. If that is a property accessor, // we need to make sure that the name is mapped correctly. The static method is not a property accessor, // so we do not have a property to link it up to. Therefore, we compute the right name now. - name = Name.identifier(context.methodSignatureMapper.mapFunctionName(target)) + name = Name.identifier(context.defaultMethodSignatureMapper.mapFunctionName(target)) modality = if (isInterface) Modality.OPEN else target.modality // Since we already mangle the name above we need to reset internal visibilities to public in order // to avoid mangling the same name twice. diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/caches/BridgeLoweringCache.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/caches/BridgeLoweringCache.kt index 2c1c2df662f..32cf484662f 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/caches/BridgeLoweringCache.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/caches/BridgeLoweringCache.kt @@ -28,7 +28,7 @@ class BridgeLoweringCache(private val context: JvmBackendContext) { private val signatureCache = ConcurrentHashMap() fun computeJvmMethod(function: IrFunction): Method = - signatureCache.getOrPut(function.symbol) { context.methodSignatureMapper.mapAsmMethod(function) } + signatureCache.getOrPut(function.symbol) { context.defaultMethodSignatureMapper.mapAsmMethod(function) } private fun canHaveSpecialBridge(function: IrSimpleFunction): Boolean { if (function.name in specialBridgeMethods.specialMethodNames) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrUtils.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrUtils.kt index d15d485a0c7..1dbbb512852 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrUtils.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/ir/JvmIrUtils.kt @@ -67,9 +67,9 @@ import org.jetbrains.kotlin.resolve.jvm.AsmTypes import org.jetbrains.kotlin.resolve.multiplatform.OptionalAnnotationUtil import org.jetbrains.kotlin.resolve.source.PsiSourceElement import org.jetbrains.kotlin.utils.DFS -import java.io.File import org.jetbrains.org.objectweb.asm.Type import org.jetbrains.org.objectweb.asm.commons.Method +import java.io.File fun IrDeclaration.getJvmNameFromAnnotation(): String? { // TODO lower @JvmName? @@ -481,7 +481,7 @@ fun IrFunctionAccessExpression.receiverAndArgs(): List { } fun classFileContainsMethod(classId: ClassId, function: IrFunction, context: JvmBackendContext): Boolean? { - val originalSignature = context.methodSignatureMapper.mapAsmMethod(function) + val originalSignature = context.defaultMethodSignatureMapper.mapAsmMethod(function) val originalDescriptor = originalSignature.descriptor val descriptor = if (function.isSuspend) listOf(*Type.getArgumentTypes(originalDescriptor), Type.getObjectType("kotlin/coroutines/Continuation")) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/IrTypeMapper.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/IrTypeMapper.kt index 3a51b87ca8c..60590c95412 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/IrTypeMapper.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/IrTypeMapper.kt @@ -37,7 +37,7 @@ import org.jetbrains.kotlin.backend.jvm.ir.isRawType as isRawTypeImpl import org.jetbrains.kotlin.ir.types.isKClass as isKClassImpl import org.jetbrains.kotlin.ir.util.isSuspendFunction as isSuspendFunctionImpl -class IrTypeMapper(private val context: JvmBackendContext) : KotlinTypeMapperBase(), TypeMappingContext { +open class IrTypeMapper(private val context: JvmBackendContext) : KotlinTypeMapperBase(), TypeMappingContext { override val typeSystem: IrTypeSystemContext = context.typeSystem override val typeContext: TypeSystemCommonBackendContextForTypeMapping = IrTypeCheckerContextForTypeMapping(typeSystem, context) @@ -125,7 +125,7 @@ class IrTypeMapper(private val context: JvmBackendContext) : KotlinTypeMapperBas return AsmUtil.boxPrimitiveType(type) ?: type } - fun mapType( + open fun mapType( type: IrType, mode: TypeMappingMode = TypeMappingMode.DEFAULT, sw: JvmSignatureWriter? = null diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/MethodSignatureMapper.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/MethodSignatureMapper.kt index 60678d85d0b..71cad44385f 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/MethodSignatureMapper.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/mapping/MethodSignatureMapper.kt @@ -47,8 +47,7 @@ import org.jetbrains.org.objectweb.asm.Opcodes import org.jetbrains.org.objectweb.asm.Type import org.jetbrains.org.objectweb.asm.commons.Method -class MethodSignatureMapper(private val context: JvmBackendContext) { - private val typeMapper: IrTypeMapper = context.typeMapper +class MethodSignatureMapper(private val context: JvmBackendContext, private val typeMapper: IrTypeMapper) { private val typeSystem: IrTypeSystemContext = typeMapper.typeSystem fun mapAsmMethod(function: IrFunction): Method = diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/metadata/DescriptorMetadataSerializer.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/metadata/DescriptorMetadataSerializer.kt index c0b89f942fc..1053a784d80 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/metadata/DescriptorMetadataSerializer.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/metadata/DescriptorMetadataSerializer.kt @@ -31,7 +31,7 @@ class DescriptorMetadataSerializer( private val serializationBindings: JvmSerializationBindings, parent: MetadataSerializer? ) : MetadataSerializer { - private val serializerExtension = JvmSerializerExtension(serializationBindings, context.state, context.typeMapper) + private val serializerExtension = JvmSerializerExtension(serializationBindings, context.state, context.defaultTypeMapper) private val serializer: DescriptorSerializer? = when (val metadata = irClass.metadata) { is DescriptorMetadataSource.Class -> DescriptorSerializer.create( @@ -51,7 +51,7 @@ class DescriptorMetadataSerializer( context.state.bindingTrace.record( CodegenBinding.DELEGATED_PROPERTIES_WITH_METADATA, // key for local delegated properties metadata in interfaces depends on jvmDefaultMode - if (irClass.isInterface && !context.state.jvmDefaultMode.forAllMethodsWithBody) context.typeMapper.mapClass( + if (irClass.isInterface && !context.state.jvmDefaultMode.forAllMethodsWithBody) context.defaultTypeMapper.mapClass( context.cachedDeclarations.getDefaultImplsClass( irClass ) diff --git a/compiler/testData/codegen/box/coroutines/bridges/lambdaWithLongReceiver_ir.txt b/compiler/testData/codegen/box/coroutines/bridges/lambdaWithLongReceiver_ir.txt index 15e55a96663..7d2959927fa 100644 --- a/compiler/testData/codegen/box/coroutines/bridges/lambdaWithLongReceiver_ir.txt +++ b/compiler/testData/codegen/box/coroutines/bridges/lambdaWithLongReceiver_ir.txt @@ -29,6 +29,7 @@ final class LambdaWithLongReceiverKt$box$1 { 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 + public final inner class kotlin/jvm/internal/Ref$ObjectRef } @kotlin.Metadata @@ -38,4 +39,5 @@ public final class LambdaWithLongReceiverKt { public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void public final static @org.jetbrains.annotations.Nullable method call(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object + public final inner class kotlin/jvm/internal/Ref$ObjectRef } diff --git a/compiler/testData/codegen/box/coroutines/bridges/lambdaWithMultipleParameters_ir.txt b/compiler/testData/codegen/box/coroutines/bridges/lambdaWithMultipleParameters_ir.txt index 4d64ec4f837..4eaf47f75cb 100644 --- a/compiler/testData/codegen/box/coroutines/bridges/lambdaWithMultipleParameters_ir.txt +++ b/compiler/testData/codegen/box/coroutines/bridges/lambdaWithMultipleParameters_ir.txt @@ -33,6 +33,7 @@ final class LambdaWithMultipleParametersKt$box$1 { 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 + public final inner class kotlin/jvm/internal/Ref$ObjectRef } @kotlin.Metadata @@ -42,4 +43,5 @@ public final class LambdaWithMultipleParametersKt { public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void public final static @org.jetbrains.annotations.Nullable method call(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function7, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object + public final inner class kotlin/jvm/internal/Ref$ObjectRef } diff --git a/compiler/testData/codegen/box/coroutines/suspendConversion/onInlineArgument_ir.txt b/compiler/testData/codegen/box/coroutines/suspendConversion/onInlineArgument_ir.txt index 6c9913ff606..84cadf5699f 100644 --- a/compiler/testData/codegen/box/coroutines/suspendConversion/onInlineArgument_ir.txt +++ b/compiler/testData/codegen/box/coroutines/suspendConversion/onInlineArgument_ir.txt @@ -12,6 +12,7 @@ final class OnInlineArgumentKt$box$1 { 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 + public final inner class kotlin/jvm/internal/Ref$ObjectRef } @kotlin.Metadata @@ -34,4 +35,5 @@ public final class OnInlineArgumentKt { public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String private final static method runS$$forInline(p0: kotlin.jvm.functions.Function2, p1: kotlin.coroutines.Continuation): java.lang.Object public final static @org.jetbrains.annotations.Nullable method runS(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function2, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object + public final inner class kotlin/jvm/internal/Ref$ObjectRef } diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/crossinline_ir.txt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/crossinline_ir.txt index 484144cd642..315438a711b 100644 --- a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/crossinline_ir.txt +++ b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/crossinline_ir.txt @@ -61,6 +61,8 @@ final class CrossinlineKt$box$1 { 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 + public final inner class SourceCrossinline$Factory + public final inner class kotlin/jvm/internal/Ref$IntRef } @kotlin.Metadata @@ -260,6 +262,9 @@ public final class CrossinlineKt { public final static method isGood(p0: int): boolean public final static @org.jetbrains.annotations.NotNull method range(@org.jetbrains.annotations.NotNull p0: SourceCrossinline$Factory, p1: int, p2: int): SourceCrossinline public final static @org.jetbrains.annotations.NotNull method source(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function2): SourceCrossinline + public final inner class SourceCrossinline$Factory + public final inner class kotlin/jvm/internal/Ref$IntRef + public final inner class kotlin/jvm/internal/Ref$ObjectRef } @kotlin.Metadata diff --git a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithoutStateMachine_ir.txt b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithoutStateMachine_ir.txt index 610d4ca8533..ef929acba89 100644 --- a/compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithoutStateMachine_ir.txt +++ b/compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithoutStateMachine_ir.txt @@ -13,6 +13,7 @@ final class InlineWithoutStateMachineKt$box$1 { 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 + public final inner class kotlin/jvm/internal/Ref$ObjectRef } @kotlin.Metadata @@ -25,4 +26,5 @@ public final class InlineWithoutStateMachineKt { public final static @org.jetbrains.annotations.Nullable method suspendHere(@org.jetbrains.annotations.NotNull p0: kotlin.coroutines.Continuation): java.lang.Object private final static method suspendThere$$forInline(p0: java.lang.String, p1: kotlin.coroutines.Continuation): java.lang.Object public final static @org.jetbrains.annotations.Nullable method suspendThere(@org.jetbrains.annotations.NotNull p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: kotlin.coroutines.Continuation): java.lang.Object + public final inner class kotlin/jvm/internal/Ref$ObjectRef } diff --git a/compiler/testData/codegen/box/dataClasses/kt49715_ir.txt b/compiler/testData/codegen/box/dataClasses/kt49715_ir.txt new file mode 100644 index 00000000000..87c09d4bb65 --- /dev/null +++ b/compiler/testData/codegen/box/dataClasses/kt49715_ir.txt @@ -0,0 +1,36 @@ +@kotlin.Metadata +public final class A$DefaultImpls { + // source: 'kt49715.kt' + public static @org.jetbrains.annotations.NotNull method toString(@org.jetbrains.annotations.NotNull p0: A, @org.jetbrains.annotations.NotNull p1: java.lang.Object): java.lang.String + public final inner class A$DefaultImpls +} + +@kotlin.Metadata +public interface A { + // source: 'kt49715.kt' + public abstract @org.jetbrains.annotations.NotNull method toString(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.String + public final inner class A$DefaultImpls +} + +@kotlin.Metadata +public final class B { + // source: 'kt49715.kt' + private final field x: int + public method (p0: int): void + public final method component1(): int + public synthetic static method copy$default(p0: B, p1: int, p2: int, p3: java.lang.Object): B + public final @org.jetbrains.annotations.NotNull method copy(p0: int): B + public method equals(@org.jetbrains.annotations.Nullable p0: java.lang.Object): boolean + public final method getX(): int + public method hashCode(): int + public final @org.jetbrains.annotations.NotNull method hi(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.String + public @org.jetbrains.annotations.NotNull method toString(): java.lang.String + public @org.jetbrains.annotations.NotNull method toString(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.String + public final inner class A$DefaultImpls +} + +@kotlin.Metadata +public final class Kt49715Kt { + // source: 'kt49715.kt' + public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String +} diff --git a/compiler/testData/codegen/box/delegatedProperty/delegateToSingleton/noInitializationOfOuterClass_ir.txt b/compiler/testData/codegen/box/delegatedProperty/delegateToSingleton/noInitializationOfOuterClass_ir.txt index f3bf2993ee4..73e50784613 100644 --- a/compiler/testData/codegen/box/delegatedProperty/delegateToSingleton/noInitializationOfOuterClass_ir.txt +++ b/compiler/testData/codegen/box/delegatedProperty/delegateToSingleton/noInitializationOfOuterClass_ir.txt @@ -7,6 +7,7 @@ public final class NoInitializationOfOuterClassKt { private static method getResult$delegate(): java.lang.Object public final static @org.jetbrains.annotations.NotNull method getResult(): java.lang.String public final static @org.jetbrains.annotations.NotNull method getValue(@org.jetbrains.annotations.NotNull p0: O$P, @org.jetbrains.annotations.Nullable p1: java.lang.Object, @org.jetbrains.annotations.Nullable p2: java.lang.Object): java.lang.String + public final inner class O$P } @kotlin.Metadata diff --git a/compiler/testData/codegen/box/delegatedProperty/delegateToThis/delegateToOuterThis_ir.txt b/compiler/testData/codegen/box/delegatedProperty/delegateToThis/delegateToOuterThis_ir.txt index ee60d3bc52b..9f7e388f4ba 100644 --- a/compiler/testData/codegen/box/delegatedProperty/delegateToThis/delegateToOuterThis_ir.txt +++ b/compiler/testData/codegen/box/delegatedProperty/delegateToThis/delegateToOuterThis_ir.txt @@ -2,6 +2,7 @@ public final class DelegateToOuterThisKt { // source: 'delegateToOuterThis.kt' public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String + public final inner class O$I } @kotlin.Metadata diff --git a/compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg_ir.txt b/compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg_ir.txt index 6283f7aee51..a6fb737cc92 100644 --- a/compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg_ir.txt +++ b/compiler/testData/codegen/box/jvm8/defaults/allCompatibility/privateFunWithDefaultArg_ir.txt @@ -20,6 +20,7 @@ final class Foo$bar$1 { 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 + public final inner class kotlin/jvm/internal/Ref$ObjectRef } @kotlin.Metadata @@ -34,6 +35,7 @@ public interface Foo { public synthetic static method fooSuspend$default(p0: Foo, p1: java.lang.String, p2: kotlin.coroutines.Continuation, p3: int, p4: java.lang.Object): java.lang.Object private method fooSuspend(p0: java.lang.String, p1: kotlin.coroutines.Continuation): java.lang.Object public final inner class Foo$DefaultImpls + public final inner class kotlin/jvm/internal/Ref$ObjectRef } @kotlin.Metadata diff --git a/compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg_ir.txt b/compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg_ir.txt index 48208ac8583..ffb057a242c 100644 --- a/compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg_ir.txt +++ b/compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/privateFunWithDefaultArg_ir.txt @@ -13,6 +13,7 @@ final class Foo$bar$1 { 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 + public final inner class kotlin/jvm/internal/Ref$ObjectRef } @kotlin.Metadata @@ -25,6 +26,7 @@ public interface Foo { private method foo(p0: java.lang.String): java.lang.String public synthetic static method fooSuspend$default(p0: Foo, p1: java.lang.String, p2: kotlin.coroutines.Continuation, p3: int, p4: java.lang.Object): java.lang.Object private method fooSuspend(p0: java.lang.String, p1: kotlin.coroutines.Continuation): java.lang.Object + public final inner class kotlin/jvm/internal/Ref$ObjectRef } @kotlin.Metadata diff --git a/compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/withCompatibility/suspend.txt b/compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/withCompatibility/suspend.txt index 616f1d4e14b..356711764c5 100644 --- a/compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/withCompatibility/suspend.txt +++ b/compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/withCompatibility/suspend.txt @@ -12,6 +12,7 @@ final class SuspendKt$box$1 { 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 + public final inner class kotlin/jvm/internal/Ref$ObjectRef } @kotlin.Metadata @@ -20,6 +21,7 @@ public final class SuspendKt { inner (anonymous) class SuspendKt$box$1 public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void + public final inner class kotlin/jvm/internal/Ref$ObjectRef } @kotlin.Metadata diff --git a/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/specialization_ir.txt b/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/specialization_ir.txt new file mode 100644 index 00000000000..00cd1261094 --- /dev/null +++ b/compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance/specialization_ir.txt @@ -0,0 +1,47 @@ +Module: lib +@kotlin.Metadata +public interface Foo { + // source: 'Foo.kt' + public method foo(p0: java.lang.Object): java.lang.Object +} + +@kotlin.Metadata +public interface Foo2 { + // source: 'Foo.kt' + public method foo(p0: java.lang.Object): java.lang.Object +} +Module: main +@kotlin.Metadata +public final class DerivedClass { + // source: 'main.kt' + public method (): void +} + +@kotlin.Metadata +public final class DerivedClassWithSpecialization { + // source: 'main.kt' + public method (): void + public @org.jetbrains.annotations.NotNull method foo(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String + public synthetic bridge method foo(p0: java.lang.Object): java.lang.Object + public final inner class DerivedInterface$DefaultImpls +} + +@kotlin.Metadata +public final class DerivedInterface$DefaultImpls { + // source: 'main.kt' + public static method foo(@org.jetbrains.annotations.NotNull p0: DerivedInterface, p1: java.lang.Object): java.lang.Object + public final inner class DerivedInterface$DefaultImpls +} + +@kotlin.Metadata +public interface DerivedInterface { + // source: 'main.kt' + public abstract method foo(p0: java.lang.Object): java.lang.Object + public final inner class DerivedInterface$DefaultImpls +} + +@kotlin.Metadata +public final class MainKt { + // source: 'main.kt' + public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String +} diff --git a/compiler/testData/codegen/bytecodeListing/accessorsForProtectedStaticJavaFieldInOtherPackage_ir.txt b/compiler/testData/codegen/bytecodeListing/accessorsForProtectedStaticJavaFieldInOtherPackage_ir.txt index d73bbae302a..e16f6a4806a 100644 --- a/compiler/testData/codegen/bytecodeListing/accessorsForProtectedStaticJavaFieldInOtherPackage_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/accessorsForProtectedStaticJavaFieldInOtherPackage_ir.txt @@ -34,6 +34,7 @@ public final class test/C { public synthetic final static method access$h$s66(): java.lang.String public final @org.jetbrains.annotations.NotNull method f(): java.lang.String public final @org.jetbrains.annotations.NotNull method g(): kotlin.jvm.functions.Function0 + public inner class A$B } @kotlin.Metadata diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractMapRedefiningGetAny_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractMapRedefiningGetAny_ir.txt index 255ef3c092d..e46725496d4 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractMapRedefiningGetAny_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractMapRedefiningGetAny_ir.txt @@ -20,4 +20,5 @@ public abstract class MindMap { public bridge final method remove(p0: java.lang.Object): java.lang.String public bridge final method size(): int public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/byteShortMap_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/byteShortMap_ir.txt index 313323c379f..e5dbc48f20f 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/byteShortMap_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/byteShortMap_ir.txt @@ -23,4 +23,5 @@ public abstract class method remove(p0: java.lang.Object): java.lang.Object public method remove(p0: java.lang.Object): java.lang.Short public bridge final method size(): int + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/byteShortMutableMap_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/byteShortMutableMap_ir.txt index df78d8877f5..f43fc755321 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/byteShortMutableMap_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/byteShortMutableMap_ir.txt @@ -20,4 +20,5 @@ public abstract class method remove(p0: java.lang.Object): java.lang.Object public bridge final method remove(p0: java.lang.Object): java.lang.Short public bridge final method size(): int + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericMap_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericMap_ir.txt index 42c14798f83..5db88b0ccb1 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericMap_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericMap_ir.txt @@ -14,4 +14,5 @@ public abstract class<Ljava/lang/Objec public abstract method getSize(): int public abstract method getValues(): java.util.Collection public bridge final method size(): int + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericMutableMap_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericMutableMap_ir.txt index ee7bfe4e075..1e91dd03b89 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericMutableMap_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericMutableMap_ir.txt @@ -10,4 +10,5 @@ public abstract class<Ljava/lang/Objec public abstract method getSize(): int public abstract method getValues(): java.util.Collection public bridge final method size(): int + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericStringMap_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericStringMap_ir.txt index 9d95caade61..d5fb822e06f 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericStringMap_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericStringMap_ir.txt @@ -19,4 +19,5 @@ public abstract class<Ljava/lang/Object;Ljava/util/Map method remove(p0: java.lang.Object): java.lang.Object public method remove(p0: java.lang.Object): java.lang.String public bridge final method size(): int + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericStringMutableMap_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericStringMutableMap_ir.txt index a4d1f1c07ac..fc62f252b4d 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericStringMutableMap_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericStringMutableMap_ir.txt @@ -14,4 +14,5 @@ public abstract class<Ljava/lang/Object;Ljava/util/Map method getValues(): java.util.Collection public synthetic bridge method remove(p0: java.lang.Object): java.lang.Object public bridge final method size(): int + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/mapEntry_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/mapEntry_ir.txt index eee59eafbc9..8a2fcf912b1 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/mapEntry_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/mapEntry_ir.txt @@ -4,6 +4,7 @@ public abstract class method (): void public synthetic bridge method setValue(p0: java.lang.Object): java.lang.Object public method setValue(p0: short): java.lang.Short + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -11,6 +12,7 @@ public abstract class<Ljava/lang/Objec // source: 'mapEntry.kt' public <(TV;)TV;> method setValue(p0: java.lang.Object): java.lang.Object public method (): void + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -19,6 +21,7 @@ public abstract class<Ljava/lang/Object;Ljava/util/Map$Ent public method (): void public synthetic bridge method setValue(p0: java.lang.Object): java.lang.Object public method setValue(p0: java.lang.String): java.lang.String + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -27,6 +30,7 @@ public abstract class method (): void public synthetic bridge method setValue(p0: java.lang.Object): java.lang.Object public method setValue(p0: java.lang.String): java.lang.String + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -34,4 +38,5 @@ public abstract class<Ljava/lang/Object;Ljava/util/Map$Ent // source: 'mapEntry.kt' public <(TV;)TV;> method setValue(p0: java.lang.Object): java.lang.Object public method (): void + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/mutableMapEntry_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/mutableMapEntry_ir.txt new file mode 100644 index 00000000000..36fc4e24d80 --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/mutableMapEntry_ir.txt @@ -0,0 +1,34 @@ +@kotlin.Metadata +public abstract class;Lkotlin/jvm/internal/markers/KMutableMap$Entry;> ByteShortMutableMapEntry { + // source: 'mutableMapEntry.kt' + public method (): void + public inner class java/util/Map$Entry +} + +@kotlin.Metadata +public abstract class<Ljava/lang/Object;Ljava/util/Map$Entry;Lkotlin/jvm/internal/markers/KMutableMap$Entry;> GenericMutableMutableMapEntry { + // source: 'mutableMapEntry.kt' + public method (): void + public inner class java/util/Map$Entry +} + +@kotlin.Metadata +public abstract class<Ljava/lang/Object;Ljava/util/Map$Entry;Lkotlin/jvm/internal/markers/KMutableMap$Entry;> GenericStringMutableMapEntry { + // source: 'mutableMapEntry.kt' + public method (): void + public inner class java/util/Map$Entry +} + +@kotlin.Metadata +public abstract class;Lkotlin/jvm/internal/markers/KMutableMap$Entry;> NumberStringMutableMapEntry { + // source: 'mutableMapEntry.kt' + public method (): void + public inner class java/util/Map$Entry +} + +@kotlin.Metadata +public abstract class<Ljava/lang/Object;Ljava/util/Map$Entry;Lkotlin/jvm/internal/markers/KMutableMap$Entry;> StringGenericMutableMapEntry { + // source: 'mutableMapEntry.kt' + public method (): void + public inner class java/util/Map$Entry +} diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/numberStringMap_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/numberStringMap_ir.txt index dfd13f242f8..128187f9e51 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/numberStringMap_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/numberStringMap_ir.txt @@ -23,4 +23,5 @@ public abstract class method remove(p0: java.lang.Object): java.lang.Object public method remove(p0: java.lang.Object): java.lang.String public bridge final method size(): int + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/numberStringMutableMap_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/numberStringMutableMap_ir.txt index 65419d93100..07a7569a056 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/numberStringMutableMap_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/numberStringMutableMap_ir.txt @@ -20,4 +20,5 @@ public abstract class method remove(p0: java.lang.Object): java.lang.Object public bridge final method remove(p0: java.lang.Object): java.lang.String public bridge final method size(): int + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/specializedGenericMap_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/specializedGenericMap_ir.txt index dd774596503..1abab5201c5 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/specializedGenericMap_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/specializedGenericMap_ir.txt @@ -14,6 +14,7 @@ public abstract class<Ljava/lang/Objec public abstract method getSize(): int public abstract method getValues(): java.util.Collection public bridge final method size(): int + public inner class java/util/Map$Entry } @kotlin.Metadata diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/stringGenericMap_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/stringGenericMap_ir.txt index b5fa7e547ab..4784334367f 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/stringGenericMap_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/stringGenericMap_ir.txt @@ -19,4 +19,5 @@ public abstract class<Ljava/lang/Object;Ljava/util/Map method getValues(): java.util.Collection public synthetic bridge method put(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object public bridge final method size(): int + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/stringGenericMutableMap_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/stringGenericMutableMap_ir.txt index ea5ce048bf2..e606c7fba7f 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/stringGenericMutableMap_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/stringGenericMutableMap_ir.txt @@ -16,4 +16,5 @@ public abstract class<Ljava/lang/Object;Ljava/util/Map method getValues(): java.util.Collection public abstract method remove(p0: java.lang.String): java.lang.Object public bridge final method size(): int + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegation2WithFullJdk_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegation2WithFullJdk_ir.txt index 954808903b8..37ab15cd0ab 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegation2WithFullJdk_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegation2WithFullJdk_ir.txt @@ -193,6 +193,7 @@ public final class DStringMap { public method replaceAll(p0: java.util.function.BiFunction): void public bridge final method size(): int public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -206,6 +207,7 @@ public final class DStringMapEntry { public synthetic bridge method getValue(): java.lang.Object public method setValue(p0: java.lang.Number): java.lang.Number public synthetic bridge method setValue(p0: java.lang.Object): java.lang.Object + public inner class java/util/Map$Entry } @kotlin.Metadata diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegation2_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegation2_ir.txt index 0469597759f..023009c7dda 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegation2_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegation2_ir.txt @@ -172,6 +172,7 @@ public final class DStringMap { public synthetic bridge method remove(p0: java.lang.Object): java.lang.Object public bridge final method size(): int public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -185,6 +186,7 @@ public final class DStringMapEntry { public synthetic bridge method getValue(): java.lang.Object public method setValue(p0: java.lang.Number): java.lang.Number public synthetic bridge method setValue(p0: java.lang.Object): java.lang.Object + public inner class java/util/Map$Entry } @kotlin.Metadata diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegation3WithFullJdk_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegation3WithFullJdk_ir.txt index fe01b2df9fc..6c8c0b62cd2 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegation3WithFullJdk_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegation3WithFullJdk_ir.txt @@ -193,6 +193,7 @@ public final class DIntMap { public method replaceAll(p0: java.util.function.BiFunction): void public bridge final method size(): int public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -206,6 +207,7 @@ public final class DIntMapEntry { public synthetic bridge method getValue(): java.lang.Object public method setValue(p0: double): java.lang.Double public synthetic bridge method setValue(p0: java.lang.Object): java.lang.Object + public inner class java/util/Map$Entry } @kotlin.Metadata diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegation3_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegation3_ir.txt index 8de73fec565..c17c78d94d0 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegation3_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegation3_ir.txt @@ -172,6 +172,7 @@ public final class DIntMap { public synthetic bridge method remove(p0: java.lang.Object): java.lang.Object public bridge final method size(): int public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -185,6 +186,7 @@ public final class DIntMapEntry { public synthetic bridge method getValue(): java.lang.Object public method setValue(p0: double): java.lang.Double public synthetic bridge method setValue(p0: java.lang.Object): java.lang.Object + public inner class java/util/Map$Entry } @kotlin.Metadata diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegationWithFullJdk_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegationWithFullJdk_ir.txt new file mode 100644 index 00000000000..55647a00805 --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegationWithFullJdk_ir.txt @@ -0,0 +1,197 @@ +@kotlin.Metadata +public final class DGenericCollection { + // source: 'collectionByDelegationWithFullJdk.kt' + private synthetic final field $$delegate_0: java.util.Collection + public method (@org.jetbrains.annotations.NotNull p0: java.util.Collection): void + public method add(p0: java.lang.Object): boolean + public method addAll(p0: java.util.Collection): boolean + public method clear(): void + public method contains(p0: java.lang.Object): boolean + public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean + public method getSize(): int + public method isEmpty(): boolean + public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator + public method remove(p0: java.lang.Object): boolean + public method removeAll(p0: java.util.Collection): boolean + public method removeIf(p0: java.util.function.Predicate): boolean + public method retainAll(p0: java.util.Collection): boolean + public bridge final method size(): int + public method toArray(): java.lang.Object[] + public method toArray(p0: java.lang.Object[]): java.lang.Object[] +} + +@kotlin.Metadata +public final class DGenericCollectionByList { + // source: 'collectionByDelegationWithFullJdk.kt' + private synthetic final field $$delegate_0: java.util.List + public method (@org.jetbrains.annotations.NotNull p0: java.util.List): void + public method add(p0: java.lang.Object): boolean + public method addAll(p0: java.util.Collection): boolean + public method clear(): void + public method contains(p0: java.lang.Object): boolean + public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean + public method getSize(): int + public method isEmpty(): boolean + public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator + public method remove(p0: java.lang.Object): boolean + public method removeAll(p0: java.util.Collection): boolean + public method removeIf(p0: java.util.function.Predicate): boolean + public method retainAll(p0: java.util.Collection): boolean + public bridge final method size(): int + public method toArray(): java.lang.Object[] + public method toArray(p0: java.lang.Object[]): java.lang.Object[] +} + +@kotlin.Metadata +public final class DGenericCollectionBySet { + // source: 'collectionByDelegationWithFullJdk.kt' + private synthetic final field $$delegate_0: java.util.Set + public method (@org.jetbrains.annotations.NotNull p0: java.util.Set): void + public method add(p0: java.lang.Object): boolean + public method addAll(p0: java.util.Collection): boolean + public method clear(): void + public method contains(p0: java.lang.Object): boolean + public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean + public method getSize(): int + public method isEmpty(): boolean + public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator + public method remove(p0: java.lang.Object): boolean + public method removeAll(p0: java.util.Collection): boolean + public method removeIf(p0: java.util.function.Predicate): boolean + public method retainAll(p0: java.util.Collection): boolean + public bridge final method size(): int + public method toArray(): java.lang.Object[] + public method toArray(p0: java.lang.Object[]): java.lang.Object[] +} + +@kotlin.Metadata +public final class DGenericIterable { + // source: 'collectionByDelegationWithFullJdk.kt' + private synthetic final field $$delegate_0: java.lang.Iterable + public method (@org.jetbrains.annotations.NotNull p0: java.lang.Iterable): void + public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator +} + +@kotlin.Metadata +public final class DGenericIterator { + // source: 'collectionByDelegationWithFullJdk.kt' + private synthetic final field $$delegate_0: java.util.Iterator + public method (@org.jetbrains.annotations.NotNull p0: java.util.Iterator): void + public method hasNext(): boolean + public method next(): java.lang.Object + public method remove(): void +} + +@kotlin.Metadata +public final class DGenericList { + // source: 'collectionByDelegationWithFullJdk.kt' + private synthetic final field $$delegate_0: java.util.List + public method (@org.jetbrains.annotations.NotNull p0: java.util.List): void + public method add(p0: int, p1: java.lang.Object): void + public method add(p0: java.lang.Object): boolean + public method addAll(p0: int, p1: java.util.Collection): boolean + public method addAll(p0: java.util.Collection): boolean + public method clear(): void + public method contains(p0: java.lang.Object): boolean + public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean + public method get(p0: int): java.lang.Object + public method getSize(): int + public method indexOf(p0: java.lang.Object): int + public method isEmpty(): boolean + public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator + public method lastIndexOf(p0: java.lang.Object): int + public @org.jetbrains.annotations.NotNull method listIterator(): java.util.ListIterator + public @org.jetbrains.annotations.NotNull method listIterator(p0: int): java.util.ListIterator + public method remove(p0: int): java.lang.Object + public method remove(p0: java.lang.Object): boolean + public method removeAll(p0: java.util.Collection): boolean + public method replaceAll(p0: java.util.function.UnaryOperator): void + public method retainAll(p0: java.util.Collection): boolean + public method set(p0: int, p1: java.lang.Object): java.lang.Object + public bridge final method size(): int + public method sort(p0: java.util.Comparator): void + public @org.jetbrains.annotations.NotNull method subList(p0: int, p1: int): java.util.List + public method toArray(): java.lang.Object[] + public method toArray(p0: java.lang.Object[]): java.lang.Object[] +} + +@kotlin.Metadata +public final class DGenericListIterator { + // source: 'collectionByDelegationWithFullJdk.kt' + private synthetic final field $$delegate_0: java.util.ListIterator + public method (@org.jetbrains.annotations.NotNull p0: java.util.ListIterator): void + public method add(p0: java.lang.Object): void + public method hasNext(): boolean + public method hasPrevious(): boolean + public method next(): java.lang.Object + public method nextIndex(): int + public method previous(): java.lang.Object + public method previousIndex(): int + public method remove(): void + public method set(p0: java.lang.Object): void +} + +@kotlin.Metadata +public final class DGenericMap { + // source: 'collectionByDelegationWithFullJdk.kt' + private synthetic final field $$delegate_0: java.util.Map + public method (@org.jetbrains.annotations.NotNull p0: java.util.Map): void + public method clear(): void + public method compute(p0: java.lang.Object, p1: java.util.function.BiFunction): java.lang.Object + public method computeIfAbsent(p0: java.lang.Object, p1: java.util.function.Function): java.lang.Object + public method computeIfPresent(p0: java.lang.Object, p1: java.util.function.BiFunction): java.lang.Object + public method containsKey(p0: java.lang.Object): boolean + public method containsValue(p0: java.lang.Object): boolean + public bridge final method entrySet(): java.util.Set + public @org.jetbrains.annotations.Nullable method get(p0: java.lang.Object): java.lang.Object + public @org.jetbrains.annotations.NotNull method getEntries(): java.util.Set + public @org.jetbrains.annotations.NotNull method getKeys(): java.util.Set + public method getSize(): int + public @org.jetbrains.annotations.NotNull method getValues(): java.util.Collection + public method isEmpty(): boolean + public bridge final method keySet(): java.util.Set + public method merge(p0: java.lang.Object, p1: java.lang.Object, p2: java.util.function.BiFunction): java.lang.Object + public method put(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object + public method putAll(p0: java.util.Map): void + public method putIfAbsent(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object + public method remove(p0: java.lang.Object): java.lang.Object + public method remove(p0: java.lang.Object, p1: java.lang.Object): boolean + public method replace(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object + public method replace(p0: java.lang.Object, p1: java.lang.Object, p2: java.lang.Object): boolean + public method replaceAll(p0: java.util.function.BiFunction): void + public bridge final method size(): int + public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry +} + +@kotlin.Metadata +public final class DGenericMapEntry { + // source: 'collectionByDelegationWithFullJdk.kt' + private synthetic final field $$delegate_0: java.util.Map$Entry + public method (@org.jetbrains.annotations.NotNull p0: java.util.Map$Entry): void + public method getKey(): java.lang.Object + public method getValue(): java.lang.Object + public method setValue(p0: java.lang.Object): java.lang.Object + public inner class java/util/Map$Entry +} + +@kotlin.Metadata +public final class DGenericSet { + // source: 'collectionByDelegationWithFullJdk.kt' + private synthetic final field $$delegate_0: java.util.Set + public method (@org.jetbrains.annotations.NotNull p0: java.util.Set): void + public method add(p0: java.lang.Object): boolean + public method addAll(p0: java.util.Collection): boolean + public method clear(): void + public method contains(p0: java.lang.Object): boolean + public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean + public method getSize(): int + public method isEmpty(): boolean + public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator + public method remove(p0: java.lang.Object): boolean + public method removeAll(p0: java.util.Collection): boolean + public method retainAll(p0: java.util.Collection): boolean + public bridge final method size(): int + public method toArray(): java.lang.Object[] + public method toArray(p0: java.lang.Object[]): java.lang.Object[] +} diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegation_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegation_ir.txt new file mode 100644 index 00000000000..1dc774d6edd --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionByDelegation_ir.txt @@ -0,0 +1,183 @@ +@kotlin.Metadata +public final class DGenericCollection { + // source: 'collectionByDelegation.kt' + private synthetic final field $$delegate_0: java.util.Collection + public method (@org.jetbrains.annotations.NotNull p0: java.util.Collection): void + public method add(p0: java.lang.Object): boolean + public method addAll(p0: java.util.Collection): boolean + public method clear(): void + public method contains(p0: java.lang.Object): boolean + public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean + public method getSize(): int + public method isEmpty(): boolean + public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator + public method remove(p0: java.lang.Object): boolean + public method removeAll(p0: java.util.Collection): boolean + public method retainAll(p0: java.util.Collection): boolean + public bridge final method size(): int + public method toArray(): java.lang.Object[] + public method toArray(p0: java.lang.Object[]): java.lang.Object[] +} + +@kotlin.Metadata +public final class DGenericCollectionByList { + // source: 'collectionByDelegation.kt' + private synthetic final field $$delegate_0: java.util.List + public method (@org.jetbrains.annotations.NotNull p0: java.util.List): void + public method add(p0: java.lang.Object): boolean + public method addAll(p0: java.util.Collection): boolean + public method clear(): void + public method contains(p0: java.lang.Object): boolean + public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean + public method getSize(): int + public method isEmpty(): boolean + public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator + public method remove(p0: java.lang.Object): boolean + public method removeAll(p0: java.util.Collection): boolean + public method retainAll(p0: java.util.Collection): boolean + public bridge final method size(): int + public method toArray(): java.lang.Object[] + public method toArray(p0: java.lang.Object[]): java.lang.Object[] +} + +@kotlin.Metadata +public final class DGenericCollectionBySet { + // source: 'collectionByDelegation.kt' + private synthetic final field $$delegate_0: java.util.Set + public method (@org.jetbrains.annotations.NotNull p0: java.util.Set): void + public method add(p0: java.lang.Object): boolean + public method addAll(p0: java.util.Collection): boolean + public method clear(): void + public method contains(p0: java.lang.Object): boolean + public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean + public method getSize(): int + public method isEmpty(): boolean + public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator + public method remove(p0: java.lang.Object): boolean + public method removeAll(p0: java.util.Collection): boolean + public method retainAll(p0: java.util.Collection): boolean + public bridge final method size(): int + public method toArray(): java.lang.Object[] + public method toArray(p0: java.lang.Object[]): java.lang.Object[] +} + +@kotlin.Metadata +public final class DGenericIterable { + // source: 'collectionByDelegation.kt' + private synthetic final field $$delegate_0: java.lang.Iterable + public method (@org.jetbrains.annotations.NotNull p0: java.lang.Iterable): void + public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator +} + +@kotlin.Metadata +public final class DGenericIterator { + // source: 'collectionByDelegation.kt' + private synthetic final field $$delegate_0: java.util.Iterator + public method (@org.jetbrains.annotations.NotNull p0: java.util.Iterator): void + public method hasNext(): boolean + public method next(): java.lang.Object + public method remove(): void +} + +@kotlin.Metadata +public final class DGenericList { + // source: 'collectionByDelegation.kt' + private synthetic final field $$delegate_0: java.util.List + public method (@org.jetbrains.annotations.NotNull p0: java.util.List): void + public method add(p0: int, p1: java.lang.Object): void + public method add(p0: java.lang.Object): boolean + public method addAll(p0: int, p1: java.util.Collection): boolean + public method addAll(p0: java.util.Collection): boolean + public method clear(): void + public method contains(p0: java.lang.Object): boolean + public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean + public method get(p0: int): java.lang.Object + public method getSize(): int + public method indexOf(p0: java.lang.Object): int + public method isEmpty(): boolean + public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator + public method lastIndexOf(p0: java.lang.Object): int + public @org.jetbrains.annotations.NotNull method listIterator(): java.util.ListIterator + public @org.jetbrains.annotations.NotNull method listIterator(p0: int): java.util.ListIterator + public method remove(p0: int): java.lang.Object + public method remove(p0: java.lang.Object): boolean + public method removeAll(p0: java.util.Collection): boolean + public method retainAll(p0: java.util.Collection): boolean + public method set(p0: int, p1: java.lang.Object): java.lang.Object + public bridge final method size(): int + public @org.jetbrains.annotations.NotNull method subList(p0: int, p1: int): java.util.List + public method toArray(): java.lang.Object[] + public method toArray(p0: java.lang.Object[]): java.lang.Object[] +} + +@kotlin.Metadata +public final class DGenericListIterator { + // source: 'collectionByDelegation.kt' + private synthetic final field $$delegate_0: java.util.ListIterator + public method (@org.jetbrains.annotations.NotNull p0: java.util.ListIterator): void + public method add(p0: java.lang.Object): void + public method hasNext(): boolean + public method hasPrevious(): boolean + public method next(): java.lang.Object + public method nextIndex(): int + public method previous(): java.lang.Object + public method previousIndex(): int + public method remove(): void + public method set(p0: java.lang.Object): void +} + +@kotlin.Metadata +public final class DGenericMap { + // source: 'collectionByDelegation.kt' + private synthetic final field $$delegate_0: java.util.Map + public method (@org.jetbrains.annotations.NotNull p0: java.util.Map): void + public method clear(): void + public method containsKey(p0: java.lang.Object): boolean + public method containsValue(p0: java.lang.Object): boolean + public bridge final method entrySet(): java.util.Set + public @org.jetbrains.annotations.Nullable method get(p0: java.lang.Object): java.lang.Object + public @org.jetbrains.annotations.NotNull method getEntries(): java.util.Set + public @org.jetbrains.annotations.NotNull method getKeys(): java.util.Set + public method getSize(): int + public @org.jetbrains.annotations.NotNull method getValues(): java.util.Collection + public method isEmpty(): boolean + public bridge final method keySet(): java.util.Set + public method put(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object + public method putAll(p0: java.util.Map): void + public method remove(p0: java.lang.Object): java.lang.Object + public bridge final method size(): int + public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry +} + +@kotlin.Metadata +public final class DGenericMapEntry { + // source: 'collectionByDelegation.kt' + private synthetic final field $$delegate_0: java.util.Map$Entry + public method (@org.jetbrains.annotations.NotNull p0: java.util.Map$Entry): void + public method getKey(): java.lang.Object + public method getValue(): java.lang.Object + public method setValue(p0: java.lang.Object): java.lang.Object + public inner class java/util/Map$Entry +} + +@kotlin.Metadata +public final class DGenericSet { + // source: 'collectionByDelegation.kt' + private synthetic final field $$delegate_0: java.util.Set + public method (@org.jetbrains.annotations.NotNull p0: java.util.Set): void + public method add(p0: java.lang.Object): boolean + public method addAll(p0: java.util.Collection): boolean + public method clear(): void + public method contains(p0: java.lang.Object): boolean + public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean + public method getSize(): int + public method isEmpty(): boolean + public @org.jetbrains.annotations.NotNull method iterator(): java.util.Iterator + public method remove(p0: java.lang.Object): boolean + public method removeAll(p0: java.util.Collection): boolean + public method retainAll(p0: java.util.Collection): boolean + public bridge final method size(): int + public method toArray(): java.lang.Object[] + public method toArray(p0: java.lang.Object[]): java.lang.Object[] +} diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionsWithFullJdk_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionsWithFullJdk_ir.txt index 7fb75fbd119..4dd80aeb046 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionsWithFullJdk_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/collectionsWithFullJdk_ir.txt @@ -123,6 +123,7 @@ public abstract class AbstractMap { public method replaceAll(p0: java.util.function.BiFunction): void public bridge final method size(): int public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -131,6 +132,7 @@ public abstract class AbstractMapEntry { public method (): void public method setValue(p0: java.lang.Number): java.lang.Number public synthetic bridge method setValue(p0: java.lang.Object): java.lang.Object + public inner class java/util/Map$Entry } @kotlin.Metadata diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/mapOfPrimitivesFullJdk_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/mapOfPrimitivesFullJdk_ir.txt index 028562f9a3f..e73e9ed5dd1 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/mapOfPrimitivesFullJdk_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/mapOfPrimitivesFullJdk_ir.txt @@ -39,4 +39,5 @@ public abstract class IntIntMap { public method replaceAll(p0: java.util.function.BiFunction): void public bridge final method size(): int public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/noStubsForMapImplementations_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/noStubsForMapImplementations_ir.txt index 0dff01a9c3e..cdfaa882228 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/noStubsForMapImplementations_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/noStubsForMapImplementations_ir.txt @@ -43,4 +43,5 @@ public final class MyMap { public bridge final method values(): java.util.ArrayList public synthetic bridge method values(): java.util.Collection public final inner class MyMap$MySet + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/collectionStubs/observableMutableMap_ir.txt b/compiler/testData/codegen/bytecodeListing/collectionStubs/observableMutableMap_ir.txt index 62e96db3e7b..14f4ccbeb8a 100644 --- a/compiler/testData/codegen/bytecodeListing/collectionStubs/observableMutableMap_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/collectionStubs/observableMutableMap_ir.txt @@ -19,4 +19,5 @@ public abstract class ObservableMutableMap { public final @org.jetbrains.annotations.Nullable method remove(p0: java.lang.Object): java.lang.Object public bridge final method size(): int public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/coroutines/coroutineFields_ir.txt b/compiler/testData/codegen/bytecodeListing/coroutines/coroutineFields_ir.txt index e6c1debac5e..50aebc8928a 100644 --- a/compiler/testData/codegen/bytecodeListing/coroutines/coroutineFields_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/coroutines/coroutineFields_ir.txt @@ -53,6 +53,7 @@ final class CoroutineFieldsKt$box$1 { public final @org.jetbrains.annotations.Nullable method invoke(@org.jetbrains.annotations.NotNull p0: Controller, @org.jetbrains.annotations.Nullable 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 invokeSuspend(@org.jetbrains.annotations.NotNull p0: java.lang.Object): java.lang.Object + public final inner class kotlin/jvm/internal/Ref$ObjectRef } @kotlin.Metadata @@ -61,4 +62,5 @@ public final class CoroutineFieldsKt { inner (anonymous) class CoroutineFieldsKt$box$1 public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function2): void + public final inner class kotlin/jvm/internal/Ref$ObjectRef } diff --git a/compiler/testData/codegen/bytecodeListing/coroutines/spilling/booleanParameter_ir.txt b/compiler/testData/codegen/bytecodeListing/coroutines/spilling/booleanParameter_ir.txt index f51bbbbc24f..512a5456902 100644 --- a/compiler/testData/codegen/bytecodeListing/coroutines/spilling/booleanParameter_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/coroutines/spilling/booleanParameter_ir.txt @@ -13,6 +13,7 @@ final class BooleanParameterKt$box$1 { 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 + public final inner class kotlin/jvm/internal/Ref$ObjectRef } @kotlin.coroutines.jvm.internal.DebugMetadata @@ -37,4 +38,5 @@ public final class BooleanParameterKt { inner (anonymous) class BooleanParameterKt$box$lambda$1 public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String public final static method builder(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function1): void + public final inner class kotlin/jvm/internal/Ref$ObjectRef } diff --git a/compiler/testData/codegen/bytecodeListing/coroutines/suspendConversion_ir.txt b/compiler/testData/codegen/bytecodeListing/coroutines/suspendConversion_ir.txt index 1dd0e5ef62e..02c5c7b0a2c 100644 --- a/compiler/testData/codegen/bytecodeListing/coroutines/suspendConversion_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/coroutines/suspendConversion_ir.txt @@ -6,6 +6,7 @@ synthetic final class SuspendConversionKt$test$1 { method (p0: java.lang.Object): void 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 + public final inner class kotlin/jvm/internal/Intrinsics$Kotlin } @kotlin.Metadata diff --git a/compiler/testData/codegen/bytecodeListing/deprecated/inheritingDeprecation_ir.txt b/compiler/testData/codegen/bytecodeListing/deprecated/inheritingDeprecation_ir.txt new file mode 100644 index 00000000000..73e4644be18 --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/deprecated/inheritingDeprecation_ir.txt @@ -0,0 +1,84 @@ +@kotlin.Metadata +public final class DefaultImpl { + // source: 'inheritingDeprecation.kt' + public method (): void + public deprecated @org.jetbrains.annotations.NotNull method getExtProp(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String + public deprecated @org.jetbrains.annotations.NotNull method getProp(): java.lang.String + public final inner class IFoo$DefaultImpls +} + +@kotlin.Metadata +public final class DefaultImpl2 { + // source: 'inheritingDeprecation.kt' + public method (): void + public deprecated @org.jetbrains.annotations.NotNull method getExtProp(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String + public deprecated @org.jetbrains.annotations.NotNull method getProp(): java.lang.String + public final inner class IFoo2$DefaultImpls +} + +@kotlin.Metadata +public final class Delegated { + // source: 'inheritingDeprecation.kt' + private synthetic final field $$delegate_0: IFoo + public method (@org.jetbrains.annotations.NotNull p0: IFoo): void + public deprecated @org.jetbrains.annotations.NotNull method getExtProp(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String + public deprecated @org.jetbrains.annotations.NotNull method getProp(): java.lang.String +} + +@kotlin.Metadata +public final class Delegated2 { + // source: 'inheritingDeprecation.kt' + private synthetic final field $$delegate_0: IFoo2 + public method (@org.jetbrains.annotations.NotNull p0: IFoo2): void + public deprecated @org.jetbrains.annotations.NotNull method getExtProp(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String + public deprecated @org.jetbrains.annotations.NotNull method getProp(): java.lang.String +} + +@kotlin.Metadata +public final class ExplicitOverride { + // source: 'inheritingDeprecation.kt' + public method (): void + public @org.jetbrains.annotations.NotNull method getExtProp(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String + public @org.jetbrains.annotations.NotNull method getProp(): java.lang.String +} + +@kotlin.Metadata +public final class ExplicitOverride2 { + // source: 'inheritingDeprecation.kt' + public method (): void + public @org.jetbrains.annotations.NotNull method getExtProp(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String + public @org.jetbrains.annotations.NotNull method getProp(): java.lang.String +} + +@kotlin.Metadata +public final class IFoo$DefaultImpls { + // source: 'inheritingDeprecation.kt' + public synthetic deprecated static @kotlin.Deprecated(message="") method getExtProp$annotations(p0: java.lang.String): void + public deprecated static @org.jetbrains.annotations.NotNull method getExtProp(@org.jetbrains.annotations.NotNull p0: IFoo, @org.jetbrains.annotations.NotNull p1: java.lang.String): java.lang.String + public synthetic deprecated static @kotlin.Deprecated(message="") method getProp$annotations(): void + public deprecated static @org.jetbrains.annotations.NotNull method getProp(@org.jetbrains.annotations.NotNull p0: IFoo): java.lang.String + public final inner class IFoo$DefaultImpls +} + +@kotlin.Metadata +public interface IFoo { + // source: 'inheritingDeprecation.kt' + public deprecated abstract @org.jetbrains.annotations.NotNull method getExtProp(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String + public deprecated abstract @org.jetbrains.annotations.NotNull method getProp(): java.lang.String + public final inner class IFoo$DefaultImpls +} + +@kotlin.Metadata +public final class IFoo2$DefaultImpls { + // source: 'inheritingDeprecation.kt' + public deprecated static @org.jetbrains.annotations.NotNull method getExtProp(@org.jetbrains.annotations.NotNull p0: IFoo2, @org.jetbrains.annotations.NotNull p1: java.lang.String): java.lang.String + public deprecated static @org.jetbrains.annotations.NotNull method getProp(@org.jetbrains.annotations.NotNull p0: IFoo2): java.lang.String + public final inner class IFoo$DefaultImpls + public final inner class IFoo2$DefaultImpls +} + +@kotlin.Metadata +public interface IFoo2 { + // source: 'inheritingDeprecation.kt' + public final inner class IFoo2$DefaultImpls +} diff --git a/compiler/testData/codegen/bytecodeListing/inline/enclosingInfo/kt10259_ir.txt b/compiler/testData/codegen/bytecodeListing/inline/enclosingInfo/kt10259_ir.txt index e7372a0a149..be8967c70e9 100644 --- a/compiler/testData/codegen/bytecodeListing/inline/enclosingInfo/kt10259_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inline/enclosingInfo/kt10259_ir.txt @@ -19,6 +19,7 @@ final class _2Kt$box$1$1$1 { method (p0: kotlin.jvm.internal.Ref$ObjectRef): void public synthetic bridge method invoke(): java.lang.Object public final method invoke(): void + public final inner class kotlin/jvm/internal/Ref$ObjectRef } @kotlin.Metadata @@ -42,6 +43,7 @@ final class _2Kt$box$1$1 { method (p0: kotlin.jvm.internal.Ref$ObjectRef, p1: kotlin.jvm.internal.Ref$ObjectRef): void public synthetic bridge method invoke(): java.lang.Object public final method invoke(): void + public final inner class kotlin/jvm/internal/Ref$ObjectRef } @kotlin.Metadata @@ -50,6 +52,7 @@ public final class _2Kt { inner (anonymous) class _2Kt$box$1$1 public final static method box(): void public final static method eval(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function0): java.lang.Object + public final inner class kotlin/jvm/internal/Ref$ObjectRef } @kotlin.Metadata diff --git a/compiler/testData/codegen/bytecodeListing/inline/enclosingInfo/transformedConstructorWithNestedInline_ir.txt b/compiler/testData/codegen/bytecodeListing/inline/enclosingInfo/transformedConstructorWithNestedInline_ir.txt index 670f2afdc88..216b7a044ec 100644 --- a/compiler/testData/codegen/bytecodeListing/inline/enclosingInfo/transformedConstructorWithNestedInline_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inline/enclosingInfo/transformedConstructorWithNestedInline_ir.txt @@ -27,6 +27,7 @@ public final class _2Kt { // source: '2.kt' inner (anonymous) class _2Kt$box$res$1$1$1 public final static method box(): void + public final inner class kotlin/jvm/internal/Ref$ObjectRef } @kotlin.Metadata diff --git a/compiler/testData/codegen/bytecodeListing/inline/enclosingInfo/transformedConstructor_ir.txt b/compiler/testData/codegen/bytecodeListing/inline/enclosingInfo/transformedConstructor_ir.txt index 3f3d889f69e..6cda811c308 100644 --- a/compiler/testData/codegen/bytecodeListing/inline/enclosingInfo/transformedConstructor_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inline/enclosingInfo/transformedConstructor_ir.txt @@ -27,6 +27,7 @@ public final class _2Kt { // source: '2.kt' inner (anonymous) class _2Kt$box$res$1$1 public final static method box(): void + public final inner class kotlin/jvm/internal/Ref$ObjectRef } @kotlin.Metadata diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/defaultInterfaceMembers/javaDefaultInterfaceMember_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/defaultInterfaceMembers/javaDefaultInterfaceMember_ir.txt new file mode 100644 index 00000000000..1034ca5a18f --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/defaultInterfaceMembers/javaDefaultInterfaceMember_ir.txt @@ -0,0 +1,131 @@ +@kotlin.Metadata +public interface KBar2 { + // source: 'javaDefaultInterfaceMember.kt' +} + +@kotlin.Metadata +public interface KFoo2 { + // source: 'javaDefaultInterfaceMember.kt' +} + +@kotlin.Metadata +public final class KFoo3$DefaultImpls { + // source: 'javaDefaultInterfaceMember.kt' + public static method foo(@org.jetbrains.annotations.NotNull p0: KFoo3): void + public final inner class KFoo3$DefaultImpls +} + +@kotlin.Metadata +public interface KFoo3 { + // source: 'javaDefaultInterfaceMember.kt' + public abstract method foo(): void + public final inner class KFoo3$DefaultImpls +} + +@kotlin.Metadata +public interface KFooUnrelated { + // source: 'javaDefaultInterfaceMember.kt' + public abstract method foo(): void +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class TestBar1 { + // source: 'javaDefaultInterfaceMember.kt' + private final field x: int + private synthetic method (p0: int): void + public method bar(): void + public static method bar-impl(p0: int): void + public synthetic final static method box-impl(p0: int): TestBar1 + public static method constructor-impl(p0: int): int + public method equals(p0: java.lang.Object): boolean + public static method equals-impl(p0: int, p1: java.lang.Object): boolean + public final static method equals-impl0(p0: int, p1: int): boolean + public final method getX(): int + public method hashCode(): int + public static method hashCode-impl(p0: int): int + public method toString(): java.lang.String + public static method toString-impl(p0: int): java.lang.String + public synthetic final method unbox-impl(): int +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class TestBar2 { + // source: 'javaDefaultInterfaceMember.kt' + private final field x: int + private synthetic method (p0: int): void + public method bar(): void + public static method bar-impl(p0: int): void + public synthetic final static method box-impl(p0: int): TestBar2 + public static method constructor-impl(p0: int): int + public method equals(p0: java.lang.Object): boolean + public static method equals-impl(p0: int, p1: java.lang.Object): boolean + public final static method equals-impl0(p0: int, p1: int): boolean + public final method getX(): int + public method hashCode(): int + public static method hashCode-impl(p0: int): int + public method toString(): java.lang.String + public static method toString-impl(p0: int): java.lang.String + public synthetic final method unbox-impl(): int +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class TestFoo1 { + // source: 'javaDefaultInterfaceMember.kt' + private final field x: int + private synthetic method (p0: int): void + public synthetic final static method box-impl(p0: int): TestFoo1 + public static method constructor-impl(p0: int): int + public method equals(p0: java.lang.Object): boolean + public static method equals-impl(p0: int, p1: java.lang.Object): boolean + public final static method equals-impl0(p0: int, p1: int): boolean + public final method getX(): int + public method hashCode(): int + public static method hashCode-impl(p0: int): int + public method toString(): java.lang.String + public static method toString-impl(p0: int): java.lang.String + public synthetic final method unbox-impl(): int +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class TestFoo2 { + // source: 'javaDefaultInterfaceMember.kt' + private final field x: int + private synthetic method (p0: int): void + public synthetic final static method box-impl(p0: int): TestFoo2 + public static method constructor-impl(p0: int): int + public method equals(p0: java.lang.Object): boolean + public static method equals-impl(p0: int, p1: java.lang.Object): boolean + public final static method equals-impl0(p0: int, p1: int): boolean + public final method getX(): int + public method hashCode(): int + public static method hashCode-impl(p0: int): int + public method toString(): java.lang.String + public static method toString-impl(p0: int): java.lang.String + public synthetic final method unbox-impl(): int +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class TestFoo3 { + // source: 'javaDefaultInterfaceMember.kt' + private final field x: int + private synthetic method (p0: int): void + public synthetic final static method box-impl(p0: int): TestFoo3 + public static method constructor-impl(p0: int): int + public method equals(p0: java.lang.Object): boolean + public static method equals-impl(p0: int, p1: java.lang.Object): boolean + public final static method equals-impl0(p0: int, p1: int): boolean + public method foo(): void + public static method foo-impl(p0: int): void + public final method getX(): int + public method hashCode(): int + public static method hashCode-impl(p0: int): int + public method toString(): java.lang.String + public static method toString-impl(p0: int): java.lang.String + public synthetic final method unbox-impl(): int + public final inner class KFoo3$DefaultImpls +} diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/defaultInterfaceMethodsInInlineClass_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/defaultInterfaceMethodsInInlineClass_ir.txt new file mode 100644 index 00000000000..bf113ff24b6 --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/defaultInterfaceMethodsInInlineClass_ir.txt @@ -0,0 +1,60 @@ +@kotlin.Metadata +public final class IFoo$DefaultImpls { + // source: 'defaultInterfaceMethodsInInlineClass.kt' + public static @org.jetbrains.annotations.NotNull method bar(@org.jetbrains.annotations.NotNull p0: IFoo, p1: java.lang.Object): java.lang.String + public static @org.jetbrains.annotations.NotNull method foo(@org.jetbrains.annotations.NotNull p0: IFoo, p1: java.lang.Object): java.lang.String + public synthetic static method withDefault$default(p0: IFoo, p1: java.lang.Object, p2: int, p3: int, p4: java.lang.Object): java.lang.String + public static @org.jetbrains.annotations.NotNull method withDefault(@org.jetbrains.annotations.NotNull p0: IFoo, p1: java.lang.Object, p2: int): java.lang.String + public final inner class IFoo$DefaultImpls +} + +@kotlin.Metadata +public interface IFoo { + // source: 'defaultInterfaceMethodsInInlineClass.kt' + public abstract @org.jetbrains.annotations.NotNull method bar(p0: java.lang.Object): java.lang.String + public abstract @org.jetbrains.annotations.NotNull method foo(p0: java.lang.Object): java.lang.String + public abstract @org.jetbrains.annotations.NotNull method withDefault(p0: java.lang.Object, p1: int): java.lang.String + public final inner class IFoo$DefaultImpls +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class L { + // source: 'defaultInterfaceMethodsInInlineClass.kt' + private final field x: long + private synthetic method (p0: long): void + public synthetic bridge method bar(p0: java.lang.Object): java.lang.String + public @org.jetbrains.annotations.NotNull method bar--h0D71M(p0: long): java.lang.String + public static @org.jetbrains.annotations.NotNull method bar--h0D71M(p0: long, p1: long): java.lang.String + public synthetic final static method box-impl(p0: long): L + public static method constructor-impl(p0: long): long + public method equals(p0: java.lang.Object): boolean + public static method equals-impl(p0: long, p1: java.lang.Object): boolean + public final static method equals-impl0(p0: long, p1: long): boolean + public synthetic bridge method foo(p0: java.lang.Object): java.lang.String + public @org.jetbrains.annotations.NotNull method foo--h0D71M(p0: long): java.lang.String + public static @org.jetbrains.annotations.NotNull method foo--h0D71M(p0: long, p1: long): java.lang.String + public final method getX(): long + public method hashCode(): int + public static method hashCode-impl(p0: long): int + public method toString(): java.lang.String + public static method toString-impl(p0: long): java.lang.String + public synthetic final method unbox-impl(): long + public synthetic bridge method withDefault(p0: java.lang.Object, p1: int): java.lang.String + public @org.jetbrains.annotations.NotNull method withDefault-7bZmAKo(p0: long, p1: int): java.lang.String + public static @org.jetbrains.annotations.NotNull method withDefault-7bZmAKo(p0: long, p1: long, p2: int): java.lang.String + public final inner class IFoo$DefaultImpls +} + +@kotlin.Metadata +public final class X { + // source: 'defaultInterfaceMethodsInInlineClass.kt' + public method (): void + public synthetic bridge method bar(p0: java.lang.Object): java.lang.String + public @org.jetbrains.annotations.NotNull method bar--h0D71M(p0: long): java.lang.String + public synthetic bridge method foo(p0: java.lang.Object): java.lang.String + public @org.jetbrains.annotations.NotNull method foo--h0D71M(p0: long): java.lang.String + public synthetic bridge method withDefault(p0: java.lang.Object, p1: int): java.lang.String + public @org.jetbrains.annotations.NotNull method withDefault-7bZmAKo(p0: long, p1: int): java.lang.String + public final inner class IFoo$DefaultImpls +} diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/mapEntry_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/mapEntry_ir.txt new file mode 100644 index 00000000000..275f677ffa4 --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/mapEntry_ir.txt @@ -0,0 +1,21 @@ +public final class InlineMapEntry { + // source: 'mapEntry.kt' + private final field e: java.util.Map$Entry + private synthetic method (p0: java.util.Map$Entry): void + public synthetic final static method box-impl(p0: java.util.Map$Entry): InlineMapEntry + public static method constructor-impl(p0: java.util.Map$Entry): java.util.Map$Entry + public method equals(p0: java.lang.Object): boolean + public static method equals-impl(p0: java.util.Map$Entry, p1: java.lang.Object): boolean + public final static method equals-impl0(p0: java.util.Map$Entry, p1: java.util.Map$Entry): boolean + public method getKey(): java.lang.Object + public static method getKey-impl(p0: java.util.Map$Entry): java.lang.Object + public method getValue(): java.lang.Object + public static method getValue-impl(p0: java.util.Map$Entry): java.lang.Object + public method hashCode(): int + public static method hashCode-impl(p0: java.util.Map$Entry): int + public method setValue(p0: java.lang.Object): java.lang.Object + public method toString(): java.lang.String + public static method toString-impl(p0: java.util.Map$Entry): java.lang.String + public synthetic final method unbox-impl(): java.util.Map$Entry + public inner class java/util/Map$Entry +} diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/map_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/map_ir.txt index a3f6520c36c..c4037e9a831 100644 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/map_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/map_ir.txt @@ -36,4 +36,5 @@ public final class InlineMap { public static method toString-impl(p0: java.util.Map): java.lang.String public synthetic final method unbox-impl(): java.util.Map public synthetic bridge method values(): java.util.Collection + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/mutableMapEntry_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/mutableMapEntry_ir.txt new file mode 100644 index 00000000000..2a91e3a99aa --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/mutableMapEntry_ir.txt @@ -0,0 +1,22 @@ +public final class InlineMutableMapEntry { + // source: 'mutableMapEntry.kt' + private final field e: java.util.Map$Entry + private synthetic method (p0: java.util.Map$Entry): void + public synthetic final static method box-impl(p0: java.util.Map$Entry): InlineMutableMapEntry + public static method constructor-impl(p0: java.util.Map$Entry): java.util.Map$Entry + public method equals(p0: java.lang.Object): boolean + public static method equals-impl(p0: java.util.Map$Entry, p1: java.lang.Object): boolean + public final static method equals-impl0(p0: java.util.Map$Entry, p1: java.util.Map$Entry): boolean + public method getKey(): java.lang.Object + public static method getKey-impl(p0: java.util.Map$Entry): java.lang.Object + public method getValue(): java.lang.Object + public static method getValue-impl(p0: java.util.Map$Entry): java.lang.Object + public method hashCode(): int + public static method hashCode-impl(p0: java.util.Map$Entry): int + public method setValue(p0: java.lang.Object): java.lang.Object + public static method setValue-impl(p0: java.util.Map$Entry, p1: java.lang.Object): java.lang.Object + public method toString(): java.lang.String + public static method toString-impl(p0: java.util.Map$Entry): java.lang.String + public synthetic final method unbox-impl(): java.util.Map$Entry + public inner class java/util/Map$Entry +} diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/mutableMap_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/mutableMap_ir.txt index 8aab2c8d496..4bce83683fb 100644 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/mutableMap_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/mutableMap_ir.txt @@ -40,4 +40,5 @@ public final class InlineMutableMap { public static method toString-impl(p0: java.util.Map): java.lang.String public synthetic final method unbox-impl(): java.util.Map public synthetic bridge method values(): java.util.Collection + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mapEntry_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mapEntry_ir.txt index c93d273e7b4..eb0a5342748 100644 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mapEntry_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mapEntry_ir.txt @@ -54,4 +54,5 @@ public final class InlineMapEntry { public method toString(): java.lang.String public static method toString-impl(p0: java.util.Map$Entry): java.lang.String public synthetic final method unbox-impl(): java.util.Map$Entry + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/map_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/map_ir.txt index ac55d085053..f4d7746aacf 100644 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/map_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/map_ir.txt @@ -77,4 +77,5 @@ public final class InlineMap { public static method toString-impl(p0: java.util.Map): java.lang.String public synthetic final method unbox-impl(): java.util.Map public synthetic bridge method values(): java.util.Collection + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableMapEntry_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableMapEntry_ir.txt new file mode 100644 index 00000000000..821bdda5156 --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableMapEntry_ir.txt @@ -0,0 +1,59 @@ +public final class IK { + // source: 'mutableMapEntry.kt' + private final field x: int + private synthetic method (p0: int): void + public synthetic final static method box-impl(p0: int): IK + public static method constructor-impl(p0: int): int + public method equals(p0: java.lang.Object): boolean + public static method equals-impl(p0: int, p1: java.lang.Object): boolean + public final static method equals-impl0(p0: int, p1: int): boolean + public final method getX(): int + public method hashCode(): int + public static method hashCode-impl(p0: int): int + public method toString(): java.lang.String + public static method toString-impl(p0: int): java.lang.String + public synthetic final method unbox-impl(): int +} + +public final class IV { + // source: 'mutableMapEntry.kt' + private final field x: double + private synthetic method (p0: double): void + public synthetic final static method box-impl(p0: double): IV + public static method constructor-impl(p0: double): double + public method equals(p0: java.lang.Object): boolean + public static method equals-impl(p0: double, p1: java.lang.Object): boolean + public final static method equals-impl0(p0: double, p1: double): boolean + public final method getX(): double + public method hashCode(): int + public static method hashCode-impl(p0: double): int + public method toString(): java.lang.String + public static method toString-impl(p0: double): java.lang.String + public synthetic final method unbox-impl(): double +} + +public final class InlineMutableMapEntry { + // source: 'mutableMapEntry.kt' + private final field e: java.util.Map$Entry + private synthetic method (p0: java.util.Map$Entry): void + public synthetic final static method box-impl(p0: java.util.Map$Entry): InlineMutableMapEntry + public static method constructor-impl(p0: java.util.Map$Entry): java.util.Map$Entry + public method equals(p0: java.lang.Object): boolean + public static method equals-impl(p0: java.util.Map$Entry, p1: java.lang.Object): boolean + public final static method equals-impl0(p0: java.util.Map$Entry, p1: java.util.Map$Entry): boolean + public synthetic bridge method getKey(): java.lang.Object + public method getKey-I5j8jlQ(): int + public static method getKey-I5j8jlQ(p0: java.util.Map$Entry): int + public synthetic bridge method getValue(): java.lang.Object + public method getValue-zSeR6Gk(): double + public static method getValue-zSeR6Gk(p0: java.util.Map$Entry): double + public method hashCode(): int + public static method hashCode-impl(p0: java.util.Map$Entry): int + public synthetic bridge method setValue(p0: java.lang.Object): java.lang.Object + public method setValue-cYiyq8k(p0: double): double + public static method setValue-cYiyq8k(p0: java.util.Map$Entry, p1: double): double + public method toString(): java.lang.String + public static method toString-impl(p0: java.util.Map$Entry): java.lang.String + public synthetic final method unbox-impl(): java.util.Map$Entry + public inner class java/util/Map$Entry +} diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableMap_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableMap_ir.txt index 06b606974e2..c8632ffa348 100644 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableMap_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass/mutableMap_ir.txt @@ -81,4 +81,5 @@ public final class InlineMutableMap { public static method toString-impl(p0: java.util.Map): java.lang.String public synthetic final method unbox-impl(): java.util.Map public synthetic bridge method values(): java.util.Collection + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/noDelegationsToPrivateInterfaceMembers_ir.txt b/compiler/testData/codegen/bytecodeListing/noDelegationsToPrivateInterfaceMembers_ir.txt new file mode 100644 index 00000000000..5986d221ff7 --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/noDelegationsToPrivateInterfaceMembers_ir.txt @@ -0,0 +1,37 @@ +@kotlin.Metadata +public final class A$DefaultImpls { + // source: 'noDelegationsToPrivateInterfaceMembers.kt' + private static method bar(p0: A): java.lang.String + public static @org.jetbrains.annotations.NotNull method foo(@org.jetbrains.annotations.NotNull p0: A): java.lang.String + private static method getLog(p0: A): java.lang.String + public final inner class A$DefaultImpls +} + +@kotlin.Metadata +public interface A { + // source: 'noDelegationsToPrivateInterfaceMembers.kt' + public abstract @org.jetbrains.annotations.NotNull method foo(): java.lang.String + public final inner class A$DefaultImpls +} + +@kotlin.Metadata +public final class B$DefaultImpls { + // source: 'noDelegationsToPrivateInterfaceMembers.kt' + public static @org.jetbrains.annotations.NotNull method foo(@org.jetbrains.annotations.NotNull p0: B): java.lang.String + public final inner class A$DefaultImpls + public final inner class B$DefaultImpls +} + +@kotlin.Metadata +public interface B { + // source: 'noDelegationsToPrivateInterfaceMembers.kt' + public final inner class B$DefaultImpls +} + +@kotlin.Metadata +public final class C { + // source: 'noDelegationsToPrivateInterfaceMembers.kt' + public method (): void + public @org.jetbrains.annotations.NotNull method foo(): java.lang.String + public final inner class B$DefaultImpls +} diff --git a/compiler/testData/codegen/bytecodeListing/sam/reusedSamWrapperClasses_ir.txt b/compiler/testData/codegen/bytecodeListing/sam/reusedSamWrapperClasses_ir.txt index 9a14226085a..380b5621920 100644 --- a/compiler/testData/codegen/bytecodeListing/sam/reusedSamWrapperClasses_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/sam/reusedSamWrapperClasses_ir.txt @@ -44,6 +44,7 @@ final class B$test2$f$1 { @kotlin.Metadata public final class B { // source: 'reusedSamWrapperClasses.kt' + inner (anonymous) class A$sam$java_lang_Runnable$0 inner (anonymous) class B$test2$f$1 public method (): void public final method test2(): void diff --git a/compiler/testData/codegen/bytecodeListing/specialBridges/kt41123_ir.txt b/compiler/testData/codegen/bytecodeListing/specialBridges/kt41123_ir.txt index cc571357491..c38a588a1ab 100644 --- a/compiler/testData/codegen/bytecodeListing/specialBridges/kt41123_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/specialBridges/kt41123_ir.txt @@ -20,6 +20,7 @@ public class A { public bridge method remove(p0: java.lang.String): java.lang.String public bridge final method size(): int public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry } @kotlin.Metadata diff --git a/compiler/testData/codegen/bytecodeListing/specialBridges/kt48945_ir.txt b/compiler/testData/codegen/bytecodeListing/specialBridges/kt48945_ir.txt index f2d0e343050..152006ba595 100644 --- a/compiler/testData/codegen/bytecodeListing/specialBridges/kt48945_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/specialBridges/kt48945_ir.txt @@ -40,6 +40,7 @@ public final class Test_GMStringString_AbstractMapStringString { public bridge method remove(p0: java.lang.String, p1: java.lang.String): boolean public bridge final method size(): int public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -67,6 +68,7 @@ public final class Test_GMStringString_JMapFinalRemove { public bridge method remove(p0: java.lang.String, p1: java.lang.String): boolean public bridge final method size(): int public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -96,6 +98,7 @@ public final class Test_MSS_AbstractMapStringString { public bridge method remove(p0: java.lang.String, p1: java.lang.String): boolean public bridge final method size(): int public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -123,6 +126,7 @@ public final class Test_MSS_JMapFinalRemove { public bridge method remove(p0: java.lang.String, p1: java.lang.String): boolean public bridge final method size(): int public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -152,6 +156,7 @@ public final class Test_MapStringString_AbstractMapStringString { public bridge method remove(p0: java.lang.String, p1: java.lang.String): boolean public bridge final method size(): int public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -179,6 +184,7 @@ public final class Test_MapStringString_JMapFinalRemove { public bridge method remove(p0: java.lang.String, p1: java.lang.String): boolean public bridge final method size(): int public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -208,6 +214,7 @@ public final class Test_SMSS_AbstractMapStringString { public bridge method remove(p0: java.lang.String, p1: java.lang.String): boolean public bridge final method size(): int public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -235,4 +242,5 @@ public final class Test_SMSS_JMapFinalRemove { public bridge method remove(p0: java.lang.String, p1: java.lang.String): boolean public bridge final method size(): int public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/genericClass_ir.txt b/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/genericClass_ir.txt new file mode 100644 index 00000000000..1b6a41279aa --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/genericClass_ir.txt @@ -0,0 +1,47 @@ +@kotlin.Metadata +public abstract class<Ljava/lang/Object;Ljava/util/Map;Lkotlin/jvm/internal/markers/KMutableMap;> AbstractGenericMap { + // source: 'genericClass.kt' + public @org.jetbrains.annotations.NotNull <()Ljava/util/Collection;> method getValues(): java.util.Collection + public bridge final <()Ljava/util/Collection;> method values(): java.util.Collection + public bridge final <()Ljava/util/Set;>;> method entrySet(): java.util.Set + public @org.jetbrains.annotations.NotNull <()Ljava/util/Set;>;> method getEntries(): java.util.Set + public @org.jetbrains.annotations.NotNull <()Ljava/util/Set;> method getKeys(): java.util.Set + public bridge final <()Ljava/util/Set;> method keySet(): java.util.Set + public @org.jetbrains.annotations.Nullable <(Ljava/lang/Object;)TV;> method get(p0: java.lang.Object): java.lang.Object + public @org.jetbrains.annotations.Nullable <(Ljava/lang/Object;)TV;> method remove(p0: java.lang.Object): java.lang.Object + public <(Ljava/util/Map<+TK;+TV;>;)V> method putAll(@org.jetbrains.annotations.NotNull p0: java.util.Map): void + public @org.jetbrains.annotations.Nullable <(TK;TV;)TV;> method put(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object + public method (): void + public method clear(): void + public method containsKey(p0: java.lang.Object): boolean + public method containsValue(p0: java.lang.Object): boolean + public method getSize(): int + public method isEmpty(): boolean + public bridge final method size(): int + private synthetic final field ;> $$delegate_0: java.util.HashMap + public inner class java/util/Map$Entry +} + +@kotlin.Metadata +public final class<Ljava/lang/Object;Ljava/util/Map;Lkotlin/jvm/internal/markers/KMutableMap;> GenericMap { + // source: 'genericClass.kt' + public @org.jetbrains.annotations.NotNull <()Ljava/util/Collection;> method getValues(): java.util.Collection + public bridge final <()Ljava/util/Collection;> method values(): java.util.Collection + public bridge final <()Ljava/util/Set;>;> method entrySet(): java.util.Set + public @org.jetbrains.annotations.NotNull <()Ljava/util/Set;>;> method getEntries(): java.util.Set + public @org.jetbrains.annotations.NotNull <()Ljava/util/Set;> method getKeys(): java.util.Set + public bridge final <()Ljava/util/Set;> method keySet(): java.util.Set + public @org.jetbrains.annotations.Nullable <(Ljava/lang/Object;)TV;> method get(p0: java.lang.Object): java.lang.Object + public @org.jetbrains.annotations.Nullable <(Ljava/lang/Object;)TV;> method remove(p0: java.lang.Object): java.lang.Object + public <(Ljava/util/Map<+TK;+TV;>;)V> method putAll(@org.jetbrains.annotations.NotNull p0: java.util.Map): void + public @org.jetbrains.annotations.Nullable <(TK;TV;)TV;> method put(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object + public method (): void + public method clear(): void + public method containsKey(p0: java.lang.Object): boolean + public method containsValue(p0: java.lang.Object): boolean + public method getSize(): int + public method isEmpty(): boolean + public bridge final method size(): int + private synthetic final field ;> $$delegate_0: java.util.HashMap + public inner class java/util/Map$Entry +} diff --git a/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/implementsJavaMapWithCustomEntries_ir.txt b/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/implementsJavaMapWithCustomEntries_ir.txt index a9e0d3fd0f2..32ef5015c3f 100644 --- a/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/implementsJavaMapWithCustomEntries_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/implementsJavaMapWithCustomEntries_ir.txt @@ -10,4 +10,5 @@ public final class<LJImpl;> M public method (): void public bridge method getSize(): int public bridge final method size(): int + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/implementsJavaMap_ir.txt b/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/implementsJavaMap_ir.txt index 40cc49a6877..d69c0d8cd26 100644 --- a/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/implementsJavaMap_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/implementsJavaMap_ir.txt @@ -11,6 +11,7 @@ public abstract class<Ljava/lang/Objec public abstract method getSize(): int public abstract method getValues(): java.util.Collection public bridge final method size(): int + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -31,4 +32,5 @@ public abstract class<Ljava/lang/Objec public abstract method getValues(): java.util.Collection public abstract method remove(p0: java.lang.Number): java.lang.Object public bridge final method size(): int + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/implementsMap_ir.txt b/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/implementsMap_ir.txt index 010997f99f8..271c3130f36 100644 --- a/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/implementsMap_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/implementsMap_ir.txt @@ -15,6 +15,7 @@ public abstract class<Ljava/lang/Objec public abstract method getSize(): int public abstract method getValues(): java.util.Collection public bridge final method size(): int + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -43,6 +44,7 @@ public abstract class<Ljava/lang/Objec public abstract method getValues(): java.util.Collection public synthetic bridge method put(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object public bridge final method size(): int + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -66,4 +68,5 @@ public abstract class<Ljava/lang/Object;Ljava/util/Map method getValues(): java.util.Collection public synthetic bridge method put(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object public bridge final method size(): int + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/implementsSortedMap_ir.txt b/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/implementsSortedMap_ir.txt index 1c3a98fd1d2..06afa260a2a 100644 --- a/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/implementsSortedMap_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/implementsSortedMap_ir.txt @@ -34,4 +34,5 @@ public final class<;B:Ljava/lang/Object;>Ljava/la public synthetic bridge method subMap(p0: java.lang.Object, p1: java.lang.Object): java.util.SortedMap public synthetic bridge method tailMap(p0: java.lang.Object): java.util.SortedMap private final @org.jetbrains.annotations.NotNull field ;> map: java.util.SortedMap + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/nonGenericClass_ir.txt b/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/nonGenericClass_ir.txt index 37140cd9ac4..3f239ccda79 100644 --- a/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/nonGenericClass_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/nonGenericClass_ir.txt @@ -26,6 +26,7 @@ public abstract class method remove(p0: java.lang.Object): java.lang.String public bridge final method size(): int private synthetic final field ;> $$delegate_0: java.util.HashMap + public inner class java/util/Map$Entry } @kotlin.Metadata @@ -56,4 +57,5 @@ public final class method remove(p0: java.lang.Object): java.lang.String public bridge final method size(): int private synthetic final field ;> $$delegate_0: java.util.HashMap + public inner class java/util/Map$Entry } diff --git a/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/partiallySpecializedClass_ir.txt b/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/partiallySpecializedClass_ir.txt new file mode 100644 index 00000000000..9ea55190f69 --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/specialBridges/signatures/partiallySpecializedClass_ir.txt @@ -0,0 +1,55 @@ +@kotlin.Metadata +public abstract class<Ljava/lang/Object;Ljava/util/Map;Lkotlin/jvm/internal/markers/KMutableMap;> AbstractStringMap { + // source: 'partiallySpecializedClass.kt' + public @org.jetbrains.annotations.NotNull <()Ljava/util/Collection;> method getValues(): java.util.Collection + public bridge final <()Ljava/util/Collection;> method values(): java.util.Collection + public @org.jetbrains.annotations.NotNull <()Ljava/util/Set;> method getKeys(): java.util.Set + public bridge final <()Ljava/util/Set;> method keySet(): java.util.Set + public bridge final <()Ljava/util/Set;>;> method entrySet(): java.util.Set + public @org.jetbrains.annotations.NotNull <()Ljava/util/Set;>;> method getEntries(): java.util.Set + public bridge final <(Ljava/lang/Object;)TV;> method get(p0: java.lang.Object): java.lang.Object + public bridge final <(Ljava/lang/Object;)TV;> method remove(p0: java.lang.Object): java.lang.Object + public @org.jetbrains.annotations.Nullable <(Ljava/lang/String;)TV;> method get(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.Object + public @org.jetbrains.annotations.Nullable <(Ljava/lang/String;)TV;> method remove(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.Object + public @org.jetbrains.annotations.Nullable <(Ljava/lang/String;TV;)TV;> method put(@org.jetbrains.annotations.NotNull p0: java.lang.String, p1: java.lang.Object): java.lang.Object + public <(Ljava/util/Map<+Ljava/lang/String;+TV;>;)V> method putAll(@org.jetbrains.annotations.NotNull p0: java.util.Map): void + public method (): void + public method clear(): void + public method containsKey(@org.jetbrains.annotations.NotNull p0: java.lang.String): boolean + public bridge final method containsKey(p0: java.lang.Object): boolean + public method containsValue(p0: java.lang.Object): boolean + public method getSize(): int + public method isEmpty(): boolean + public synthetic bridge method put(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object + public bridge final method size(): int + private synthetic final field ;> $$delegate_0: java.util.HashMap + public inner class java/util/Map$Entry +} + +@kotlin.Metadata +public final class<Ljava/lang/Object;Ljava/util/Map;Lkotlin/jvm/internal/markers/KMutableMap;> StringMap { + // source: 'partiallySpecializedClass.kt' + public @org.jetbrains.annotations.NotNull <()Ljava/util/Collection;> method getValues(): java.util.Collection + public bridge final <()Ljava/util/Collection;> method values(): java.util.Collection + public @org.jetbrains.annotations.NotNull <()Ljava/util/Set;> method getKeys(): java.util.Set + public bridge final <()Ljava/util/Set;> method keySet(): java.util.Set + public bridge final <()Ljava/util/Set;>;> method entrySet(): java.util.Set + public @org.jetbrains.annotations.NotNull <()Ljava/util/Set;>;> method getEntries(): java.util.Set + public bridge final <(Ljava/lang/Object;)TV;> method get(p0: java.lang.Object): java.lang.Object + public bridge final <(Ljava/lang/Object;)TV;> method remove(p0: java.lang.Object): java.lang.Object + public @org.jetbrains.annotations.Nullable <(Ljava/lang/String;)TV;> method get(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.Object + public @org.jetbrains.annotations.Nullable <(Ljava/lang/String;)TV;> method remove(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.Object + public @org.jetbrains.annotations.Nullable <(Ljava/lang/String;TV;)TV;> method put(@org.jetbrains.annotations.NotNull p0: java.lang.String, p1: java.lang.Object): java.lang.Object + public <(Ljava/util/Map<+Ljava/lang/String;+TV;>;)V> method putAll(@org.jetbrains.annotations.NotNull p0: java.util.Map): void + public method (): void + public method clear(): void + public method containsKey(@org.jetbrains.annotations.NotNull p0: java.lang.String): boolean + public bridge final method containsKey(p0: java.lang.Object): boolean + public method containsValue(p0: java.lang.Object): boolean + public method getSize(): int + public method isEmpty(): boolean + public synthetic bridge method put(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object + public bridge final method size(): int + private synthetic final field ;> $$delegate_0: java.util.HashMap + public inner class java/util/Map$Entry +} diff --git a/compiler/testData/codegen/bytecodeListing/specialBridges/specialBridgeForGet_ir.txt b/compiler/testData/codegen/bytecodeListing/specialBridges/specialBridgeForGet_ir.txt index 31578c511fa..2bbad276f90 100644 --- a/compiler/testData/codegen/bytecodeListing/specialBridges/specialBridgeForGet_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/specialBridges/specialBridgeForGet_ir.txt @@ -28,6 +28,7 @@ public abstract class AMap1 { public method replaceAll(p0: java.util.function.BiFunction): void public bridge final method size(): int public bridge final method values(): java.util.Collection + public inner class java/util/Map$Entry } @kotlin.Metadata diff --git a/compiler/testData/codegen/bytecodeText/capturedVarsOptimization/capturedValInLambdaInitializedInside.kt b/compiler/testData/codegen/bytecodeText/capturedVarsOptimization/capturedValInLambdaInitializedInside.kt index 8e7d1c8d810..9dcbb84251e 100644 --- a/compiler/testData/codegen/bytecodeText/capturedVarsOptimization/capturedValInLambdaInitializedInside.kt +++ b/compiler/testData/codegen/bytecodeText/capturedVarsOptimization/capturedValInLambdaInitializedInside.kt @@ -9,4 +9,9 @@ fun box(): String { return x } +// JVM_TEMPLATES // 0 ObjectRef + +// JVM_IR_TEMPLATES +// 2 ObjectRef +// 1 INNERCLASS kotlin.jvm.internal.Ref\$ObjectRef kotlin.jvm.internal.Ref ObjectRef \ No newline at end of file diff --git a/compiler/testData/codegen/bytecodeText/capturedVarsOptimization/returnValueOfArrayConstructor.kt b/compiler/testData/codegen/bytecodeText/capturedVarsOptimization/returnValueOfArrayConstructor.kt index 2887fa456fc..bc4d2ddb22a 100644 --- a/compiler/testData/codegen/bytecodeText/capturedVarsOptimization/returnValueOfArrayConstructor.kt +++ b/compiler/testData/codegen/bytecodeText/capturedVarsOptimization/returnValueOfArrayConstructor.kt @@ -1,5 +1,10 @@ fun f() = IntArray(1) { run { return@IntArray 1 } } -// On JVM_IR, the return is an assignment to a captured var followed by -// a non-local `break` from a `do ... while (false)`. The var should be optimized. +// JVM_TEMPLATES // 0 IntRef + +// On JVM_IR, the return is an assignment to a captured var followed by +// a non-local `break` from a `do ... while (false)`. The var should be optimized, but InnerClasses attribute will be added anyway. +// JVM_IR_TEMPLATES +// 2 IntRef +// 1 INNERCLASS kotlin.jvm.internal.Ref\$IntRef kotlin.jvm.internal.Ref IntRef \ No newline at end of file diff --git a/compiler/testData/codegen/bytecodeText/innerClasses/kt27936.kt b/compiler/testData/codegen/bytecodeText/innerClasses/kt27936.kt new file mode 100644 index 00000000000..03968817a89 --- /dev/null +++ b/compiler/testData/codegen/bytecodeText/innerClasses/kt27936.kt @@ -0,0 +1,141 @@ +// TARGET_BACKEND: JVM_IR + +// FILE: classes.kt + +public class A0 { + public class B0 { + public class C0 { + public class D0 + } + } +} + +public class A1 { + public class B1 { + public class C1 { + public class D1 + } + } +} + +public class A2 { + public class B2 { + public class C2 { + public class D2 + } + } +} + +object A3 { + interface B3 { + interface C3 { + interface D3 + } + } +} + +public class A4 { + public class B4 { + public class C4 { + public class D4 + } + } +} + +public class A5 { + public class B5 { + public class C5 { + public class D5 + } + } +} + +public class A6 { + public class B6 { + public class C6 { + public class D6 + } + } +} + +@Target(AnnotationTarget.VALUE_PARAMETER) +@Retention(AnnotationRetention.RUNTIME) +annotation class ClassHolder(val value: kotlin.reflect.KClass<*>) + +public class A7 { + public class B7 { + public class C7 { + public class D7 + } + } +} + +@JvmInline +public value class A8(private val value: Int) { + @JvmInline + public value class B8(private val value: Int) { + @JvmInline + public value class C8(private val value: Int) { + @JvmInline + public value class D8(private val value: Int) + } + } +} + + +inline fun foo() = null + + +// FILE: X.kt +class X { + fun f0(t: List>>) {} + fun f1(): A1.B1.C1? = null + fun f2() { + foo() + } + fun f3(x: Any): Any? = x as? A3.B3.C3 + fun f4(): String { + val x = listOf() + return x.toString() + } + + class Y { + fun f5(): String { + val x: A5.B5.C5? = null + return x.toString() + } + fun f6(): A6.B6.C6? = null + + fun f7(@ClassHolder(A7.B7.C7::class) x: Int) {} + + fun f8() = A8.B8.C8::class.toString() + } +} + + +// @X.class: +// 10 INNERCLASS +// 1 INNERCLASS java.lang.Thread\$State java.lang.Thread State +// 0 INNERCLASS A0\$B0 A0 B0 +// 0 INNERCLASS A0\$B0\$C0 A0\$B0 C0 +// 1 INNERCLASS A1\$B1 A1 B1 +// 1 INNERCLASS A1\$B1\$C1 A1\$B1 C1 +// 1 INNERCLASS A2\$B2 A2 B2 +// 1 INNERCLASS A2\$B2\$C2 A2\$B2 C2 +// 1 INNERCLASS A3\$B3 A3 B3 +// 1 INNERCLASS A3\$B3\$C3 A3\$B3 C3 +// 1 INNERCLASS A4\$B4 A4 B4 +// 1 INNERCLASS A4\$B4\$C4 A4\$B4 C4 +// 1 INNERCLASS X\$Y X Y + +// @X$Y.class: +// 9 INNERCLASS +// 1 INNERCLASS X\$Y X Y +// 1 INNERCLASS A5\$B5 A5 B5 +// 1 INNERCLASS A5\$B5\$C5 A5\$B5 C5 +// 1 INNERCLASS A6\$B6 A6 B6 +// 1 INNERCLASS A6\$B6\$C6 A6\$B6 C6 +// 1 INNERCLASS A7\$B7 A7 B7 +// 1 INNERCLASS A7\$B7\$C7 A7\$B7 C7 +// 1 INNERCLASS A8\$B8 A8 B8 +// 1 INNERCLASS A8\$B8\$C8 A8\$B8 C8 diff --git a/compiler/testData/codegen/bytecodeText/kt10259.kt b/compiler/testData/codegen/bytecodeText/kt10259.kt index 4ee2690ed4d..6ae3b161407 100644 --- a/compiler/testData/codegen/bytecodeText/kt10259.kt +++ b/compiler/testData/codegen/bytecodeText/kt10259.kt @@ -27,6 +27,7 @@ inline fun test(s: () -> Unit) { // this behavior is equivalent to javac and seems to be correct. // JVM_IR_TEMPLATES -// 5 INNERCLASS +// 8 INNERCLASS // 3 INNERCLASS Kt10259Kt\$box\$1\$lam1\$1 null null // 2 INNERCLASS Kt10259Kt\$box\$1\$lam1\$1\$lam2\$1 +// 3 INNERCLASS kotlin.jvm.internal.Ref\$ObjectRef kotlin.jvm.internal.Ref ObjectRef diff --git a/compiler/testData/codegen/bytecodeText/kt10259_2.kt b/compiler/testData/codegen/bytecodeText/kt10259_2.kt index 75030bb1932..9a4d68ff24d 100644 --- a/compiler/testData/codegen/bytecodeText/kt10259_2.kt +++ b/compiler/testData/codegen/bytecodeText/kt10259_2.kt @@ -15,8 +15,17 @@ inline fun test(crossinline s: () -> Unit) { }.let { it() } } +// JVM_TEMPLATES // 3 INNERCLASS Kt10259_2Kt\$test\$1 null // 2 INNERCLASS Kt10259_2Kt\$test\$1\$1 // 2 INNERCLASS Kt10259_2Kt\$box\$\$inlined\$test\$1\s // 2 INNERCLASS Kt10259_2Kt\$box\$\$inlined\$test\$1\$1 -// 9 INNERCLASS \ No newline at end of file +// 9 INNERCLASS + +// JVM_IR_TEMPLATES +// 3 INNERCLASS Kt10259_2Kt\$test\$1 null +// 2 INNERCLASS Kt10259_2Kt\$test\$1\$1 +// 2 INNERCLASS Kt10259_2Kt\$box\$\$inlined\$test\$1\s +// 2 INNERCLASS Kt10259_2Kt\$box\$\$inlined\$test\$1\$1 +// 1 INNERCLASS kotlin.jvm.internal.Ref\$ObjectRef kotlin.jvm.internal.Ref ObjectRef +// 10 INNERCLASS \ No newline at end of file diff --git a/compiler/testData/codegen/bytecodeText/kt10259_3.kt b/compiler/testData/codegen/bytecodeText/kt10259_3.kt index bfd670ca1be..12f89c204ea 100644 --- a/compiler/testData/codegen/bytecodeText/kt10259_3.kt +++ b/compiler/testData/codegen/bytecodeText/kt10259_3.kt @@ -38,11 +38,11 @@ inline fun test(crossinline s: () -> Unit) { // this behavior is equivalent to javac and seems to be correct. // JVM_IR_TEMPLATES -// 14 INNERCLASS +// 17 INNERCLASS // 3 INNERCLASS Kt10259_3Kt\$box\$1\$lam1\$1 null null // 2 INNERCLASS Kt10259_3Kt\$box\$1\$lam1\$1\$lam2\$1 null null // 2 INNERCLASS Kt10259_3Kt\$box\$\$inlined\$test\$1 null null // 2 INNERCLASS Kt10259_3Kt\$box\$\$inlined\$test\$1\$1 null null // 3 INNERCLASS Kt10259_3Kt\$test\$1 null null // 2 INNERCLASS Kt10259_3Kt\$test\$1\$1 null null - +// 3 INNERCLASS kotlin.jvm.internal.Ref\$ObjectRef kotlin.jvm.internal.Ref ObjectRef diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBytecodeTextTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBytecodeTextTestGenerated.java index 3e735de26cd..1ecaf08c58e 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBytecodeTextTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBytecodeTextTestGenerated.java @@ -4042,6 +4042,12 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @Test + @TestMetadata("kt27936.kt") + public void testKt27936() throws Exception { + runTest("compiler/testData/codegen/bytecodeText/innerClasses/kt27936.kt"); + } + @Test @TestMetadata("nestedClassInAnnotationArgument.kt") public void testNestedClassInAnnotationArgument() throws Exception { diff --git a/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/BytecodeListingTextCollectingVisitor.kt b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/BytecodeListingTextCollectingVisitor.kt index 6f8bf802925..96ebb3d96ce 100644 --- a/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/BytecodeListingTextCollectingVisitor.kt +++ b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/BytecodeListingTextCollectingVisitor.kt @@ -80,7 +80,7 @@ class BytecodeListingTextCollectingVisitor( override fun shouldWriteClass(node: ClassNode): Boolean = !node.name.startsWith("helpers/") override fun shouldWriteMethod(access: Int, name: String, desc: String): Boolean = true override fun shouldWriteField(access: Int, name: String, desc: String): Boolean = true - override fun shouldWriteInnerClass(name: String, outerName: String?, innerName: String?): Boolean = true + override fun shouldWriteInnerClass(name: String, outerName: String?, innerName: String?): Boolean = !name.startsWith("helpers/") } } diff --git a/plugins/jvm-abi-gen/testData/content/class/signatures.txt b/plugins/jvm-abi-gen/testData/content/class/signatures.txt index c6e0393eedd..458ff72c3cb 100644 --- a/plugins/jvm-abi-gen/testData/content/class/signatures.txt +++ b/plugins/jvm-abi-gen/testData/content/class/signatures.txt @@ -28,8 +28,8 @@ public final class test/Class$NestedInnerClass$NestedNestedInnerClass { @kotlin.Metadata final class test/Class$NestedInnerClass { // source: 'classes.kt' - public final inner class test/Class$NestedInnerClass$NestedNestedInnerClass private final inner class test/Class$NestedInnerClass + public final inner class test/Class$NestedInnerClass$NestedNestedInnerClass public method (): void } @kotlin.Metadata