KT-27936 Generate InnerClasses attributes

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,

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 {

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<TypePathInfo<IrConstructorCall>> =
-            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()
 }

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<IrClass>()
+
+    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<IrClass>()
-
     // TODO: the names produced by generators in this map depend on the order in which methods are generated; see above.
     private val regeneratedObjectNameGenerators = mutableMapOf<String, NameGenerator>()
 
@@ -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 != "<clinit>" }
+                val method = enclosingFunction?.let(methodSignatureMapper::mapAsmMethod)?.takeIf { it.name != "<clinit>" }
                 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 '<Continuation>' 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<IrDeclaration>(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
         }
     }
 

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,

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<out Throwable>)
         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,

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<IrType> {
     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())
     }
 }

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<RawSignature, MutableSet<IrFunction>>()
     private val fieldsBySignature = LinkedHashMap<RawSignature, MutableSet<IrField>>()
@@ -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<IrDeclaration>
     ): ConflictingJvmDeclarationsData =
         ConflictingJvmDeclarationsData(
-            type.internalName,
+            classCodegen.type.internalName,
             classOrigin,
             rawSignature,
             methods.map { it.getJvmDeclarationOrigin() }

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
         )
     )

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))

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()
         }
     }

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)
         }

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)
         }
     }

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)
         }
     }
 }

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)

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)
         }
     }

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)

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()}'")
     }

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)
             }

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)

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)

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,

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<Type> = expression.argTypes(context)
+    val classCodegen: ClassCodegen,
+    val argsTypes: List<Type> = 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<Type> = expression.argTypes(context),
+            classCodegen: ClassCodegen,
+            argsTypes: List<Type> = 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<Type> = expression.argTypes(context),
+            classCodegen: ClassCodegen,
+            argsTypes: List<Type> = 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<Type> {
+fun IrFunctionAccessExpression.argTypes(classCodegen: ClassCodegen): ArrayList<Type> {
     val callee = symbol.owner
-    val signature = context.methodSignatureMapper.mapSignatureSkipGeneric(callee)
+    val signature = classCodegen.methodSignatureMapper.mapSignatureSkipGeneric(callee)
     return arrayListOf<Type>().apply {
         if (dispatchReceiver != null) {
-            add(context.typeMapper.mapClass(callee.parentAsClass))
+            add(classCodegen.typeMapper.mapClass(callee.parentAsClass))
         }
         addAll(signature.asmMethod.argumentTypes)
     }

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)
         }
     }

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))
     }
 }

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()}",

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

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)
         }
     }

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)
         }
     }

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,

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",

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)
     }

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)
         }
     }

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",

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", "<init>", "()V", false)

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

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))
         }
     }

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) {
 
         }
     }

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

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<SpecialBridge> {
-        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

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,

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)

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

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()

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.

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)
 

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()

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 -> ""

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<IrSimpleFunction>
     ): Collection<IrSimpleFunction> {
-        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<Method, IrSimpleFunction>()
         for (overridden in extraOverriddenMethods) {
-            val jvmOverriddenMethod = backendContext.methodSignatureMapper.mapAsmMethod(overridden)
+            val jvmOverriddenMethod = backendContext.defaultMethodSignatureMapper.mapAsmMethod(overridden)
             if (jvmOverriddenMethod != jvmInstanceMethod && jvmOverriddenMethod != jvmSamMethod) {
                 signatureToNonFakeOverride[jvmOverriddenMethod] = overridden
             }

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)
         }
     }
 

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.

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<IrFunctionSymbol, Method>()
 
     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)

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<IrExpression> {
 }
 
 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"))

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<JvmSignatureWriter> {
+open class IrTypeMapper(private val context: JvmBackendContext) : KotlinTypeMapperBase(), TypeMappingContext<JvmSignatureWriter> {
     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

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 =

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
                     )

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
 }

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
 }

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
 }

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

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
 }

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 <init>(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
+}

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

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

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

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

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

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 <init>(): void
+}
+
+@kotlin.Metadata
+public final class DerivedClassWithSpecialization {
+    // source: 'main.kt'
+    public method <init>(): 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
+}

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

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
 }

compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/byteShortMap_ir.txt

@@ -23,4 +23,5 @@ public abstract class<Ljava/lang/Object;Ljava/util/Map<Ljava/lang/Byte;Ljava/lan
     public synthetic bridge <null> method remove(p0: java.lang.Object): java.lang.Object
     public <null> method remove(p0: java.lang.Object): java.lang.Short
     public bridge final <null> method size(): int
+    public inner class java/util/Map$Entry
 }

compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/byteShortMutableMap_ir.txt

@@ -20,4 +20,5 @@ public abstract class<Ljava/lang/Object;Ljava/util/Map<Ljava/lang/Byte;Ljava/lan
     public synthetic bridge final <null> method remove(p0: java.lang.Object): java.lang.Object
     public bridge final <null> method remove(p0: java.lang.Object): java.lang.Short
     public bridge final <null> method size(): int
+    public inner class java/util/Map$Entry
 }

compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericMap_ir.txt

@@ -14,4 +14,5 @@ public abstract class<<K:Ljava/lang/Object;V:Ljava/lang/Object;>Ljava/lang/Objec
     public abstract <null> method getSize(): int
     public abstract <null> method getValues(): java.util.Collection
     public bridge final <null> method size(): int
+    public inner class java/util/Map$Entry
 }

compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericMutableMap_ir.txt

@@ -10,4 +10,5 @@ public abstract class<<K:Ljava/lang/Object;V:Ljava/lang/Object;>Ljava/lang/Objec
     public abstract <null> method getSize(): int
     public abstract <null> method getValues(): java.util.Collection
     public bridge final <null> method size(): int
+    public inner class java/util/Map$Entry
 }

compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericStringMap_ir.txt

@@ -19,4 +19,5 @@ public abstract class<<K:Ljava/lang/Object;>Ljava/lang/Object;Ljava/util/Map<TK;
     public synthetic bridge <null> method remove(p0: java.lang.Object): java.lang.Object
     public <null> method remove(p0: java.lang.Object): java.lang.String
     public bridge final <null> method size(): int
+    public inner class java/util/Map$Entry
 }

compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/genericStringMutableMap_ir.txt

@@ -14,4 +14,5 @@ public abstract class<<K:Ljava/lang/Object;>Ljava/lang/Object;Ljava/util/Map<TK;
     public abstract <null> method getValues(): java.util.Collection
     public synthetic bridge <null> method remove(p0: java.lang.Object): java.lang.Object
     public bridge final <null> method size(): int
+    public inner class java/util/Map$Entry
 }

compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/mapEntry_ir.txt

@@ -4,6 +4,7 @@ public abstract class<Ljava/lang/Object;Ljava/util/Map$Entry<Ljava/lang/Byte;Lja
     public <null> method <init>(): void
     public synthetic bridge <null> method setValue(p0: java.lang.Object): java.lang.Object
     public <null> method setValue(p0: short): java.lang.Short
+    public inner class java/util/Map$Entry
 }
 
 @kotlin.Metadata
@@ -11,6 +12,7 @@ public abstract class<<K:Ljava/lang/Object;V:Ljava/lang/Object;>Ljava/lang/Objec
     // source: 'mapEntry.kt'
     public <(TV;)TV;> method setValue(p0: java.lang.Object): java.lang.Object
     public <null> method <init>(): void
+    public inner class java/util/Map$Entry
 }
 
 @kotlin.Metadata
@@ -19,6 +21,7 @@ public abstract class<<K:Ljava/lang/Object;>Ljava/lang/Object;Ljava/util/Map$Ent
     public <null> method <init>(): void
     public synthetic bridge <null> method setValue(p0: java.lang.Object): java.lang.Object
     public <null> 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<Ljava/lang/Object;Ljava/util/Map$Entry<Ljava/lang/Number;L
     public <null> method <init>(): void
     public synthetic bridge <null> method setValue(p0: java.lang.Object): java.lang.Object
     public <null> 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<<V:Ljava/lang/Object;>Ljava/lang/Object;Ljava/util/Map$Ent
     // source: 'mapEntry.kt'
     public <(TV;)TV;> method setValue(p0: java.lang.Object): java.lang.Object
     public <null> method <init>(): void
+    public inner class java/util/Map$Entry
 }

compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/mutableMapEntry_ir.txt

@@ -0,0 +1,34 @@
+@kotlin.Metadata
+public abstract class<Ljava/lang/Object;Ljava/util/Map$Entry<Ljava/lang/Byte;Ljava/lang/Short;>;Lkotlin/jvm/internal/markers/KMutableMap$Entry;>  ByteShortMutableMapEntry {
+    // source: 'mutableMapEntry.kt'
+    public <null> method <init>(): void
+    public inner class java/util/Map$Entry
+}
+
+@kotlin.Metadata
+public abstract class<<K:Ljava/lang/Object;V:Ljava/lang/Object;>Ljava/lang/Object;Ljava/util/Map$Entry<TK;TV;>;Lkotlin/jvm/internal/markers/KMutableMap$Entry;>  GenericMutableMutableMapEntry {
+    // source: 'mutableMapEntry.kt'
+    public <null> method <init>(): void
+    public inner class java/util/Map$Entry
+}
+
+@kotlin.Metadata
+public abstract class<<K:Ljava/lang/Object;>Ljava/lang/Object;Ljava/util/Map$Entry<TK;Ljava/lang/String;>;Lkotlin/jvm/internal/markers/KMutableMap$Entry;>  GenericStringMutableMapEntry {
+    // source: 'mutableMapEntry.kt'
+    public <null> method <init>(): void
+    public inner class java/util/Map$Entry
+}
+
+@kotlin.Metadata
+public abstract class<Ljava/lang/Object;Ljava/util/Map$Entry<Ljava/lang/Number;Ljava/lang/String;>;Lkotlin/jvm/internal/markers/KMutableMap$Entry;>  NumberStringMutableMapEntry {
+    // source: 'mutableMapEntry.kt'
+    public <null> method <init>(): void
+    public inner class java/util/Map$Entry
+}
+
+@kotlin.Metadata
+public abstract class<<V:Ljava/lang/Object;>Ljava/lang/Object;Ljava/util/Map$Entry<Ljava/lang/String;TV;>;Lkotlin/jvm/internal/markers/KMutableMap$Entry;>  StringGenericMutableMapEntry {
+    // source: 'mutableMapEntry.kt'
+    public <null> method <init>(): void
+    public inner class java/util/Map$Entry
+}

compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/numberStringMap_ir.txt

@@ -23,4 +23,5 @@ public abstract class<Ljava/lang/Object;Ljava/util/Map<Ljava/lang/Number;Ljava/l
     public synthetic bridge <null> method remove(p0: java.lang.Object): java.lang.Object
     public <null> method remove(p0: java.lang.Object): java.lang.String
     public bridge final <null> method size(): int
+    public inner class java/util/Map$Entry
 }

compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/numberStringMutableMap_ir.txt

@@ -20,4 +20,5 @@ public abstract class<Ljava/lang/Object;Ljava/util/Map<Ljava/lang/Number;Ljava/l
     public synthetic bridge final <null> method remove(p0: java.lang.Object): java.lang.Object
     public bridge final <null> method remove(p0: java.lang.Object): java.lang.String
     public bridge final <null> method size(): int
+    public inner class java/util/Map$Entry
 }

compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/specializedGenericMap_ir.txt

@@ -14,6 +14,7 @@ public abstract class<<K:Ljava/lang/Object;V:Ljava/lang/Object;>Ljava/lang/Objec
     public abstract <null> method getSize(): int
     public abstract <null> method getValues(): java.util.Collection
     public bridge final <null> method size(): int
+    public inner class java/util/Map$Entry
 }
 
 @kotlin.Metadata

compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/stringGenericMap_ir.txt

@@ -19,4 +19,5 @@ public abstract class<<V:Ljava/lang/Object;>Ljava/lang/Object;Ljava/util/Map<Lja
     public abstract <null> method getValues(): java.util.Collection
     public synthetic bridge <null> method put(p0: java.lang.Object, p1: java.lang.Object): java.lang.Object
     public bridge final <null> method size(): int
+    public inner class java/util/Map$Entry
 }

compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures/stringGenericMutableMap_ir.txt

@@ -16,4 +16,5 @@ public abstract class<<V:Ljava/lang/Object;>Ljava/lang/Object;Ljava/util/Map<Lja
     public abstract <null> method getValues(): java.util.Collection
     public abstract <null> method remove(p0: java.lang.String): java.lang.Object
     public bridge final <null> method size(): int
+    public inner class java/util/Map$Entry
 }

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

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

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

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

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 <init>(@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 <init>(@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 <init>(@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 <init>(@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 <init>(@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 <init>(@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 <init>(@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 <init>(@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 <init>(@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 <init>(@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[]
+}

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 <init>(@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 <init>(@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 <init>(@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 <init>(@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 <init>(@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 <init>(@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 <init>(@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 <init>(@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 <init>(@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 <init>(@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[]
+}

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 <init>(): 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

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
 }

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
 }

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
 }

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
 }

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
 }

compiler/testData/codegen/bytecodeListing/coroutines/suspendConversion_ir.txt

@@ -6,6 +6,7 @@ synthetic final class SuspendConversionKt$test$1 {
     method <init>(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

compiler/testData/codegen/bytecodeListing/deprecated/inheritingDeprecation_ir.txt

@@ -0,0 +1,84 @@
+@kotlin.Metadata
+public final class DefaultImpl {
+    // source: 'inheritingDeprecation.kt'
+    public method <init>(): 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 <init>(): 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 <init>(@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 <init>(@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 <init>(): 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 <init>(): 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
+}

compiler/testData/codegen/bytecodeListing/inline/enclosingInfo/kt10259_ir.txt

@@ -19,6 +19,7 @@ final class _2Kt$box$1$1$1 {
     method <init>(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 <init>(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

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

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