[FIR2IR] Extract logic of IR declarations generation into separate component. Part 1

This commit just moves methods, which create IR callable declarations
  from Fir2IrDeclarationStorage to newly created Fir2IrCallableDeclarationsGenerator
  and Fir2IrLazyDeclarationsGenerator without any modifications.

Code in generators contains some errors (mostly because it refers to the
  logic of caching created declaration), and those errors will be fixed
  in following commits

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

@@ -583,7 +583,7 @@ fun Fir2IrComponents.createTemporaryVariable(
     conversionScope: Fir2IrConversionScope,
     nameHint: String? = null
 ): Pair<IrVariable, IrValueSymbol> {
-    val receiverVariable = declarationStorage.declareTemporaryVariable(receiverExpression, nameHint).apply {
+    val receiverVariable = callablesGenerator.declareTemporaryVariable(receiverExpression, nameHint).apply {
         parent = conversionScope.parentFromStack()
     }
     val variableSymbol = receiverVariable.symbol

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

@@ -6,10 +6,7 @@
 package org.jetbrains.kotlin.fir.backend
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.backend.generators.AnnotationGenerator
+import org.jetbrains.kotlin.fir.backend.generators.*
-import org.jetbrains.kotlin.fir.backend.generators.CallAndReferenceGenerator
-import org.jetbrains.kotlin.fir.backend.generators.DelegatedMemberGenerator
-import org.jetbrains.kotlin.fir.backend.generators.FakeOverrideGenerator
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.signaturer.FirBasedSignatureComposer
 import org.jetbrains.kotlin.ir.IrLock
@@ -37,6 +34,9 @@ interface Fir2IrComponents {
     val signatureComposer: FirBasedSignatureComposer
     val visibilityConverter: Fir2IrVisibilityConverter
 
+    val callablesGenerator: Fir2IrCallableDeclarationsGenerator
+    val lazyDeclarationsGenerator: Fir2IrLazyDeclarationsGenerator
+
     val annotationGenerator: AnnotationGenerator
     val callGenerator: CallAndReferenceGenerator
     val fakeOverrideGenerator: FakeOverrideGenerator

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

@@ -6,10 +6,7 @@
 package org.jetbrains.kotlin.fir.backend
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.backend.generators.AnnotationGenerator
+import org.jetbrains.kotlin.fir.backend.generators.*
-import org.jetbrains.kotlin.fir.backend.generators.CallAndReferenceGenerator
-import org.jetbrains.kotlin.fir.backend.generators.DelegatedMemberGenerator
-import org.jetbrains.kotlin.fir.backend.generators.FakeOverrideGenerator
 import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.signaturer.FirBasedSignatureComposer
@@ -40,16 +37,20 @@ class Fir2IrComponentsStorage(
     override val classifierStorage: Fir2IrClassifierStorage = Fir2IrClassifierStorage(this, commonMemberStorage)
     override val declarationStorage: Fir2IrDeclarationStorage = Fir2IrDeclarationStorage(this, moduleDescriptor, commonMemberStorage)
 
+    override val callablesGenerator: Fir2IrCallableDeclarationsGenerator = Fir2IrCallableDeclarationsGenerator(this)
+    override val lazyDeclarationsGenerator: Fir2IrLazyDeclarationsGenerator = Fir2IrLazyDeclarationsGenerator(this)
+
+    // builtins should go after storages and generators, because they use them during initialization
     override val irBuiltIns: IrBuiltInsOverFir = initializedIrBuiltIns ?: IrBuiltInsOverFir(
         this, configuration.languageVersionSettings, moduleDescriptor, irMangler
     )
-
     override val builtIns: Fir2IrBuiltIns = Fir2IrBuiltIns(this, specialSymbolProvider)
+
     override val irProviders: List<IrProvider> = listOf(FirIrProvider(this))
 
     override val typeConverter: Fir2IrTypeConverter = Fir2IrTypeConverter(this)
-
     private val conversionScope = Fir2IrConversionScope(configuration)
+
     val fir2IrVisitor: Fir2IrVisitor = Fir2IrVisitor(this, conversionScope)
 
     override val annotationGenerator: AnnotationGenerator = AnnotationGenerator(this)

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

@@ -470,7 +470,7 @@ class Fir2IrConverter(
             }
             is FirField -> {
                 if (declaration.isSynthetic) {
-                    declarationStorage.createIrFieldAndDelegatedMembers(declaration, containingClass!!, parent as IrClass)
+                    callablesGenerator.createIrFieldAndDelegatedMembers(declaration, containingClass!!, parent as IrClass)
                 } else {
                     throw AssertionError("Unexpected non-synthetic field: ${declaration::class}")
                 }
@@ -486,7 +486,7 @@ class Fir2IrConverter(
                 classifierStorage.getIrEnumEntry(declaration, parent as IrClass)
             }
             is FirAnonymousInitializer -> {
-                declarationStorage.createIrAnonymousInitializer(declaration, parent as IrClass)
+                callablesGenerator.createIrAnonymousInitializer(declaration, parent as IrClass)
             }
             is FirTypeAlias -> {
                 // DO NOTHING

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

@@ -220,7 +220,11 @@ class Fir2IrVisitor(
             declarationStorage.enterScope(irScript.symbol)
 
             irScript.explicitCallParameters = script.parameters.map { parameter ->
-                declarationStorage.createIrVariable(parameter, irScript, givenOrigin = IrDeclarationOrigin.SCRIPT_CALL_PARAMETER)
+                callablesGenerator.createIrVariable(
+                    parameter,
+                    irScript,
+                    givenOrigin = IrDeclarationOrigin.SCRIPT_CALL_PARAMETER
+                )
             }
 
             // NOTE: index should correspond to one generated in the collectTowerDataElementsForScript
@@ -274,7 +278,7 @@ class Fir2IrVisitor(
                                         irBuiltIns.unitType, IrStatementOrigin.DESTRUCTURING_DECLARATION
                                     ).also {
                                         it.statements.add(
-                                            declarationStorage.createIrVariable(statement, conversionScope.parentFromStack()).also {
+                                            callablesGenerator.createIrVariable(statement, conversionScope.parentFromStack()).also {
                                                 it.initializer = statement.initializer?.toIrStatement() as? IrExpression
                                             }
                                         )
@@ -392,7 +396,7 @@ class Fir2IrVisitor(
 
     override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: Any?): IrElement = whileAnalysing(session, simpleFunction) {
         val irFunction = if (simpleFunction.visibility == Visibilities.Local) {
-            declarationStorage.createIrFunction(
+            callablesGenerator.createIrFunction(
                 simpleFunction, irParent = conversionScope.parent(), predefinedOrigin = IrDeclarationOrigin.LOCAL_FUNCTION, isLocal = true
             )
         } else {
@@ -414,7 +418,7 @@ class Fir2IrVisitor(
         data: Any?
     ): IrElement = whileAnalysing(session, anonymousFunction) {
         return anonymousFunction.convertWithOffsets { startOffset, endOffset ->
-            val irFunction = declarationStorage.createIrFunction(
+            val irFunction = callablesGenerator.createIrFunction(
                 anonymousFunction,
                 irParent = conversionScope.parent(),
                 predefinedOrigin = IrDeclarationOrigin.LOCAL_FUNCTION,
@@ -438,7 +442,7 @@ class Fir2IrVisitor(
         assert(variable.isLocal)
         val delegate = variable.delegate
         if (delegate != null) {
-            val irProperty = declarationStorage.createIrLocalDelegatedProperty(variable, conversionScope.parentFromStack())
+            val irProperty = callablesGenerator.createIrLocalDelegatedProperty(variable, conversionScope.parentFromStack())
             irProperty.delegate.initializer = convertToIrExpression(delegate, isDelegate = true)
             conversionScope.withFunction(irProperty.getter) {
                 memberGenerator.convertFunctionContent(irProperty.getter, variable.getter, null)
@@ -454,7 +458,7 @@ class Fir2IrVisitor(
         val isNextVariable = initializer is FirFunctionCall &&
                 initializer.calleeReference.toResolvedNamedFunctionSymbol()?.callableId?.isIteratorNext() == true &&
                 variable.source?.isChildOfForLoop == true
-        val irVariable = declarationStorage.createIrVariable(
+        val irVariable = callablesGenerator.createIrVariable(
             variable, conversionScope.parentFromStack(),
             if (isNextVariable) {
                 if (variable.name.isSpecial && variable.name == SpecialNames.DESTRUCT) {
@@ -1260,7 +1264,7 @@ class Fir2IrVisitor(
         return when {
             subjectVariable != null -> subjectVariable.accept(this, null) as IrVariable
             subjectExpression != null -> {
-                applyParentFromStackTo(declarationStorage.declareTemporaryVariable(convertToIrExpression(subjectExpression), "subject"))
+                applyParentFromStackTo(callablesGenerator.declareTemporaryVariable(convertToIrExpression(subjectExpression), "subject"))
             }
             else -> null
         }
@@ -1419,7 +1423,7 @@ class Fir2IrVisitor(
 
     override fun visitCatch(catch: FirCatch, data: Any?): IrElement {
         return catch.convertWithOffsets { startOffset, endOffset ->
-            val catchParameter = declarationStorage.createIrVariable(
+            val catchParameter = callablesGenerator.createIrVariable(
                 catch.parameter, conversionScope.parentFromStack(), IrDeclarationOrigin.CATCH_PARAMETER
             )
             IrCatchImpl(startOffset, endOffset, catchParameter, catch.block.convertToIrBlock(forceUnitType = false))

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

@@ -293,7 +293,7 @@ class DataClassMembersGenerator(val components: Fir2IrComponents) : Fir2IrCompon
             isOperator: Boolean = false,
         ): IrFunction {
             val signature = if (klass.symbol.classId.isLocal) null else components.signatureComposer.composeSignature(syntheticCounterpart)
-            return components.declarationStorage.declareIrSimpleFunction(signature) { symbol ->
+            return components.callablesGenerator.declareIrSimpleFunction(signature) { symbol ->
                 components.irFactory.createSimpleFunction(
                     startOffset = UNDEFINED_OFFSET,
                     endOffset = UNDEFINED_OFFSET,

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

@@ -206,7 +206,7 @@ class DelegatedMemberGenerator(private val components: Fir2IrComponents) : Fir2I
         delegateOverride: FirSimpleFunction
     ): IrSimpleFunction {
         val delegateFunction =
-            declarationStorage.createIrFunction(
+            callablesGenerator.createIrFunction(
                 delegateOverride, subClass, predefinedOrigin = IrDeclarationOrigin.DELEGATED_MEMBER,
                 fakeOverrideOwnerLookupTag = firSubClass.symbol.toLookupTag()
             )
@@ -297,7 +297,7 @@ class DelegatedMemberGenerator(private val components: Fir2IrComponents) : Fir2I
         firDelegateProperty: FirProperty
     ): IrProperty {
         val delegateProperty =
-            declarationStorage.createIrProperty(
+            callablesGenerator.createIrProperty(
                 firDelegateProperty, subClass, predefinedOrigin = IrDeclarationOrigin.DELEGATED_MEMBER,
                 fakeOverrideOwnerLookupTag = firSubClass.symbol.toLookupTag()
             )

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

@@ -122,7 +122,7 @@ class FakeOverrideGenerator(
             createFakeOverriddenIfNeeded(
                 firClass, irClass, isLocal, functionSymbol,
                 declarationStorage::getCachedIrFunction,
-                declarationStorage::createIrFunction,
+                callablesGenerator::createIrFunction,
                 createFakeOverrideSymbol = { firFunction, callableSymbol ->
                     val symbol = FirFakeOverrideGenerator.createSymbolForSubstitutionOverride(callableSymbol, firClass.symbol.classId)
                     FirFakeOverrideGenerator.createSubstitutionOverrideFunction(
@@ -150,7 +150,7 @@ class FakeOverrideGenerator(
                     createFakeOverriddenIfNeeded(
                         firClass, irClass, isLocal, propertyOrFieldSymbol,
                         declarationStorage::getCachedIrProperty,
-                        declarationStorage::createIrProperty,
+                        callablesGenerator::createIrProperty,
                         createFakeOverrideSymbol = { firProperty, callableSymbol ->
                             val symbolForOverride =
                                 FirFakeOverrideGenerator.createSymbolForSubstitutionOverride(callableSymbol, firClass.symbol.classId)
@@ -180,7 +180,7 @@ class FakeOverrideGenerator(
                         firClass, irClass, isLocal, propertyOrFieldSymbol,
                         { field, _, _ -> declarationStorage.getCachedIrFieldStaticFakeOverrideByDeclaration(field) },
                         { field, irParent, _, _ ->
-                            declarationStorage.createIrField(field, irParent)
+                            callablesGenerator.createIrField(field, irParent)
                         },
                         createFakeOverrideSymbol = { firField, _ ->
                             FirFakeOverrideGenerator.createSubstitutionOverrideField(

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

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.backend.generators
+
+import org.jetbrains.kotlin.fir.backend.Fir2IrComponents
+import org.jetbrains.kotlin.fir.backend.convertWithOffsets
+import org.jetbrains.kotlin.fir.backend.isStubPropertyForPureField
+import org.jetbrains.kotlin.fir.declarations.FirProperty
+import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
+import org.jetbrains.kotlin.fir.dispatchReceiverClassLookupTagOrNull
+import org.jetbrains.kotlin.fir.isSubstitutionOrIntersectionOverride
+import org.jetbrains.kotlin.fir.lazy.Fir2IrLazyClass
+import org.jetbrains.kotlin.fir.lazy.Fir2IrLazyProperty
+import org.jetbrains.kotlin.fir.lazy.Fir2IrLazySimpleFunction
+import org.jetbrains.kotlin.fir.originalForSubstitutionOverride
+import org.jetbrains.kotlin.fir.symbols.Fir2IrPropertySymbol
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
+import org.jetbrains.kotlin.ir.declarations.IrProperty
+import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
+import org.jetbrains.kotlin.ir.symbols.IrSymbolInternals
+import org.jetbrains.kotlin.ir.util.IdSignature
+
+class Fir2IrLazyDeclarationsGenerator(val components: Fir2IrComponents) : Fir2IrComponents by components {
+    internal fun createIrLazyFunction(
+        fir: FirSimpleFunction,
+        signature: IdSignature,
+        lazyParent: IrDeclarationParent,
+        declarationOrigin: IrDeclarationOrigin
+    ): IrSimpleFunction {
+        val symbol = symbolTable.referenceSimpleFunction(signature)
+        val irFunction = fir.convertWithOffsets { startOffset, endOffset ->
+            symbolTable.declareSimpleFunction(signature, { symbol }) {
+                val isFakeOverride = fir.isSubstitutionOrIntersectionOverride
+                Fir2IrLazySimpleFunction(
+                    components, startOffset, endOffset, declarationOrigin,
+                    fir, (lazyParent as? Fir2IrLazyClass)?.fir, symbol, isFakeOverride
+                ).apply {
+                    this.parent = lazyParent
+                }
+            }
+        }
+        functionCache[fir] = irFunction
+        // NB: this is needed to prevent recursions in case of self bounds
+        (irFunction as Fir2IrLazySimpleFunction).prepareTypeParameters()
+        return irFunction
+    }
+
+    @OptIn(IrSymbolInternals::class)
+    internal fun createIrLazyProperty(
+        fir: FirProperty,
+        signature: IdSignature,
+        lazyParent: IrDeclarationParent,
+        declarationOrigin: IrDeclarationOrigin
+    ): IrProperty {
+        val symbol = Fir2IrPropertySymbol(signature)
+        val firPropertySymbol = fir.symbol
+
+        fun create(startOffset: Int, endOffset: Int): Fir2IrLazyProperty {
+            val isFakeOverride =
+                fir.isSubstitutionOrIntersectionOverride &&
+                        firPropertySymbol.dispatchReceiverClassLookupTagOrNull() !=
+                        firPropertySymbol.originalForSubstitutionOverride?.dispatchReceiverClassLookupTagOrNull()
+            return Fir2IrLazyProperty(
+                components, startOffset, endOffset, declarationOrigin,
+                fir, (lazyParent as? Fir2IrLazyClass)?.fir, symbol, isFakeOverride
+            ).apply {
+                this.parent = lazyParent
+            }
+        }
+
+        val irProperty = fir.convertWithOffsets { startOffset, endOffset ->
+            if (fir.isStubPropertyForPureField == true) {
+                // Very special case when two similar properties can exist so conflicts in SymbolTable are possible.
+                // See javaCloseFieldAndKotlinProperty.kt in BB tests
+                symbolTable.declarePropertyWithSignature(signature, symbol)
+                create(startOffset, endOffset)
+                symbol.owner
+            } else {
+                symbolTable.declareProperty(signature, { symbol }) {
+                    create(startOffset, endOffset)
+                }
+            }
+        }
+        propertyCache[fir] = irProperty
+        irProperty.getter?.symbol?.let { getterForPropertyCache[symbol] = it }
+        irProperty.setter?.symbol?.let { setterForPropertyCache[symbol] = it }
+        irProperty.backingField?.symbol?.let {
+            backingFieldForPropertyCache[symbol] = it
+            propertyForBackingFieldCache[it] = symbol
+        }
+        return irProperty
+    }
+
+}

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyConstructor.kt

@@ -102,17 +102,17 @@ class Fir2IrLazyConstructor(
         declarationStorage.enterScope(this.symbol)
 
         buildList {
-            declarationStorage.addContextReceiverParametersTo(
+            callablesGenerator.addContextReceiverParametersTo(
                 fir.contextReceivers,
                 this@Fir2IrLazyConstructor,
-                this@buildList,
+                this@buildList
             )
 
             fir.valueParameters.mapIndexedTo(this) { index, valueParameter ->
-                declarationStorage.createIrParameter(
+                callablesGenerator.createIrParameter(
                     valueParameter, index + contextReceiverParametersCount,
                     useStubForDefaultValueStub = (parent as? IrClass)?.name != Name.identifier("Enum"),
-                    forcedDefaultValueConversion = (parent as? IrClass)?.isAnnotationClass == true,
+                    forcedDefaultValueConversion = (parent as? IrClass)?.isAnnotationClass == true
                 ).apply {
                     this.parent = this@Fir2IrLazyConstructor
                 }

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyProperty.kt

@@ -115,7 +115,8 @@ class Fir2IrLazyProperty(
                     }
                     val initializer = fir.backingField?.initializer ?: fir.initializer
                     val visibility = fir.backingField?.visibility ?: fir.visibility
-                    createBackingField(
+                    callablesGenerator.createBackingField(
+                        this@Fir2IrLazyProperty,
                         fir,
                         IrDeclarationOrigin.PROPERTY_BACKING_FIELD,
                         components.visibilityConverter.convertToDescriptorVisibility(visibility),
@@ -130,9 +131,14 @@ class Fir2IrLazyProperty(
             }
             fir.hasBackingField && origin != IrDeclarationOrigin.FAKE_OVERRIDE -> {
                 with(declarationStorage) {
-                    createBackingField(
+                    callablesGenerator.createBackingField(
-                        fir, IrDeclarationOrigin.PROPERTY_BACKING_FIELD,
+                        this@Fir2IrLazyProperty,
-                        components.visibilityConverter.convertToDescriptorVisibility(fir.visibility), fir.name, fir.isVal, fir.initializer,
+                        fir,
+                        IrDeclarationOrigin.PROPERTY_BACKING_FIELD,
+                        components.visibilityConverter.convertToDescriptorVisibility(fir.visibility),
+                        fir.name,
+                        fir.isVal,
+                        fir.initializer,
                         type
                     ).also { field ->
                         field.initializer = toIrInitializer(fir.initializer)
@@ -141,10 +147,14 @@ class Fir2IrLazyProperty(
             }
             fir.delegate != null -> {
                 with(declarationStorage) {
-                    createBackingField(
+                    callablesGenerator.createBackingField(
-                        fir, IrDeclarationOrigin.PROPERTY_DELEGATE,
+                        this@Fir2IrLazyProperty,
+                        fir,
+                        IrDeclarationOrigin.PROPERTY_DELEGATE,
                         components.visibilityConverter.convertToDescriptorVisibility(fir.visibility),
-                        NameUtils.propertyDelegateName(fir.name), true, fir.delegate
+                        NameUtils.propertyDelegateName(fir.name),
+                        true,
+                        fir.delegate
                     )
                 }
             }

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyPropertyAccessor.kt

@@ -81,16 +81,16 @@ class Fir2IrLazyPropertyAccessor(
             declarationStorage.enterScope(this.symbol)
 
             buildList {
-                declarationStorage.addContextReceiverParametersTo(
+                callablesGenerator.addContextReceiverParametersTo(
                     fir.contextReceiversForFunctionOrContainingProperty(),
                     this@Fir2IrLazyPropertyAccessor,
-                    this@buildList,
+                    this@buildList
                 )
 
                 if (isSetter) {
                     val valueParameter = firAccessor?.valueParameters?.firstOrNull()
                     add(
-                        declarationStorage.createDefaultSetterParameter(
+                        callablesGenerator.createDefaultSetterParameter(
                             startOffset, endOffset,
                             (valueParameter?.returnTypeRef ?: firParentProperty.returnTypeRef).toIrType(
                                 typeConverter, conversionTypeContext

compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazySimpleFunction.kt

@@ -69,14 +69,14 @@ class Fir2IrLazySimpleFunction(
         declarationStorage.enterScope(this.symbol)
 
         buildList {
-            declarationStorage.addContextReceiverParametersTo(
+            callablesGenerator.addContextReceiverParametersTo(
                 fir.contextReceiversForFunctionOrContainingProperty(),
                 this@Fir2IrLazySimpleFunction,
-                this@buildList,
+                this@buildList
             )
 
             fir.valueParameters.mapIndexedTo(this) { index, valueParameter ->
-                declarationStorage.createIrParameter(
+                callablesGenerator.createIrParameter(
                     valueParameter, index + contextReceiverParametersCount, skipDefaultParameter = isFakeOverride
                 ).apply {
                     this.parent = this@Fir2IrLazySimpleFunction