JVM: workaround inline class mapping issue in old backend

The real fix will be removal of `StackValue` and
`StaticTypeMapperForOldBackend`, and it will be done as a part of
KT-71197. This change is a relatively safe workaround for the issue.

The problem is caused by 588361c, where
`computeExpandedTypeForInlineClass` started to use more things from
`TypeSystemContext`, namely `builtIns`, to be able to correctly map
generic types based on inline classes over arrays.

 #KT-79547 Fixed

Author: udalov

analysis/low-level-api-fir/tests-gen/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLBlackBoxTestGenerated.java

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.codegen.state
 
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.codegen.signature.AsmTypeFactory
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
@@ -18,6 +19,7 @@ import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeSystemCommonBackendContext
 import org.jetbrains.kotlin.types.checker.SimpleClassicTypeSystemContext
 import org.jetbrains.kotlin.types.model.KotlinTypeMarker
+import org.jetbrains.kotlin.types.typeUtil.builtIns
 import org.jetbrains.org.objectweb.asm.Type
 
 // This class exists only because it's used to box/unbox inline classes in the static method StackValue.coerce in the old backend, which
@@ -26,7 +28,7 @@ object StaticTypeMapperForOldBackend : KotlinTypeMapperBase() {
     override val typeSystem: TypeSystemCommonBackendContext
         get() = SimpleClassicTypeSystemContext
 
-    private val staticTypeMappingConfiguration = object : TypeMappingConfiguration<Type> {
+    private class Configuration(override val builtIns: KotlinBuiltIns) : TypeMappingConfiguration<Type> {
         override fun commonSupertype(types: Collection<KotlinType>): KotlinType {
             return CommonSupertypes.commonSupertype(types)
         }
@@ -51,7 +53,7 @@ object StaticTypeMapperForOldBackend : KotlinTypeMapperBase() {
     override fun mapClass(classifier: ClassifierDescriptor): Type = TODO("Should not be called")
 
     override fun mapTypeCommon(type: KotlinTypeMarker, mode: TypeMappingMode): Type {
-        return mapType(type as KotlinType, AsmTypeFactory, mode, staticTypeMappingConfiguration, null)
+        return mapType(type as KotlinType, AsmTypeFactory, mode, Configuration(type.builtIns), null)
     }
 
     private fun generateErrorMessageForErrorType(type: KotlinType, descriptor: DeclarationDescriptor): String {

analysis/low-level-api-fir/tests-gen/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLReversedBlackBoxTestGenerated.java

@@ -0,0 +1,24 @@
+// TARGET_BACKEND: JVM
+// WITH_STDLIB
+
+@JvmInline
+public value class KoneMutableArray<Element>(internal val array: Array<Element>)
+
+public inline fun <reified Element> KoneMutableArray(size: UInt, initializer: (UInt) -> Element): KoneMutableArray<Element> =
+    KoneMutableArray(Array(size.toInt()) { initializer(it.toUInt()) })
+
+@JvmInline
+public value class KoneArraySettableList<Element> @PublishedApi internal constructor(
+    internal val data: KoneMutableArray<Any?>,
+)
+
+public inline fun <Element> KoneArraySettableList(size: UInt, initializer: (index: UInt) -> Element): KoneArraySettableList<Element> =
+    KoneArraySettableList(KoneMutableArray(size, initializer))
+
+fun box(): String {
+    val koneList = run {
+        val list = listOf(1, 2, 3, 4)
+        KoneArraySettableList(list.size.toUInt()) { list[it.toInt()] }
+    }
+    return "OK"
+}

compiler/backend/src/org/jetbrains/kotlin/codegen/state/StaticTypeMapperForOldBackend.kt

@@ -12,8 +12,9 @@ import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.name.SpecialNames
 import org.jetbrains.kotlin.resolve.isInlineClass
 import org.jetbrains.kotlin.types.*
-import org.jetbrains.kotlin.types.error.ErrorUtils
+import org.jetbrains.kotlin.types.checker.ClassicTypeSystemContext
 import org.jetbrains.kotlin.types.checker.SimpleClassicTypeSystemContext
+import org.jetbrains.kotlin.types.error.ErrorUtils
 import org.jetbrains.kotlin.types.typeUtil.makeNullable
 import org.jetbrains.kotlin.types.typeUtil.replaceArgumentsWithStarProjections
 import org.jetbrains.kotlin.types.typeUtil.representativeUpperBound
@@ -28,6 +29,9 @@ interface TypeMappingConfiguration<out T : Any> {
 
     // returns null when type doesn't need to be preprocessed
     fun preprocessType(kotlinType: KotlinType): KotlinType? = null
+
+    val builtIns: KotlinBuiltIns?
+        get() = null
 }
 
 fun <T : Any> mapType(
@@ -117,7 +121,11 @@ fun <T : Any> mapType(
         descriptor is ClassDescriptor -> {
             // NB if inline class is recursive, it's ok to map it as wrapped
             if (descriptor.isInlineClass() && !mode.needInlineClassWrapping) {
-                val expandedType = SimpleClassicTypeSystemContext.computeExpandedTypeForInlineClass(kotlinType) as KotlinType?
+                val typeSystemContext = object : ClassicTypeSystemContext {
+                    override val builtIns: KotlinBuiltIns
+                        get() = typeMappingConfiguration.builtIns ?: super.builtIns
+                }
+                val expandedType = typeSystemContext.computeExpandedTypeForInlineClass(kotlinType) as KotlinType?
                 if (expandedType != null) {
                     return mapType(
                         expandedType, factory, mode.wrapInlineClassesMode(), typeMappingConfiguration,