[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
2023-08-25 13:49:03 +03:00
parent 714cb67254
commit 08ebe04485
15 changed files with 1221 additions and 1134 deletions
@@ -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
@@ -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.CallAndReferenceGenerator
-import org.jetbrains.kotlin.fir.backend.generators.DelegatedMemberGenerator
-import org.jetbrains.kotlin.fir.backend.generators.FakeOverrideGenerator
+import org.jetbrains.kotlin.fir.backend.generators.*
 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
@@ -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.CallAndReferenceGenerator
-import org.jetbrains.kotlin.fir.backend.generators.DelegatedMemberGenerator
-import org.jetbrains.kotlin.fir.backend.generators.FakeOverrideGenerator
+import org.jetbrains.kotlin.fir.backend.generators.*
 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)
@@ -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
@@ -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))
@@ -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,
@@ -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()
            )
@@ -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(
@@ -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
+    }
+
+}
@@ -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
                }
@@ -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(
-                        fir, IrDeclarationOrigin.PROPERTY_BACKING_FIELD,
-                        components.visibilityConverter.convertToDescriptorVisibility(fir.visibility), fir.name, fir.isVal, fir.initializer,
+                    callablesGenerator.createBackingField(
+                        this@Fir2IrLazyProperty,
+                        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(
-                        fir, IrDeclarationOrigin.PROPERTY_DELEGATE,
+                    callablesGenerator.createBackingField(
+                        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
                    )
                }
            }
@@ -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
@@ -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