[FIR] Get rid of all conditional reads of FirDeclaration.resolvePhase

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/FirJavaElementFinder.kt

@@ -96,7 +96,7 @@ class FirJavaElementFinder(
         )
 
         val superTypeRefs = when {
-            firClass.resolvePhase > FirResolvePhase.SUPER_TYPES -> firClass.superTypeRefs
+            firClass.superTypeRefs.all { it is FirResolvedTypeRef } -> firClass.superTypeRefs
             else -> firClass.resolveSupertypesInTheAir(session)
         }
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.contracts.description.ConeConditionalEffectDecla
 import org.jetbrains.kotlin.fir.contracts.description.ConeConstantReference
 import org.jetbrains.kotlin.fir.contracts.description.ConeReturnsEffectDeclaration
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.utils.isLocal
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
@@ -214,6 +215,7 @@ abstract class FirDataFlowAnalyzer<FLOW : Flow>(
     // ----------------------------------- Named function -----------------------------------
 
     fun enterFunction(function: FirFunction) {
+        if (function is FirDefaultPropertyAccessor) return
         if (function is FirAnonymousFunction) {
             enterAnonymousFunction(function)
             return
@@ -226,7 +228,8 @@ abstract class FirDataFlowAnalyzer<FLOW : Flow>(
         functionEnterNode.mergeIncomingFlow(shouldForkFlow = previousNode != null)
     }
 
-    fun exitFunction(function: FirFunction): FirControlFlowGraphReference {
+    fun exitFunction(function: FirFunction): FirControlFlowGraphReference? {
+        if (function is FirDefaultPropertyAccessor) return null
         if (function is FirAnonymousFunction) {
             return exitAnonymousFunction(function)
         }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt

@@ -407,8 +407,7 @@ abstract class AbstractFirStatusResolveTransformer(
             forceResolveStatusesOfSupertypes(regularClass)
             return
         }
-        if (regularClass.resolvePhase > FirResolvePhase.STATUS) return
+        if (regularClass.origin != FirDeclarationOrigin.Source) return
-        val firProvider = session.firProvider
         val statusComputationStatus = statusComputationSession[regularClass]
         if (!statusComputationStatus.requiresComputation) return
 
@@ -425,6 +424,7 @@ abstract class AbstractFirStatusResolveTransformer(
             }
             reverse()
         } else buildList<FirDeclaration> {
+            val firProvider = regularClass.moduleData.session.firProvider
             val outerClasses = generateSequence(symbol.classId) { classId ->
                 classId.outerClassId
             }.mapTo(mutableListOf()) { firProvider.getFirClassifierByFqName(it) }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt

@@ -436,14 +436,14 @@ class SupertypeComputationSession {
 
     val supertypesSupplier: SupertypeSupplier = object : SupertypeSupplier() {
         override fun forClass(firClass: FirClass, useSiteSession: FirSession): List<ConeClassLikeType> {
-            if (firClass.resolvePhase > FirResolvePhase.SUPER_TYPES) return firClass.superConeTypes
+            if (firClass.superTypeRefs.all { it is FirResolvedTypeRef }) return firClass.superConeTypes
             return (getSupertypesComputationStatus(firClass) as? SupertypeComputationStatus.Computed)?.supertypeRefs?.mapNotNull {
                 it.coneTypeSafe<ConeClassLikeType>()
             }.orEmpty()
         }
 
         override fun expansionForTypeAlias(typeAlias: FirTypeAlias, useSiteSession: FirSession): ConeClassLikeType? {
-            if (typeAlias.resolvePhase > FirResolvePhase.SUPER_TYPES) return typeAlias.expandedConeType
+            if (typeAlias.expandedTypeRef is FirResolvedTypeRef) return typeAlias.expandedConeType
             return (getSupertypesComputationStatus(typeAlias) as? SupertypeComputationStatus.Computed)
                 ?.supertypeRefs
                 ?.getOrNull(0)?.coneTypeSafe()

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt

@@ -107,7 +107,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
     }
 
     override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): FirEnumEntry {
-        if (enumEntry.resolvePhase == transformerPhase) return enumEntry
+        if (implicitTypeOnly || enumEntry.initializerResolved) return enumEntry
         transformer.replaceDeclarationResolvePhaseIfNeeded(enumEntry, transformerPhase)
         return context.forEnumEntry {
             (enumEntry.transformChildren(this, data) as FirEnumEntry)
@@ -126,11 +126,8 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
         }
 
         val returnTypeRef = property.returnTypeRef
+        if (property.initializerAndAccessorsAreResolved) return property
         if (returnTypeRef !is FirImplicitTypeRef && implicitTypeOnly) return property
-        if (property.resolvePhase == transformerPhase) return property
-        if (property.resolvePhase == FirResolvePhase.BODY_RESOLVE || property.resolvePhase == transformerPhase) {
-            return property
-        }
 
         property.transformReceiverTypeRef(transformer, ResolutionMode.ContextIndependent)
         dataFlowAnalyzer.enterProperty(property)
@@ -158,6 +155,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
             dataFlowAnalyzer.exitProperty(property)?.let {
                 property.replaceControlFlowGraphReference(FirControlFlowGraphReferenceImpl(it))
             }
+            property.replaceInitializerAndAccessorsAreResolved(true)
             property
         }
     }
@@ -165,9 +163,8 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
     override fun transformField(field: FirField, data: ResolutionMode): FirField {
         val returnTypeRef = field.returnTypeRef
         if (implicitTypeOnly) return field
-        if (field.resolvePhase == FirResolvePhase.BODY_RESOLVE || field.resolvePhase == transformerPhase) {
+        if (field.initializerResolved) return field
-            return field
+
-        }
         dataFlowAnalyzer.enterField(field)
         return withFullBodyResolve {
             context.withField(field) {
@@ -394,23 +391,17 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
         regularClass: FirRegularClass,
         data: ResolutionMode
     ): FirRegularClass {
-        val notAnalyzed = regularClass.resolvePhase < transformerPhase
+        dataFlowAnalyzer.enterClass()
-
-        if (notAnalyzed) {
-            dataFlowAnalyzer.enterClass()
-        }
 
         val result = context.withRegularClass(regularClass, components) {
             transformDeclarationContent(regularClass, data) as FirRegularClass
         }
 
-        if (notAnalyzed) {
+        if (!implicitTypeOnly) {
-            if (!implicitTypeOnly) {
+            val controlFlowGraph = dataFlowAnalyzer.exitRegularClass(result)
-                val controlFlowGraph = dataFlowAnalyzer.exitRegularClass(result)
+            result.replaceControlFlowGraphReference(FirControlFlowGraphReferenceImpl(controlFlowGraph))
-                result.replaceControlFlowGraphReference(FirControlFlowGraphReferenceImpl(controlFlowGraph))
+        } else {
-            } else {
+            dataFlowAnalyzer.exitClass()
-                dataFlowAnalyzer.exitClass()
-            }
         }
 
         return result
@@ -476,7 +467,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
         simpleFunction: FirSimpleFunction,
         data: ResolutionMode
     ): FirSimpleFunction {
-        if (simpleFunction.resolvePhase == FirResolvePhase.BODY_RESOLVE || simpleFunction.resolvePhase == transformerPhase) {
+        if (simpleFunction.bodyResolved) {
             return simpleFunction
         }
         val returnTypeRef = simpleFunction.returnTypeRef
@@ -540,7 +531,7 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
         function: FirFunction,
         data: ResolutionMode
     ): FirStatement {
-        val functionIsNotAnalyzed = transformerPhase != function.resolvePhase
+        val functionIsNotAnalyzed = !function.bodyResolved
         if (functionIsNotAnalyzed) {
             dataFlowAnalyzer.enterFunction(function)
         }
@@ -892,4 +883,10 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
             return valueParameter
         }
     }
+
+    private val FirVariable.initializerResolved: Boolean
+        get() = initializer?.typeRef is FirResolvedTypeRef
+
+    private val FirFunction.bodyResolved: Boolean
+        get() = body?.typeRef is FirResolvedTypeRef
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirProperty.kt

@@ -49,6 +49,7 @@ abstract class FirProperty : FirVariable(), FirTypeParametersOwner, FirControlFl
     abstract val backingFieldSymbol: FirBackingFieldSymbol
     abstract val delegateFieldSymbol: FirDelegateFieldSymbol?
     abstract val isLocal: Boolean
+    abstract val initializerAndAccessorsAreResolved: Boolean
     abstract override val typeParameters: List<FirTypeParameter>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitProperty(this, data)
@@ -67,6 +68,8 @@ abstract class FirProperty : FirVariable(), FirTypeParametersOwner, FirControlFl
 
     abstract override fun replaceControlFlowGraphReference(newControlFlowGraphReference: FirControlFlowGraphReference?)
 
+    abstract fun replaceInitializerAndAccessorsAreResolved(newInitializerAndAccessorsAreResolved: Boolean)
+
     abstract override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirProperty
 
     abstract override fun <D> transformReceiverTypeRef(transformer: FirTransformer<D>, data: D): FirProperty

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirPropertyBuilder.kt

@@ -59,6 +59,7 @@ class FirPropertyBuilder : FirDeclarationBuilder, FirTypeParametersOwnerBuilder,
     lateinit var symbol: FirPropertySymbol
     var delegateFieldSymbol: FirDelegateFieldSymbol? = null
     var isLocal: Boolean by kotlin.properties.Delegates.notNull<Boolean>()
+    var initializerAndAccessorsAreResolved: Boolean = false
     override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
 
     override fun build(): FirProperty {
@@ -83,6 +84,7 @@ class FirPropertyBuilder : FirDeclarationBuilder, FirTypeParametersOwnerBuilder,
             symbol,
             delegateFieldSymbol,
             isLocal,
+            initializerAndAccessorsAreResolved,
             typeParameters,
         )
     }
@@ -123,6 +125,7 @@ inline fun buildPropertyCopy(original: FirProperty, init: FirPropertyBuilder.()
     copyBuilder.symbol = original.symbol
     copyBuilder.delegateFieldSymbol = original.delegateFieldSymbol
     copyBuilder.isLocal = original.isLocal
+    copyBuilder.initializerAndAccessorsAreResolved = original.initializerAndAccessorsAreResolved
     copyBuilder.typeParameters.addAll(original.typeParameters)
     return copyBuilder.apply(init).build()
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirPropertyImpl.kt

@@ -52,6 +52,7 @@ internal class FirPropertyImpl(
     override val symbol: FirPropertySymbol,
     override val delegateFieldSymbol: FirDelegateFieldSymbol?,
     override val isLocal: Boolean,
+    override var initializerAndAccessorsAreResolved: Boolean,
     override val typeParameters: MutableList<FirTypeParameter>,
 ) : FirProperty() {
     override val isVal: Boolean get() = !isVar
@@ -160,4 +161,8 @@ internal class FirPropertyImpl(
     override fun replaceControlFlowGraphReference(newControlFlowGraphReference: FirControlFlowGraphReference?) {
         controlFlowGraphReference = newControlFlowGraphReference
     }
+
+    override fun replaceInitializerAndAccessorsAreResolved(newInitializerAndAccessorsAreResolved: Boolean) {
+        initializerAndAccessorsAreResolved = newInitializerAndAccessorsAreResolved
+    }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultPropertyAccessor.kt

@@ -17,11 +17,8 @@ import org.jetbrains.kotlin.fir.declarations.builder.buildDefaultSetterValuePara
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertyAccessorSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitUnitTypeRef
-import org.jetbrains.kotlin.name.CallableId
-import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 
 @OptIn(FirImplementationDetail::class)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/synthetic/FirSyntheticProperty.kt

@@ -81,6 +81,9 @@ class FirSyntheticProperty(
     // ???
     override val backingFieldSymbol: FirBackingFieldSymbol = FirBackingFieldSymbol(symbol.callableId)
 
+    override val initializerAndAccessorsAreResolved: Boolean
+        get() = true
+
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         returnTypeRef.accept(visitor, data)
         status.accept(visitor, data)
@@ -149,4 +152,8 @@ class FirSyntheticProperty(
     override fun replaceInitializer(newInitializer: FirExpression?) {
         throw AssertionError("Mutation of synthetic property isn't supported")
     }
+
+    override fun replaceInitializerAndAccessorsAreResolved(newInitializerAndAccessorsAreResolved: Boolean) {
+        throw AssertionError("Mutation of synthetic property isn't supported")
+    }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/utils/FirStatusUtils.kt

@@ -8,7 +8,10 @@ package org.jetbrains.kotlin.fir.declarations.utils
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.fir.FirRenderer
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.render
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.contract
 
 inline val FirMemberDeclaration.modality: Modality? get() = status.modality
 inline val FirMemberDeclaration.isAbstract: Boolean get() = status.modality == Modality.ABSTRACT

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt

@@ -202,6 +202,7 @@ object BuilderConfigurator : AbstractBuilderConfigurator<FirTreeBuilder>(FirTree
             parents += typeParametersOwnerBuilder
             defaultNull("getter", "setter", "containerSource", "delegateFieldSymbol")
             default("resolvePhase", "FirResolvePhase.RAW_FIR")
+            defaultFalse("initializerAndAccessorsAreResolved")
             withCopy()
         }
 

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt

@@ -311,6 +311,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
             +field("backingFieldSymbol", backingFieldSymbolType)
             +field("delegateFieldSymbol", delegateFieldSymbolType, nullable = true)
             +booleanField("isLocal")
+            +booleanField("initializerAndAccessorsAreResolved", withReplace = true)
             +typeParameters
         }
 

idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/api/DeclarationCopyBuilder.kt

@@ -59,6 +59,10 @@ internal object DeclarationCopyBuilder {
             getter = propertyWithBody.getter
             setter = copySetter
 
+            if (propertyResolvePhase < FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) {
+                initializerAndAccessorsAreResolved = false
+            }
+
             initDeclaration(this@withBodyFrom, propertyWithBody)
             resolvePhase = propertyResolvePhase
         }