Do not use KotlinTypeMapper in enum values/valueOf intrinsic

Remove KotlinTypeMapper from inlineIntrinsics.kt completely

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.kt

@@ -29,8 +29,10 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DescriptorWithContainerSource
 import org.jetbrains.kotlin.types.KotlinType
+import org.jetbrains.kotlin.types.TypeSystemCommonBackendContext
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.isFunctionLiteral
 import org.jetbrains.kotlin.types.expressions.LabelResolver
+import org.jetbrains.kotlin.types.model.TypeParameterMarker
 import org.jetbrains.org.objectweb.asm.Label
 import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.Type
@@ -127,13 +129,16 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
     }
 
     fun performInline(
-        typeArguments: Map<TypeParameterDescriptor, KotlinType>?,
+        typeArguments: List<TypeParameterMarker>?,
         callDefault: Boolean,
+        typeSystem: TypeSystemCommonBackendContext,
         codegen: BaseExpressionCodegen
     ) {
         var nodeAndSmap: SMAPAndMethodNode? = null
         try {
-            nodeAndSmap = createInlineMethodNode(functionDescriptor, methodOwner, jvmSignature, callDefault, typeArguments, state, sourceCompiler)
+            nodeAndSmap = createInlineMethodNode(
+                functionDescriptor, methodOwner, jvmSignature, callDefault, typeArguments, typeSystem, state, sourceCompiler
+            )
             endCall(inlineCall(nodeAndSmap, callDefault))
         } catch (e: CompilationException) {
             throw e
@@ -514,11 +519,12 @@ abstract class InlineCodegen<out T : BaseExpressionCodegen>(
             methodOwner: Type,
             jvmSignature: JvmMethodSignature,
             callDefault: Boolean,
-            typeArguments: Map<TypeParameterDescriptor, KotlinType>?,
+            typeArguments: List<TypeParameterMarker>?,
+            typeSystem: TypeSystemCommonBackendContext,
             state: GenerationState,
             sourceCompilerForInline: SourceCompilerForInline
         ): SMAPAndMethodNode {
-            val intrinsic = generateInlineIntrinsic(state, functionDescriptor, typeArguments)
+            val intrinsic = generateInlineIntrinsic(state, functionDescriptor, typeArguments, typeSystem)
             if (intrinsic != null) {
                 return SMAPAndMethodNode(intrinsic, createDefaultFakeSMAP())
             }

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegenForDefaultBody.kt

@@ -39,8 +39,9 @@ class InlineCodegenForDefaultBody(
     }
 
     override fun genCallInner(callableMethod: Callable, resolvedCall: ResolvedCall<*>?, callDefault: Boolean, codegen: ExpressionCodegen) {
-        val nodeAndSmap =
+        val nodeAndSmap = InlineCodegen.createInlineMethodNode(
-            InlineCodegen.createInlineMethodNode(function, methodOwner, jvmSignature, callDefault, null, state, sourceCompilerForInline)
+            function, methodOwner, jvmSignature, callDefault, null, codegen.typeSystem, state, sourceCompilerForInline
+        )
         val childSourceMapper = InlineCodegen.createNestedSourceMapper(nodeAndSmap, sourceMapper)
 
         val node = nodeAndSmap.node

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/PsiInlineCodegen.kt

@@ -64,7 +64,7 @@ class PsiInlineCodegen(
             return
         }
         try {
-            performInline(resolvedCall?.typeArguments, callDefault, codegen)
+            performInline(resolvedCall?.typeArguments?.keys?.toList(), callDefault, codegen.typeSystem, codegen)
         } finally {
             state.globalInlineContext.exitFromInliningOf(resolvedCall)
         }

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/inlineIntrinsics.kt

@@ -15,16 +15,12 @@ import org.jetbrains.kotlin.codegen.coroutines.createMethodNodeForSuspendCorouti
 import org.jetbrains.kotlin.codegen.createMethodNodeForAlwaysEnabledAssert
 import org.jetbrains.kotlin.codegen.isBuiltinAlwaysEnabledAssert
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
-import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.resolve.calls.checkers.TypeOfChecker
 import org.jetbrains.kotlin.resolve.calls.checkers.isBuiltInCoroutineContext
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.*
-import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeSystemCommonBackendContext
-import org.jetbrains.kotlin.types.checker.ClassicTypeSystemContextImpl
 import org.jetbrains.kotlin.types.model.KotlinTypeMarker
 import org.jetbrains.kotlin.types.model.TypeArgumentMarker
 import org.jetbrains.kotlin.types.model.TypeParameterMarker
@@ -37,19 +33,16 @@ import org.jetbrains.org.objectweb.asm.tree.MethodNode
 internal fun generateInlineIntrinsic(
     state: GenerationState,
     descriptor: FunctionDescriptor,
-    typeArguments: Map<TypeParameterDescriptor, KotlinType>?
+    typeParameters: List<TypeParameterMarker>?,
+    typeSystem: TypeSystemCommonBackendContext
 ): MethodNode? {
     val languageVersionSettings = state.languageVersionSettings
-    val typeMapper = state.typeMapper
-
-    // TODO
-    val typeSystem = ClassicTypeSystemContextImpl(state.module.builtIns)
 
     return when {
         isSpecialEnumMethod(descriptor) ->
-            createSpecialEnumMethodBody(descriptor.name.asString(), typeArguments!!.keys.single(), typeMapper, typeSystem)
+            createSpecialEnumMethodBody(descriptor.name.asString(), typeParameters!!.single(), typeSystem)
         TypeOfChecker.isTypeOf(descriptor) ->
-            typeSystem.createTypeOfMethodBody(typeArguments!!.keys.single())
+            typeSystem.createTypeOfMethodBody(typeParameters!!.single())
         descriptor.isBuiltInIntercepted(languageVersionSettings) ->
             createMethodNodeForIntercepted(languageVersionSettings)
         descriptor.isBuiltInCoroutineContext(languageVersionSettings) ->
@@ -77,11 +70,10 @@ private fun isSpecialEnumMethod(descriptor: FunctionDescriptor): Boolean {
 }
 
 private fun createSpecialEnumMethodBody(
-    name: String, typeParameter: TypeParameterDescriptor, typeMapper: KotlinTypeMapper, typeSystem: TypeSystemCommonBackendContext
+    name: String, typeParameter: TypeParameterMarker, typeSystem: TypeSystemCommonBackendContext
 ): MethodNode {
     val isValueOf = "enumValueOf" == name
-    val invokeType = typeMapper.mapType(typeParameter.defaultType)
+    val desc = getSpecialEnumFunDescriptor(ENUM_TYPE, isValueOf)
-    val desc = getSpecialEnumFunDescriptor(invokeType, isValueOf)
     val node = MethodNode(Opcodes.API_VERSION, Opcodes.ACC_STATIC, "fake", desc, null, null)
     ReifiedTypeInliner.putReifiedOperationMarkerIfNeeded(
         typeParameter, false, ReifiedTypeInliner.OperationKind.ENUM_REIFIED, InstructionAdapter(node), typeSystem

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineCodegen.kt

@@ -23,7 +23,6 @@ import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.dump
 import org.jetbrains.kotlin.ir.util.getArguments
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature
-import org.jetbrains.kotlin.utils.keysToMap
 import org.jetbrains.org.objectweb.asm.Type
 import org.jetbrains.org.objectweb.asm.commons.Method
 
@@ -110,11 +109,10 @@ class IrInlineCodegen(
         codegen: ExpressionCodegen,
         expression: IrFunctionAccessExpression
     ) {
-        val typeArguments = expression.descriptor.typeParameters.keysToMap { expression.getTypeArgumentOrDefault(it) }
         // TODO port inlining cycle detection to IrFunctionAccessExpression & pass it
         state.globalInlineContext.enterIntoInlining(null)
         try {
-            performInline(typeArguments, false, codegen)
+            performInline(expression.symbol.owner.typeParameters.map { it.symbol }, false, codegen.typeMapper.typeSystem, codegen)
         } finally {
             state.globalInlineContext.exitFromInliningOf(null)
         }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrMemberAccessExpression.kt

@@ -63,9 +63,6 @@ val CallableDescriptor.typeParametersCount: Int
             else -> typeParameters.size
         }
 
-fun IrMemberAccessExpression.getTypeArgumentOrDefault(typeParameterDescriptor: TypeParameterDescriptor) =
-    getTypeArgument(typeParameterDescriptor)?.toKotlinType() ?: typeParameterDescriptor.defaultType
-
 fun IrMemberAccessExpression.getTypeArgumentOrDefault(irTypeParameter: IrTypeParameter) =
     getTypeArgument(irTypeParameter.index) ?: irTypeParameter.defaultType