[FIR2IR] Add pre-caching of built-in classes to avoid their duplications

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

@@ -8,7 +8,9 @@ package org.jetbrains.kotlin.fir.backend
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.firProvider
+import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
+import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -45,6 +47,24 @@ class Fir2IrClassifierStorage(
     private fun FirTypeRef.toIrType(typeContext: ConversionTypeContext = ConversionTypeContext.DEFAULT): IrType =
         with(typeConverter) { toIrType(typeContext) }
 
+    fun preCacheBuiltinClasses() {
+        for ((classId, irBuiltinSymbol) in typeConverter.classIdToSymbolMap) {
+            val firClass = ConeClassLikeLookupTagImpl(classId).toSymbol(session)!!.fir as FirRegularClass
+            val irClass = irBuiltinSymbol.owner
+            classCache[firClass] = irClass
+            processClassHeader(firClass, irClass)
+            declarationStorage.preCacheBuiltinClassConstructorIfAny(firClass, irClass)
+        }
+        for ((primitiveClassId, primitiveArrayId) in StandardClassIds.primitiveArrayTypeByElementType) {
+            val firClass = ConeClassLikeLookupTagImpl(primitiveArrayId).toSymbol(session)!!.fir as FirRegularClass
+            val irType = typeConverter.classIdToTypeMap[primitiveClassId]
+            val irClass = irBuiltIns.primitiveArrayForType[irType]!!.owner
+            classCache[firClass] = irClass
+            processClassHeader(firClass, irClass)
+            declarationStorage.preCacheBuiltinClassConstructorIfAny(firClass, irClass)
+        }
+    }
+
     internal fun IrDeclaration.declareThisReceiverParameter(
         parent: IrDeclarationParent,
         thisType: IrType,
@@ -354,14 +374,6 @@ class Fir2IrClassifierStorage(
     fun getIrClassSymbol(firClassSymbol: FirClassSymbol<*>): IrClassSymbol {
         val firClass = firClassSymbol.fir
         getCachedIrClass(firClass)?.let { return symbolTable.referenceClass(it.descriptor) }
-        val builtinClassSymbol = when (firClassSymbol.classId) {
-            StandardClassIds.Any -> irBuiltIns.anyClass
-            else -> null
-        }
-        if (builtinClassSymbol != null && firClass is FirRegularClass) {
-            classCache[firClass] = builtinClassSymbol.owner
-            return symbolTable.referenceClass(builtinClassSymbol.descriptor)
-        }
         // TODO: remove all this code and change to unbound symbol creation
         val irClass = createIrClass(firClass)
         if (firClass is FirAnonymousObject || firClass is FirRegularClass && firClass.visibility == Visibilities.LOCAL) {

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

@@ -186,7 +186,9 @@ class Fir2IrConverter(
             val externalDependenciesGenerator = ExternalDependenciesGenerator(
                 symbolTable, generateTypicalIrProviderList(irModuleFragment.descriptor, builtIns, symbolTable)
             )
+            // Necessary call to generate built-in IR classes
             externalDependenciesGenerator.generateUnboundSymbolsAsDependencies()
+            classifierStorage.preCacheBuiltinClasses()
             for (firFile in firFiles) {
                 converter.processClassHeaders(firFile)
             }

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

@@ -66,6 +66,12 @@ class Fir2IrDeclarationStorage(
 
     private val localStorage = Fir2IrLocalStorage()
 
+    internal fun preCacheBuiltinClassConstructorIfAny(firClass: FirRegularClass, irClass: IrClass) {
+        val primaryConstructor = firClass.getPrimaryConstructorIfAny() ?: return
+        val irConstructor = irClass.constructors.firstOrNull() ?: return
+        constructorCache[primaryConstructor] = irConstructor
+    }
+
     fun registerFile(firFile: FirFile, irFile: IrFile) {
         fileCache[firFile] = irFile
     }
@@ -653,15 +659,6 @@ class Fir2IrDeclarationStorage(
     fun getIrConstructorSymbol(firConstructorSymbol: FirConstructorSymbol): IrConstructorSymbol {
         val firConstructor = firConstructorSymbol.fir
         getCachedIrConstructor(firConstructor)?.let { return symbolTable.referenceConstructor(it.descriptor) }
-        val builtinParent = when (firConstructorSymbol.callableId.classId) {
-            StandardClassIds.Any -> irBuiltIns.anyClass
-            else -> null
-        }
-        if (builtinParent != null) {
-            val constructorSymbol = builtinParent.constructors.first()
-            constructorCache[firConstructor] = constructorSymbol.owner
-            return symbolTable.referenceConstructor(constructorSymbol.descriptor)
-        }
 
         val irParent = findIrParent(firConstructor) as IrClass
         val parentOrigin = (irParent as? IrDeclaration)?.origin ?: IrDeclarationOrigin.DEFINED

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

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.types.Variance
 class Fir2IrTypeConverter(
     private val components: Fir2IrComponents
 ) : Fir2IrComponents by components {
-    private val classIdToSymbolMap = mapOf(
+    internal val classIdToSymbolMap = mapOf(
         StandardClassIds.Nothing to irBuiltIns.nothingClass,
         StandardClassIds.Unit to irBuiltIns.unitClass,
         StandardClassIds.Boolean to irBuiltIns.booleanClass,
@@ -37,7 +37,7 @@ class Fir2IrTypeConverter(
         StandardClassIds.Array to irBuiltIns.arrayClass
     )
 
-    private val classIdToTypeMap = mapOf(
+    internal val classIdToTypeMap = mapOf(
         StandardClassIds.Nothing to irBuiltIns.nothingType,
         StandardClassIds.Unit to irBuiltIns.unitType,
         StandardClassIds.Boolean to irBuiltIns.booleanType,