[FIR2IR] Manage enum entry symbols in declaration storage instead of declaration generator

This is needed to be able to implement creation of unbound symbols
 for references of corresponding declarations (KT-62856)

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

@@ -22,10 +22,7 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.symbols.*
-import org.jetbrains.kotlin.ir.symbols.impl.IrClassSymbolImpl
-import org.jetbrains.kotlin.ir.symbols.impl.IrFieldSymbolImpl
-import org.jetbrains.kotlin.ir.symbols.impl.IrTypeAliasSymbolImpl
-import org.jetbrains.kotlin.ir.symbols.impl.IrTypeParameterSymbolImpl
+import org.jetbrains.kotlin.ir.symbols.impl.*
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.IdSignature
 import org.jetbrains.kotlin.name.Name
@@ -347,15 +344,24 @@ class Fir2IrClassifierStorage(
         } else {
             irParent.origin
         }
+        val symbol = createEnumEntrySymbol(enumEntry)
         return classifiersGenerator.createIrEnumEntry(
             enumEntry,
             irParent = irParent,
+            symbol,
             predefinedOrigin = predefinedOrigin
         ).also {
             enumEntryCache[enumEntry] = it
         }
     }
 
+    private fun createEnumEntrySymbol(enumEntry: FirEnumEntry): IrEnumEntrySymbol {
+        val signature = signatureComposer.composeSignature(enumEntry)
+        return when {
+            signature != null -> symbolTable.referenceEnumEntry(signature)
+            else -> IrEnumEntrySymbolImpl()
+        }
+    }
 
     // ------------------------------------ typealiases ------------------------------------
 

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/Fir2IrClassifiersGenerator.kt

@@ -342,43 +342,34 @@ class Fir2IrClassifiersGenerator(val components: Fir2IrComponents) : Fir2IrCompo
 
     // ------------------------------------ enum entries ------------------------------------
 
-    private fun declareIrEnumEntry(signature: IdSignature?, factory: (IrEnumEntrySymbol) -> IrEnumEntry): IrEnumEntry {
-        return if (signature == null)
-            factory(IrEnumEntrySymbolImpl())
-        else
-            symbolTable.declareEnumEntry(signature, { IrEnumEntryPublicSymbolImpl(signature) }, factory)
-    }
-
     fun createIrEnumEntry(
         enumEntry: FirEnumEntry,
         irParent: IrClass,
+        symbol: IrEnumEntrySymbol,
         predefinedOrigin: IrDeclarationOrigin? = null,
     ): IrEnumEntry {
         return enumEntry.convertWithOffsets { startOffset, endOffset ->
-            val signature = signatureComposer.composeSignature(enumEntry)
-            declareIrEnumEntry(signature) { symbol ->
-                val origin = enumEntry.computeIrOrigin(predefinedOrigin)
-                irFactory.createEnumEntry(
-                    startOffset = startOffset,
-                    endOffset = endOffset,
-                    origin = origin,
-                    name = enumEntry.name,
-                    symbol = symbol,
-                ).apply {
-                    declarationStorage.enterScope(this.symbol)
-                    setParent(irParent)
-                    addDeclarationToParent(this, irParent)
-                    if (isEnumEntryWhichRequiresSubclass(enumEntry)) {
-                        // An enum entry with its own members requires an anonymous object generated.
-                        // Otherwise, this is a default-ish enum entry whose initializer would be a delegating constructor call,
-                        // which will be translated via visitor later.
-                        val klass = classifierStorage.getIrAnonymousObjectForEnumEntry(
-                            (enumEntry.initializer as FirAnonymousObjectExpression).anonymousObject, enumEntry.name, irParent
-                        )
-                        this.correspondingClass = klass
-                    }
-                    declarationStorage.leaveScope(this.symbol)
+            val origin = enumEntry.computeIrOrigin(predefinedOrigin)
+            irFactory.createEnumEntry(
+                startOffset = startOffset,
+                endOffset = endOffset,
+                origin = origin,
+                name = enumEntry.name,
+                symbol = symbol,
+            ).apply {
+                declarationStorage.enterScope(this.symbol)
+                setParent(irParent)
+                addDeclarationToParent(this, irParent)
+                if (isEnumEntryWhichRequiresSubclass(enumEntry)) {
+                    // An enum entry with its own members requires an anonymous object generated.
+                    // Otherwise, this is a default-ish enum entry whose initializer would be a delegating constructor call,
+                    // which will be translated via visitor later.
+                    val klass = classifierStorage.getIrAnonymousObjectForEnumEntry(
+                        (enumEntry.initializer as FirAnonymousObjectExpression).anonymousObject, enumEntry.name, irParent
+                    )
+                    this.correspondingClass = klass
                 }
+                declarationStorage.leaveScope(this.symbol)
             }
         }
     }