[fir2ir] Allow non-cached type parameters

In the IDE, there might come declarations from other files/modules
that we link against, but not compile. Type parameters are one of such
declaration kinds.

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompilerFacility.kt

@@ -90,7 +90,8 @@ internal class KtFirCompilerFacility(
             diagnosticsReporter,
             linkViaSignatures = false,
             effectiveConfiguration[CommonConfigurationKeys.EVALUATED_CONST_TRACKER] ?: EvaluatedConstTracker.create(),
-            effectiveConfiguration[CommonConfigurationKeys.INLINE_CONST_TRACKER]
+            effectiveConfiguration[CommonConfigurationKeys.INLINE_CONST_TRACKER],
+            allowNonCachedDeclarations = true
         )
 
         val fir2IrResult = Fir2IrConverter.createModuleFragmentWithSignaturesIfNeeded(

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/klib/compilerPipeline.kt

@@ -234,6 +234,7 @@ fun transformFirToIr(
             evaluatedConstTracker = moduleStructure.compilerConfiguration
                 .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
             inlineConstTracker = null,
+            allowNonCachedDeclarations = false,
         ),
         IrGenerationExtension.getInstances(moduleStructure.project),
         signatureComposer = DescriptorSignatureComposerStub(JsManglerDesc),

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/FirKotlinToJvmBytecodeCompiler.kt

@@ -160,6 +160,7 @@ object FirKotlinToJvmBytecodeCompiler {
             evaluatedConstTracker = moduleConfiguration
                 .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
             inlineConstTracker = moduleConfiguration[CommonConfigurationKeys.INLINE_CONST_TRACKER],
+            allowNonCachedDeclarations = false,
         )
         val fir2IrAndIrActualizerResult = firResult.convertToIrAndActualizeForJvm(
             fir2IrExtensions,

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/pipeline/compilerPipeline.kt

@@ -185,6 +185,7 @@ fun convertAnalyzedFirToIr(
         evaluatedConstTracker = input.configuration
             .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
         inlineConstTracker = input.configuration[CommonConfigurationKeys.INLINE_CONST_TRACKER],
+        allowNonCachedDeclarations = false,
     )
     val (irModuleFragment, components, pluginContext, irActualizedResult) =
         analysisResults.convertToIrAndActualizeForJvm(

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrClassifierStorage.kt

@@ -665,10 +665,41 @@ class Fir2IrClassifierStorage(
         typeOrigin: ConversionTypeOrigin
     ): IrTypeParameterSymbol {
         val firTypeParameter = firTypeParameterSymbol.fir
-        return getCachedIrTypeParameter(firTypeParameter, typeOrigin)?.symbol
-        // We can try to use default cache because setter can use parent type parameters
-            ?: typeParameterCache[firTypeParameter]?.symbol
-            ?: error("Cannot find cached type parameter by FIR symbol: ${firTypeParameterSymbol.name} of the owner: ${firTypeParameter.containingDeclarationSymbol}")
+
+        val cachedSymbol = getCachedIrTypeParameter(firTypeParameter, typeOrigin)?.symbol
+            ?: typeParameterCache[firTypeParameter]?.symbol // We can try to use default cache because setter can use parent type parameters
+
+        if (cachedSymbol != null) {
+            return cachedSymbol
+        }
+
+        if (components.configuration.allowNonCachedDeclarations) {
+            val firTypeParameterOwnerSymbol = firTypeParameter.containingDeclarationSymbol
+
+            val firTypeParameterOwner = firTypeParameterOwnerSymbol.fir as FirTypeParameterRefsOwner
+            val index = firTypeParameterOwner.typeParameters.indexOf(firTypeParameter).also { check(it >= 0) }
+
+            with(firTypeParameter) {
+                val symbol = IrTypeParameterSymbolImpl()
+                convertWithOffsets { startOffset, endOffset ->
+                    irFactory.createTypeParameter(
+                        startOffset, endOffset,
+                        firTypeParameter.computeIrOrigin(),
+                        name,
+                        symbol,
+                        variance,
+                        if (index < 0) 0 else index,
+                        isReified
+                    ).apply {
+                        superTypes = firTypeParameter.bounds.map { it.toIrType(typeConverter) }
+                    }
+                }
+
+                return symbol
+            }
+        }
+
+        error("Cannot find cached type parameter by FIR symbol: ${firTypeParameterSymbol.name} of the owner: ${firTypeParameter.containingDeclarationSymbol}")
     }
 
     private val temporaryParent by lazy {

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConfiguration.kt

@@ -21,10 +21,18 @@ import org.jetbrains.kotlin.constant.EvaluatedConstTracker
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.incremental.components.InlineConstTracker
 
+/**
+ * @param allowNonCachedDeclarations
+ *  Normally, FIR-to-IR caches all declarations it meets in a compiled module.
+ *  It means asking for an IR element of a non-cached declaration is a sign of inconsistent state.
+ *  Code generation in the IDE is trickier, though, as declarations from any module can be potentially referenced.
+ *  For such a scenario, there is a flag that relaxes consistency checks.
+ */
 data class Fir2IrConfiguration(
     val languageVersionSettings: LanguageVersionSettings,
     val diagnosticReporter: DiagnosticReporter,
     val linkViaSignatures: Boolean,
     val evaluatedConstTracker: EvaluatedConstTracker,
     val inlineConstTracker: InlineConstTracker?,
+    val allowNonCachedDeclarations: Boolean,
 )

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalFirJvmCompilerRunner.kt

@@ -281,6 +281,7 @@ open class IncrementalFirJvmCompilerRunner(
                 evaluatedConstTracker = configuration
                     .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
                 inlineConstTracker = configuration[CommonConfigurationKeys.INLINE_CONST_TRACKER],
+                allowNonCachedDeclarations = false,
             )
             val irGenerationExtensions =
                 (projectEnvironment as? VfsBasedProjectEnvironment)?.project?.let { IrGenerationExtension.getInstances(it) }.orEmpty()

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJsResultsConverter.kt

@@ -171,6 +171,7 @@ fun ModuleCompilerAnalyzedOutput.convertToJsIr(
         evaluatedConstTracker = configuration
             .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
         inlineConstTracker = null,
+        allowNonCachedDeclarations = false,
     )
 
     return convertToIr(

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrJvmResultsConverter.kt

@@ -104,6 +104,7 @@ class Fir2IrJvmResultsConverter(
                 evaluatedConstTracker = compilerConfiguration
                     .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
                 inlineConstTracker = compilerConfiguration[CommonConfigurationKeys.INLINE_CONST_TRACKER],
+                allowNonCachedDeclarations = false
             )
             val (irModuleFragment, components, pluginContext) = firOutputPart.firAnalyzerFacade.result.outputs.single().convertToIr(
                 fir2IrExtensions,

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrWasmResultsConverter.kt

@@ -167,6 +167,7 @@ fun ModuleCompilerAnalyzedOutput.convertToWasmIr(
         evaluatedConstTracker = configuration
             .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
         inlineConstTracker = null,
+        allowNonCachedDeclarations = false
     )
 
     return convertToIr(

compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/codegen/GenerationUtils.kt

@@ -136,6 +136,7 @@ object GenerationUtils {
             evaluatedConstTracker = configuration
                 .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
             inlineConstTracker = configuration[CommonConfigurationKeys.INLINE_CONST_TRACKER],
+            allowNonCachedDeclarations = false
         )
 
         val commonMemberStorage = Fir2IrCommonMemberStorage(signatureComposerForJvmFir2Ir(linkViaSignatures), FirJvmKotlinMangler())

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Fir2Ir.kt

@@ -79,6 +79,7 @@ internal fun PhaseContext.fir2Ir(
             evaluatedConstTracker = configuration
                     .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()),
             inlineConstTracker = null,
+            allowNonCachedDeclarations = false,
     )
     val (irModuleFragment, components, pluginContext, irActualizedResult) = input.firResult.convertToIrAndActualize(
             fir2IrExtensions,