[FIR IDE] Replace FIR phase update to FIR IDE

2021-07-07 17:57:45 +02:00
parent df9a3c0300
commit 2fd6c55fc8
54 changed files with 1011 additions and 1053 deletions
@@ -24,10 +24,6 @@ object FirProjectionRelationChecker : FirBasicDeclarationChecker() {
        }

        if (declaration is FirTypedDeclaration) {
-            // The body of function contract is not fully resolved.
-            if (declaration.resolvePhase == FirResolvePhase.CONTRACTS) {
-                return
-            }
            checkTypeRef(declaration.returnTypeRef, context, reporter)
        }

@@ -16,7 +16,6 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.createFunctionalType
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.inference.*
-import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.firUnsafe
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType
 import org.jetbrains.kotlin.fir.resolve.transformers.ensureResolvedTypeDeclaration
 import org.jetbrains.kotlin.fir.returnExpressions
@@ -430,7 +429,6 @@ internal fun Candidate.resolveArgument(
    context: ResolutionContext
 ) {
    argument.resultType.ensureResolvedTypeDeclaration(context.session)
-
    val expectedType =
        prepareExpectedType(context.session, context.bodyResolveComponents.scopeSession, callInfo, argument, parameter, context)
    resolveArgumentExpression(
@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.resolve.calls

 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRefsOwner
 import org.jetbrains.kotlin.fir.renderWithType
@@ -17,6 +18,7 @@ import org.jetbrains.kotlin.fir.resolve.inference.model.ConeExplicitTypeParamete
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
+import org.jetbrains.kotlin.fir.symbols.ensureResolved
 import org.jetbrains.kotlin.fir.typeContext
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.FirTypePlaceholderProjection
@@ -27,6 +29,7 @@ import org.jetbrains.kotlin.resolve.calls.inference.model.SimpleConstraintSystem
 internal object CreateFreshTypeVariableSubstitutorStage : ResolutionStage() {
    override suspend fun check(candidate: Candidate, callInfo: CallInfo, sink: CheckerSink, context: ResolutionContext) {
        val declaration = candidate.symbol.fir
+        candidate.symbol.ensureResolved(FirResolvePhase.STATUS)
        if (declaration !is FirTypeParameterRefsOwner || declaration.typeParameters.isEmpty()) {
            candidate.substitutor = ConeSubstitutor.Empty
            candidate.freshVariables = emptyList()
@@ -18,6 +18,7 @@ import org.jetbrains.kotlin.fir.resolve.inference.*
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.scopes.FirUnstableSmartcastTypeScope
 import org.jetbrains.kotlin.fir.symbols.SyntheticSymbol
+import org.jetbrains.kotlin.fir.symbols.ensureResolved
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
@@ -153,6 +154,7 @@ internal object MapArguments : ResolutionStage() {

 internal object CheckArguments : CheckerStage() {
    override suspend fun check(candidate: Candidate, callInfo: CallInfo, sink: CheckerSink, context: ResolutionContext) {
+        candidate.symbol.ensureResolved(FirResolvePhase.STATUS)
        val argumentMapping =
            candidate.argumentMapping ?: error("Argument should be already mapped while checking arguments!")
        for (argument in callInfo.arguments) {
@@ -27,21 +27,9 @@ abstract class FirAbstractPhaseTransformer<D>(

    override fun transformFile(file: FirFile, data: D): FirFile {
        checkSessionConsistency(file)
-        if (file.resolvePhase < transformerPhase) {
-            file.replaceResolvePhase(transformerPhase)
-        }
-
        return super.transformFile(file, data)
    }

-    override fun transformDeclaration(declaration: FirDeclaration, data: D): FirDeclaration {
-        if (declaration.resolvePhase < transformerPhase) {
-            declaration.replaceResolvePhase(transformerPhase)
-        }
-
-        return super.transformDeclaration(declaration, data)
-    }
-
    protected fun checkSessionConsistency(file: FirFile) {
        assert(session === file.moduleData.session) {
            "File ${file.name} and transformer ${this::class} have inconsistent sessions"
@@ -33,8 +33,6 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(
    protected val classDeclarationsStack = ArrayDeque<FirRegularClass>()
    protected val towerScope = FirCompositeScope(scopes.asReversed())

-    protected open fun needReplacePhase(firDeclaration: FirDeclaration): Boolean = transformerPhase > firDeclaration.resolvePhase
-
    protected inline fun <T> withScopeCleanup(crossinline l: () -> T): T {
        val sizeBefore = scopes.size
        val result = l()
@@ -56,9 +54,6 @@ abstract class FirAbstractTreeTransformerWithSuperTypes(
        firClass: FirClass,
        data: Any?
    ): FirStatement {
-        if (needReplacePhase(firClass)) {
-            firClass.replaceResolvePhase(transformerPhase)
-        }
        return withScopeCleanup {
            // Otherwise annotations may try to resolve
            // themselves as inner classes of the `firClass`
@@ -42,7 +42,6 @@ open class FirImportResolveTransformer protected constructor(

    override fun transformFile(file: FirFile, data: Any?): FirFile {
        checkSessionConsistency(file)
-        file.replaceResolvePhase(transformerPhase)
        return file.also {
            val prevValue = currentFile
            currentFile = file
@@ -5,20 +5,10 @@

 package org.jetbrains.kotlin.fir.resolve.transformers

-import org.jetbrains.kotlin.fir.FirRenderer
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.FirPhaseManager

 object FirPhaseCheckingPhaseManager : FirPhaseManager() {
-    override fun ensureResolved(symbol: FirBasedSymbol<*>, requiredPhase: FirResolvePhase) {
-        val fir = symbol.fir
-        val availablePhase = fir.resolvePhase
-        require(availablePhase >= requiredPhase) {
-            "Expected at least $requiredPhase for $symbol but was $availablePhase\n{${fir.render(renderMode)}"
-        }
-    }
-
-    private val renderMode = FirRenderer.RenderMode.WithResolvePhases.copy(renderDeclarationOrigin = true)
+    override fun ensureResolved(symbol: FirBasedSymbol<*>, requiredPhase: FirResolvePhase) = Unit
 }
@@ -169,7 +169,6 @@ open class FirDesignatedStatusResolveTransformer(
            val computationStatus = statusComputationSession.startComputing(regularClass)
            forceResolveStatusesOfSupertypes(regularClass)
            if (computationStatus != StatusComputationSession.StatusComputationStatus.Computed) {
-                updateResolvePhaseOfMembers(regularClass)
                regularClass.transformStatus(this, statusResolver.resolveStatus(regularClass, containingClass, isLocal = false))
            }
        } else {
@@ -257,12 +256,7 @@ abstract class AbstractFirStatusResolveTransformer(
    protected abstract fun FirDeclaration.needResolveMembers(): Boolean
    protected abstract fun FirDeclaration.needResolveNestedClassifiers(): Boolean

-    protected open fun needReplacePhase(firDeclaration: FirDeclaration): Boolean = transformerPhase > firDeclaration.resolvePhase
-
    override fun transformFile(file: FirFile, data: FirResolvedDeclarationStatus?): FirFile {
-        if (needReplacePhase(file)) {
-            file.replaceResolvePhase(transformerPhase)
-        }
        transformDeclarationContent(file, data)
        return file
    }
@@ -288,9 +282,6 @@ abstract class AbstractFirStatusResolveTransformer(
        declaration: FirDeclaration,
        data: FirResolvedDeclarationStatus?
    ): FirDeclaration {
-        if (needReplacePhase(declaration)) {
-            declaration.replaceResolvePhase(transformerPhase)
-        }
        return when (declaration) {
            is FirCallableDeclaration -> {
                if (declaration is FirFunction) {
@@ -342,18 +333,17 @@ abstract class AbstractFirStatusResolveTransformer(
        }

        if (declaration.needResolveMembers()) {
-            val members = declarations.filter { it !is FirClassLikeDeclaration }
-            members.forEach { member ->
-                if (needReplacePhase(member)) {
-                    member.replaceResolvePhase(transformerPhase)
+            declarations.forEach {
+                if (it !is FirClassLikeDeclaration) {
+                    it.transformSingle(this, data)
                }
            }
-            members.forEach { member -> member.transformSingle(this, data) }
        }
        if (declaration.needResolveNestedClassifiers()) {
-            val members = declarations.filterIsInstance<FirClassLikeDeclaration>()
-            for (klass in members) {
-                klass.transformSingle(this, data)
+            declarations.forEach {
+                if (it is FirClassLikeDeclaration) {
+                    it.transformSingle(this, data)
+                }
            }
        }
        return declaration
@@ -366,23 +356,10 @@ abstract class AbstractFirStatusResolveTransformer(
    ): FirStatement {
        return storeClass(klass) {
            klass.typeParameters.forEach { it.transformSingle(this, data) }
-            if (needReplacePhase(klass)) {
-                klass.replaceResolvePhase(transformerPhase)
-            }
            transformDeclarationContent(klass, data)
        } as FirStatement
    }

-    protected fun updateResolvePhaseOfMembers(regularClass: FirRegularClass) {
-        for (declaration in regularClass.declarations) {
-            if (declaration is FirProperty || declaration is FirSimpleFunction) {
-                if (needReplacePhase(declaration)) {
-                    declaration.replaceResolvePhase(transformerPhase)
-                }
-            }
-        }
-    }
-
    protected fun forceResolveStatusesOfSupertypes(regularClass: FirRegularClass) {
        for (superTypeRef in regularClass.superTypeRefs) {
            forceResolveStatusOfCorrespondingClass(superTypeRef)
@@ -460,10 +437,6 @@ abstract class AbstractFirStatusResolveTransformer(
            statusResolver.resolveStatus(propertyAccessor, containingClass, containingProperty, isLocal = false)
        )

-        if (needReplacePhase(propertyAccessor)) {
-            propertyAccessor.replaceResolvePhase(transformerPhase)
-        }
-
        propertyAccessor.transformValueParameters(this, null)
    }

@@ -480,9 +453,6 @@ abstract class AbstractFirStatusResolveTransformer(
        simpleFunction: FirSimpleFunction,
        data: FirResolvedDeclarationStatus?
    ): FirStatement {
-        if (needReplacePhase(simpleFunction)) {
-            simpleFunction.replaceResolvePhase(transformerPhase)
-        }
        val resolvedStatus = statusResolver.resolveStatus(simpleFunction, containingClass, isLocal = false)
        simpleFunction.transformStatus(this, resolvedStatus)
        calculateDeprecations(simpleFunction)
@@ -493,9 +463,6 @@ abstract class AbstractFirStatusResolveTransformer(
        property: FirProperty,
        data: FirResolvedDeclarationStatus?
    ): FirStatement {
-        if (needReplacePhase(property)) {
-            property.replaceResolvePhase(transformerPhase)
-        }
        property.transformStatus(this, statusResolver.resolveStatus(property, containingClass, isLocal = false))

        property.getter?.let { transformPropertyAccessor(it, property) }
@@ -105,17 +105,11 @@ open class FirApplySupertypesTransformer(
        return element
    }

-    protected open fun needReplacePhase(firDeclaration: FirDeclaration): Boolean = FirResolvePhase.SUPER_TYPES > firDeclaration.resolvePhase
-
    protected open fun transformDeclarationContent(declaration: FirDeclaration, data: Any?): FirDeclaration {
        return declaration.transformChildren(this, null) as FirDeclaration
    }

    override fun transformFile(file: FirFile, data: Any?): FirFile {
-        if (needReplacePhase(file)) {
-            file.replaceResolvePhase(FirResolvePhase.SUPER_TYPES)
-        }
-
        return transformDeclarationContent(file, null) as FirFile
    }

@@ -132,9 +126,6 @@ open class FirApplySupertypesTransformer(
            // TODO: Replace with an immutable version or transformer
            firClass.replaceSuperTypeRefs(supertypeRefs)
        }
-        if (needReplacePhase(firClass)) {
-            firClass.replaceResolvePhase(FirResolvePhase.SUPER_TYPES)
-        }
    }

    override fun transformAnonymousObject(anonymousObject: FirAnonymousObject, data: Any?): FirStatement {
@@ -153,9 +144,6 @@ open class FirApplySupertypesTransformer(

    override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Any?): FirStatement {
        if (typeAlias.expandedTypeRef is FirResolvedTypeRef) {
-            if (needReplacePhase(typeAlias)) {
-                typeAlias.replaceResolvePhase(FirResolvePhase.SUPER_TYPES)
-            }
            return typeAlias
        }
        val supertypeRefs = getResolvedSupertypeRefs(typeAlias)
@@ -166,9 +154,6 @@ open class FirApplySupertypesTransformer(

        // TODO: Replace with an immutable version or transformer
        typeAlias.replaceExpandedTypeRef(supertypeRefs[0])
-        if (needReplacePhase(typeAlias)) {
-            typeAlias.replaceResolvePhase(FirResolvePhase.SUPER_TYPES)
-        }
        return typeAlias
    }
 }
@@ -96,9 +96,6 @@ open class FirTypeResolveTransformer(
    }

    override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Any?): FirEnumEntry {
-        if (needReplacePhase(enumEntry)) {
-            enumEntry.replaceResolvePhase(FirResolvePhase.TYPES)
-        }
        enumEntry.transformReturnTypeRef(this, data)
        enumEntry.transformTypeParameters(this, data)
        enumEntry.transformAnnotations(this, data)
@@ -108,14 +105,6 @@ open class FirTypeResolveTransformer(
    override fun transformProperty(property: FirProperty, data: Any?): FirProperty {
        return withScopeCleanup {
            property.addTypeParametersScope()
-            if (needReplacePhase(property)) {
-                property.replaceResolvePhase(FirResolvePhase.TYPES)
-                property.getter?.replaceResolvePhase(FirResolvePhase.TYPES)
-                property.setter?.replaceResolvePhase(FirResolvePhase.TYPES)
-                property.setter?.valueParameters?.forEach {
-                    it.replaceResolvePhase(FirResolvePhase.TYPES)
-                }
-            }
            property.transformTypeParameters(this, data)
                .transformReturnTypeRef(this, data)
                .transformReceiverTypeRef(this, data)
@@ -136,9 +125,6 @@ open class FirTypeResolveTransformer(

    override fun transformField(field: FirField, data: Any?): FirField {
        return withScopeCleanup {
-            if (needReplacePhase(field)) {
-                field.replaceResolvePhase(FirResolvePhase.TYPES)
-            }
            field.transformReturnTypeRef(this, data).transformAnnotations(this, data)
            field
        }
@@ -43,14 +43,6 @@ abstract class FirAbstractBodyResolveTransformer(phase: FirResolvePhase) : FirAb

    final override val session: FirSession get() = components.session

-    protected open fun needReplacePhase(firDeclaration: FirDeclaration): Boolean = transformerPhase > firDeclaration.resolvePhase
-
-    fun replaceDeclarationResolvePhaseIfNeeded(firDeclaration: FirDeclaration, newResolvePhase: FirResolvePhase) {
-        if (needReplacePhase(firDeclaration) && newResolvePhase > firDeclaration.resolvePhase) {
-            firDeclaration.replaceResolvePhase(newResolvePhase)
-        }
-    }
-
    @OptIn(PrivateForInline::class)
    internal inline fun <T> withFullBodyResolve(crossinline l: () -> T): T {
        val shouldSwitchMode = implicitTypeOnly
@@ -50,7 +50,6 @@ open class FirBodyResolveTransformer(
        return context.withFile(file, components) {
            firTowerDataContextCollector?.addFileContext(file, context.towerDataContext)

-            file.replaceResolvePhase(transformerPhase)
            @Suppress("UNCHECKED_CAST")
            transformDeclarationContent(file, data) as FirFile
        }
@@ -71,7 +71,6 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor

    private fun transformDeclarationContent(declaration: FirDeclaration, data: ResolutionMode): FirDeclaration {
        transformer.firTowerDataContextCollector?.addDeclarationContext(declaration, context.towerDataContext)
-        transformer.replaceDeclarationResolvePhaseIfNeeded(declaration, transformerPhase)
        return transformer.transformDeclarationContent(declaration, data)
    }

@@ -89,7 +88,6 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
            callableMember.valueParameters.forEach {
                it.transformReturnTypeRef(transformer, ResolutionMode.ContextIndependent)
                it.transformVarargTypeToArrayType()
-                it.replaceResolvePhase(FirResolvePhase.STATUS)
            }
        }
    }
@@ -102,14 +100,12 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor

    private fun doTransformTypeParameters(declaration: FirMemberDeclaration) {
        for (typeParameter in declaration.typeParameters) {
-            (typeParameter as? FirTypeParameter)?.let { transformer.replaceDeclarationResolvePhaseIfNeeded(it, FirResolvePhase.STATUS) }
            typeParameter.transformChildren(transformer, ResolutionMode.ContextIndependent)
        }
    }

    override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): FirEnumEntry {
        if (implicitTypeOnly || enumEntry.initializerResolved) return enumEntry
-        transformer.replaceDeclarationResolvePhaseIfNeeded(enumEntry, transformerPhase)
        return context.forEnumEntry {
            (enumEntry.transformChildren(this, data) as FirEnumEntry)
        }
@@ -152,7 +148,6 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
                    property.transformAccessors()
                }
            }
-            transformer.replaceDeclarationResolvePhaseIfNeeded(property, transformerPhase)
            dataFlowAnalyzer.exitProperty(property)?.let {
                property.replaceControlFlowGraphReference(FirControlFlowGraphReferenceImpl(it))
            }
@@ -174,7 +169,6 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
            if (field.initializer != null) {
                storeVariableReturnType(field)
            }
-            transformer.replaceDeclarationResolvePhaseIfNeeded(field, transformerPhase)
            dataFlowAnalyzer.exitField(field)
            field
        }
@@ -283,7 +277,6 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
        }
        variable.transformOtherChildren(transformer, ResolutionMode.ContextIndependent)
        context.storeVariable(variable)
-        transformer.replaceDeclarationResolvePhaseIfNeeded(variable, transformerPhase)
        dataFlowAnalyzer.exitLocalVariableDeclaration(variable)
        return variable
    }
@@ -386,7 +379,6 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
        typeAlias.transformAnnotations(transformer, data)
        transformer.firTowerDataContextCollector?.addDeclarationContext(typeAlias, context.towerDataContext)
        typeAlias.transformExpandedTypeRef(transformer, data)
-        transformer.replaceDeclarationResolvePhaseIfNeeded(typeAlias, transformerPhase)
        return typeAlias
    }

@@ -564,7 +556,6 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor
    private fun doTransformConstructor(constructor: FirConstructor, data: ResolutionMode): FirConstructor {
        val owningClass = context.containerIfAny as? FirRegularClass

-        transformer.replaceDeclarationResolvePhaseIfNeeded(constructor, transformerPhase)
        dataFlowAnalyzer.enterFunction(constructor)

        constructor.transformTypeParameters(transformer, data)
@@ -604,7 +595,6 @@ open class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransfor

    override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): FirStatement {
        if (valueParameter.returnTypeRef is FirImplicitTypeRef) {
-            transformer.replaceDeclarationResolvePhaseIfNeeded(valueParameter, transformerPhase)
            valueParameter.replaceReturnTypeRef(
                valueParameter.returnTypeRef.errorTypeFromPrototype(
                    ConeSimpleDiagnostic("No type for parameter", DiagnosticKind.ValueParameterWithNoTypeAnnotation)
@@ -5,9 +5,7 @@

 package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve

-import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.ResolutionMode
 import org.jetbrains.kotlin.fir.resolve.transformers.FirProviderInterceptor
 import org.jetbrains.kotlin.fir.resolve.transformers.runStatusResolveForLocalClass
@@ -22,7 +20,7 @@ fun <F : FirClassLikeDeclaration> F.runAllPhasesForLocalClass(
    firTowerDataContextCollector: FirTowerDataContextCollector?,
    firProviderInterceptor: FirProviderInterceptor?,
 ): F {
-    if (this.resolvePhase > FirResolvePhase.RAW_FIR) return this
+    if (this is FirMemberDeclaration && status is FirResolvedDeclarationStatus) return this
    if (this is FirRegularClass) {
        components.context.storeClassIfNotNested(this)
    }
@@ -54,7 +54,6 @@ open class FirContractResolveTransformer(
            simpleFunction: FirSimpleFunction,
            data: ResolutionMode
        ): FirSimpleFunction {
-            simpleFunction.updatePhase()
            if (!simpleFunction.hasContractToResolve) {
                return simpleFunction
            }
@@ -76,17 +75,14 @@ open class FirContractResolveTransformer(
        }

        override fun transformProperty(property: FirProperty, data: ResolutionMode): FirProperty {
-            property.updatePhase()
            if (
                property.getter?.hasContractToResolve != true && property.setter?.hasContractToResolve != true ||
                property.isLocal || property.delegate != null
            ) {
-                property.updatePhaseForAccessors()
                return property
            }
            if (property is FirSyntheticProperty) {
                transformSimpleFunction(property.getter.delegate, data)
-                property.updatePhaseForAccessors()
                return property
            }
            context.withProperty(property) {
@@ -96,13 +92,7 @@ open class FirContractResolveTransformer(
            return property
        }

-        private fun FirProperty.updatePhaseForAccessors() {
-            getter?.updatePhase()
-            setter?.updatePhase()
-        }
-
        override fun transformField(field: FirField, data: ResolutionMode): FirField {
-            field.updatePhase()
            return field
        }

@@ -110,7 +100,6 @@ open class FirContractResolveTransformer(
            propertyAccessor: FirPropertyAccessor,
            owner: FirProperty
        ): FirStatement {
-            propertyAccessor.updatePhase()
            if (!propertyAccessor.hasContractToResolve) {
                return propertyAccessor
            }
@@ -229,7 +218,6 @@ open class FirContractResolveTransformer(
        }

        override fun transformRegularClass(regularClass: FirRegularClass, data: ResolutionMode): FirStatement {
-            regularClass.updatePhase()
            regularClass.transformCompanionObject(this, data)
            context.withRegularClass(regularClass, components, forContracts = true) {
                transformDeclarationContent(regularClass, data)
@@ -241,7 +229,6 @@ open class FirContractResolveTransformer(
            anonymousObject: FirAnonymousObject,
            data: ResolutionMode
        ): FirStatement {
-            anonymousObject.updatePhase()
            context.withAnonymousObject(anonymousObject, components) {
                transformDeclarationContent(anonymousObject, data)
            }
@@ -252,17 +239,14 @@ open class FirContractResolveTransformer(
            anonymousInitializer: FirAnonymousInitializer,
            data: ResolutionMode
        ): FirAnonymousInitializer {
-            anonymousInitializer.updatePhase()
            return anonymousInitializer
        }

        override fun transformConstructor(constructor: FirConstructor, data: ResolutionMode): FirConstructor {
-            constructor.updatePhase()
            return constructor
        }

        override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): FirEnumEntry {
-            enumEntry.updatePhase()
            return enumEntry
        }

@@ -274,10 +258,6 @@ open class FirContractResolveTransformer(

        private val FirContractDescriptionOwner.hasContractToResolve: Boolean
            get() = contractDescription is FirLegacyRawContractDescription || contractDescription is FirRawContractDescription
-
-        private fun FirDeclaration.updatePhase() {
-            transformer.replaceDeclarationResolvePhaseIfNeeded(this, FirResolvePhase.CONTRACTS)
-        }
    }
 }

@@ -44,7 +44,6 @@ class FirPluginAnnotationsResolveTransformer(
        checkSessionConsistency(file)
        if (!extensionService.hasPredicateBasedExtensions) return file
        val registeredPluginAnnotations = session.registeredPluginAnnotations
-        file.replaceResolvePhase(FirResolvePhase.ANNOTATIONS_FOR_PLUGINS)
        val newAnnotations = file.resolveAnnotations(registeredPluginAnnotations.annotations, registeredPluginAnnotations.metaAnnotations)
        if (!newAnnotations.isEmpty) {
            for (metaAnnotation in newAnnotations.keySet()) {
@@ -66,7 +66,6 @@ class FirClassDeclaredMemberScope(
        val symbols = callablesIndex[name] ?: emptyList()
        for (symbol in symbols) {
            if (symbol is D) {
-                symbol.ensureResolvedForCalls()
                processor(symbol)
            }
        }