Fir2IrClassifierStorage: drop unnecessary signature manipulations

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

@@ -35,6 +35,7 @@ import org.jetbrains.kotlin.ir.util.IdSignature
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.name.StandardClassIds
+import org.jetbrains.kotlin.utils.addToStdlib.runIf
 import org.jetbrains.kotlin.utils.addToStdlib.runUnless
 
 class Fir2IrClassifierStorage(
@@ -355,20 +356,17 @@ class Fir2IrClassifierStorage(
     ): IrClass {
         val origin = IrDeclarationOrigin.DEFINED
         val modality = Modality.FINAL
-        val signature = null
         val result = anonymousObject.convertWithOffsets { startOffset, endOffset ->
-            declareIrClass(signature) { symbol ->
+            irFactory.createClass(
-                irFactory.createClass(
+                startOffset, endOffset, origin, IrClassSymbolImpl(), name,
-                    startOffset, endOffset, origin, symbol, name,
+                // NB: for unknown reason, IR uses 'CLASS' kind for simple anonymous objects
-                    // NB: for unknown reason, IR uses 'CLASS' kind for simple anonymous objects
+                anonymousObject.classKind.takeIf { it == ClassKind.ENUM_ENTRY } ?: ClassKind.CLASS,
-                    anonymousObject.classKind.takeIf { it == ClassKind.ENUM_ENTRY } ?: ClassKind.CLASS,
+                components.visibilityConverter.convertToDescriptorVisibility(visibility), modality
-                    components.visibilityConverter.convertToDescriptorVisibility(visibility), modality
+            ).apply {
-                ).apply {
+                metadata = FirMetadataSource.Class(anonymousObject)
-                    metadata = FirMetadataSource.Class(anonymousObject)
+                setThisReceiver(anonymousObject.typeParameters)
-                    setThisReceiver(anonymousObject.typeParameters)
+                if (irParent != null) {
-                    if (irParent != null) {
+                    this.parent = irParent
-                        this.parent = irParent
-                    }
                 }
             }
         }.declareSupertypesAndTypeParameters(anonymousObject)
@@ -553,17 +551,6 @@ class Fir2IrClassifierStorage(
         if (firClass is FirAnonymousObject || firClass is FirRegularClass && firClass.visibility == Visibilities.Local) {
             return createLocalIrClassOnTheFly(firClass).symbol
         }
-        val signature = signatureComposer.composeSignature(firClass, forceTopLevelPrivate = forceTopLevelPrivate)!!
-        val symbol = symbolTable.referenceClass(signature)
-        if (symbol.isBound) {
-            val irClass = symbol.owner
-            classCache[firClass as FirRegularClass] = irClass
-            val mappedTypeParameters = firClass.typeParameters.filterIsInstance<FirTypeParameter>().zip(irClass.typeParameters)
-            for ((firTypeParameter, irTypeParameter) in mappedTypeParameters) {
-                typeParameterCache[firTypeParameter] = irTypeParameter
-            }
-            return symbol
-        }
         firClass as FirRegularClass
         val classId = firClassSymbol.classId
         val parentId = classId.outerClassId
@@ -573,9 +560,12 @@ class Fir2IrClassifierStorage(
         // firClass may be referenced by some parent's type parameters as a bound. In that case, getIrClassSymbol will be called recursively.
         getCachedIrClass(firClass)?.let { return it.symbol }
 
+        val signature = runIf(generateSignatures) {
+            signatureComposer.composeSignature(firClass, forceTopLevelPrivate = forceTopLevelPrivate)
+        }
         val irClass = firClass.convertWithOffsets { startOffset, endOffset ->
-            symbolTable.declareClass(signature, { symbol }) {
+            declareIrClass(signature) { irClassSymbol ->
-                Fir2IrLazyClass(components, startOffset, endOffset, firClass.irOrigin(firProvider), firClass, symbol).apply {
+                Fir2IrLazyClass(components, startOffset, endOffset, firClass.irOrigin(firProvider), firClass, irClassSymbol).apply {
                     parent = irParent
                 }
             }
@@ -584,7 +574,7 @@ class Fir2IrClassifierStorage(
         // NB: this is needed to prevent recursions in case of self bounds
         (irClass as Fir2IrLazyClass).prepareTypeParameters()
 
-        return symbol
+        return irClass.symbol
     }
 
     fun getIrClassSymbolForNotFoundClass(classLikeLookupTag: ConeClassLikeLookupTag): IrClassSymbol {

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

@@ -24,7 +24,7 @@ interface Fir2IrComponents {
     val converter: Fir2IrConverter
 
     val symbolTable: SymbolTable
-    val irBuiltIns: IrBuiltIns
+    val irBuiltIns: IrBuiltInsOverFir
     val builtIns: Fir2IrBuiltIns
     val irFactory: IrFactory
     val irProviders: List<IrProvider>

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

@@ -33,7 +33,7 @@ class Fir2IrComponentsStorage(
     override lateinit var classifierStorage: Fir2IrClassifierStorage
     override lateinit var declarationStorage: Fir2IrDeclarationStorage
 
-    override lateinit var irBuiltIns: IrBuiltIns
+    override lateinit var irBuiltIns: IrBuiltInsOverFir
     override lateinit var builtIns: Fir2IrBuiltIns
     override lateinit var irProviders: List<IrProvider>
 

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

@@ -49,7 +49,8 @@ class Fir2IrTypeConverter(
             StandardClassIds.Float to irBuiltIns.floatClass,
             StandardClassIds.Double to irBuiltIns.doubleClass,
             StandardClassIds.Char to irBuiltIns.charClass,
-            StandardClassIds.Array to irBuiltIns.arrayClass
+            StandardClassIds.Array to irBuiltIns.arrayClass,
+            INTRINSIC_CONST_EVALUATION_ANNOTATION to irBuiltIns.intrinsicConst
         )
     }
 

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

@@ -196,7 +196,7 @@ class IrBuiltInsOverFir(
     override val stringType: IrType get() = string.type
 
     private val intrinsicConstAnnotationFqName = kotlinInternalPackage.child(Name.identifier("IntrinsicConstEvaluation"))
-    private val intrinsicConst = kotlinInternalIrPackage.createClass(intrinsicConstAnnotationFqName).apply {
+    internal val intrinsicConst = kotlinInternalIrPackage.createClass(intrinsicConstAnnotationFqName).apply {
         owner.createConstructor()
         owner.finalizeClassDefinition()
     }