[FIR] rename ensureResolve -> lazyResolveToPhase as it better describes function semantics

2022-08-09 14:13:04 +02:00
parent e7e9c24473
commit 0748f28efe
64 changed files with 210 additions and 221 deletions
@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.fir.scopes.impl.toConeType
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
@@ -219,7 +219,7 @@ internal class KtSymbolByFirBuilder constructor(
        }

        fun buildFunctionSignature(firSymbol: FirNamedFunctionSymbol): KtFunctionLikeSignature<KtFirFunctionSymbol> {
-            firSymbol.ensureResolved(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
+            firSymbol.lazyResolveToPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
            val functionSymbol = buildFunctionSymbol(firSymbol)
            return KtFunctionLikeSignature(
                functionSymbol,
@@ -320,7 +320,7 @@ internal class KtSymbolByFirBuilder constructor(
        }

        fun buildPropertySignature(firSymbol: FirPropertySymbol): KtVariableLikeSignature<KtVariableSymbol> {
-            firSymbol.ensureResolved(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
+            firSymbol.lazyResolveToPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
            return KtVariableLikeSignature(
                buildPropertySymbol(firSymbol),
                typeBuilder.buildKtType(firSymbol.fir.returnTypeRef),
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.fir.declarations.FirVariable
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirSafeCallExpression
 import org.jetbrains.kotlin.fir.resolve.calls.ImplicitReceiverValue
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.types.coneType
 import org.jetbrains.kotlin.fir.types.receiverType
 import org.jetbrains.kotlin.psi.KtExpression
@@ -44,7 +44,7 @@ internal class KtFirCompletionCandidateChecker(
        possibleExplicitReceiver: KtExpression?,
    ): KtExtensionApplicabilityResult {
        require(firSymbolForCandidate is KtFirSymbol<*>)
-        firSymbolForCandidate.firSymbol.ensureResolved(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
+        firSymbolForCandidate.firSymbol.lazyResolveToPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
        val declaration = firSymbolForCandidate.firSymbol.fir as FirCallableDeclaration
        return checkExtension(declaration, originalFile, nameExpression, possibleExplicitReceiver)
    }
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.realPsi
 import org.jetbrains.kotlin.fir.references.FirNamedReference
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.types.FirErrorTypeRef
@@ -50,7 +50,7 @@ internal class KtFirImportOptimizer(
    override fun analyseImports(file: KtFile): KtImportOptimizerResult {
        assertIsValidAndAccessible()

-        val firFile = file.getOrBuildFirFile(firResolveSession).apply { ensureResolved(FirResolvePhase.BODY_RESOLVE) }
+        val firFile = file.getOrBuildFirFile(firResolveSession).apply { lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE) }

        val existingImports = file.importDirectives

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.analysis.api.fir.components

 import com.intellij.openapi.project.Project
-import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analysis.api.KtAnalysisApiInternals
 import org.jetbrains.kotlin.analysis.api.components.KtImplicitReceiver
 import org.jetbrains.kotlin.analysis.api.components.KtScopeContext
@@ -44,7 +43,7 @@ import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.*
 import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -71,15 +70,15 @@ internal class KtFirScopeProvider(
    private inline fun <T> KtSymbolWithMembers.withFirForScope(crossinline body: (FirClass) -> T): T? {
        return when (this) {
            is KtFirNamedClassOrObjectSymbol -> {
-                firSymbol.ensureResolved(FirResolvePhase.TYPES)
+                firSymbol.lazyResolveToPhase(FirResolvePhase.TYPES)
                body(firSymbol.fir)
            }
            is KtFirAnonymousObjectSymbol -> {
-                firSymbol.ensureResolved(FirResolvePhase.TYPES)
+                firSymbol.lazyResolveToPhase(FirResolvePhase.TYPES)
                body(firSymbol.fir)
            }
            is KtFirEnumEntrySymbol -> {
-                firSymbol.ensureResolved(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
+                firSymbol.lazyResolveToPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
                val initializer = firSymbol.fir.initializer ?: return null
                check(initializer is FirAnonymousObjectExpression) { "Unexpected enum entry initializer: ${initializer.javaClass}" }
                body(initializer.anonymousObject)
@@ -18,10 +18,9 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.superConeTypes
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.scopes.*
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirIntersectionOverrideFunctionSymbol
@@ -113,7 +112,7 @@ internal class KtFirSymbolDeclarationOverridesProvider(
        callableSymbol: KtFirSymbol<*>,
        crossinline process: (FirTypeScope, FirDeclaration) -> Unit
    ) {
-        containingDeclaration.firSymbol.ensureResolved(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
+        containingDeclaration.firSymbol.lazyResolveToPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
        val firContainer = containingDeclaration.firSymbol.fir
        val firCallableDeclaration = callableSymbol.firSymbol.fir

@@ -154,7 +153,7 @@ internal class KtFirSymbolDeclarationOverridesProvider(
        require(superClass is KtFirSymbol<*>)

        if (subClass == superClass) return false
-        subClass.firSymbol.ensureResolved(FirResolvePhase.SUPER_TYPES)
+        subClass.firSymbol.lazyResolveToPhase(FirResolvePhase.SUPER_TYPES)
        return isSubClassOf(
            subClass = subClass.firSymbol.fir as FirClass,
            superClass = superClass.firSymbol.fir as FirClass,
@@ -169,7 +168,7 @@ internal class KtFirSymbolDeclarationOverridesProvider(
        if (!checkDeep) return false
        subClass.superConeTypes.forEach { superType ->
            val superOfSub = superType.toRegularClassSymbol(rootModuleSession) ?: return@forEach
-            superOfSub.ensureResolved(FirResolvePhase.SUPER_TYPES)
+            superOfSub.lazyResolveToPhase(FirResolvePhase.SUPER_TYPES)
            if (isSubClassOf(superOfSub.fir, superClass, checkDeep = true)) return true
        }
        return false
@@ -14,14 +14,10 @@ import org.jetbrains.kotlin.analysis.api.fir.renderer.FirIdeRenderer
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbol
 import org.jetbrains.kotlin.analysis.api.fir.types.KtFirType
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
-import org.jetbrains.kotlin.analysis.api.signatures.KtCallableSignature
-import org.jetbrains.kotlin.analysis.api.signatures.KtFunctionLikeSignature
-import org.jetbrains.kotlin.analysis.api.signatures.KtVariableLikeSignature
 import org.jetbrains.kotlin.analysis.api.symbols.KtDeclarationSymbol
 import org.jetbrains.kotlin.analysis.api.types.KtType
-import org.jetbrains.kotlin.analysis.utils.printer.prettyPrint
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase

 internal class KtFirSymbolDeclarationRendererProvider(
    override val analysisSession: KtFirAnalysisSession,
@@ -35,7 +31,7 @@ internal class KtFirSymbolDeclarationRendererProvider(

    override fun renderDeclaration(symbol: KtDeclarationSymbol, options: KtDeclarationRendererOptions): String {
        require(symbol is KtFirSymbol<*>)
-        symbol.firSymbol.ensureResolved(FirResolvePhase.BODY_RESOLVE)
+        symbol.firSymbol.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
        return FirIdeRenderer.render(symbol.firSymbol.fir, options, symbol.firSymbol.fir.moduleData.session)
    }
 }
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.fir.expressions.FirGetClassCall
 import org.jetbrains.kotlin.fir.renderer.FirRenderer
 import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
@@ -66,7 +66,7 @@ internal class KtFirTypeProvider(

    override fun buildSelfClassType(symbol: KtNamedClassOrObjectSymbol): KtType {
        require(symbol is KtFirNamedClassOrObjectSymbol)
-        symbol.firSymbol.ensureResolved(FirResolvePhase.SUPER_TYPES)
+        symbol.firSymbol.lazyResolveToPhase(FirResolvePhase.SUPER_TYPES)
        val firClass = symbol.firSymbol.fir
        val type = ConeClassLikeTypeImpl(
            firClass.symbol.toLookupTag(),
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolvedSymbol
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.*
@@ -68,7 +68,7 @@ internal object FirCompileTimeConstantEvaluator {
            mode == KtConstantEvaluationMode.CONSTANT_EXPRESSION_EVALUATION && !isConst -> null
            isVal && hasInitializer -> {
                // NB: the initializer could be [FirLazyExpression] in [BodyBuildingMode.LAZY_BODIES].
-                this.ensureResolved(FirResolvePhase.BODY_RESOLVE) // to unwrap lazy body
+                this.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE) // to unwrap lazy body
                evaluate(fir.initializer, mode)
            }
            else -> null
@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
 import org.jetbrains.kotlin.fir.declarations.utils.*
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirSyntheticPropertySymbol
 import org.jetbrains.kotlin.fir.symbols.impl.isExtension
@@ -100,7 +100,7 @@ internal class KtFirKotlinPropertySymbol(
    // NB: `field` in accessors indicates the property should have a backing field. To see that, though, we need BODY_RESOLVE.
    override val hasBackingField: Boolean
        get() = withValidityAssertion {
-            firSymbol.ensureResolved(FirResolvePhase.BODY_RESOLVE)
+            firSymbol.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
            firSymbol.fir.hasBackingField
        }
    override val isLateInit: Boolean get() = withValidityAssertion { firSymbol.isLateInit }
@@ -20,11 +20,10 @@ import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.originalForIntersectionOverrideAttr
 import org.jetbrains.kotlin.fir.originalForSubstitutionOverride
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.SessionHolderImpl
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.util.ImplementationStatus

 internal class KtFirOverrideInfoProvider(
@@ -37,7 +36,7 @@ internal class KtFirOverrideInfoProvider(
        require(classSymbol is KtFirSymbol<*>)

        // Inspecting visibility requires resolving to status
-        classSymbol.firSymbol.ensureResolved(FirResolvePhase.STATUS)
+        classSymbol.firSymbol.lazyResolveToPhase(FirResolvePhase.STATUS)
        val memberFir = memberSymbol.firSymbol.fir as? FirCallableDeclaration ?: return false
        val parentClassFir = classSymbol.firSymbol.fir as? FirClass ?: return false

@@ -49,7 +48,7 @@ internal class KtFirOverrideInfoProvider(
        require(parentClassSymbol is KtFirSymbol<*>)

        // Inspecting implementation status requires resolving to status
-        parentClassSymbol.firSymbol.ensureResolved(FirResolvePhase.STATUS)
+        parentClassSymbol.firSymbol.lazyResolveToPhase(FirResolvePhase.STATUS)
        val memberFir = memberSymbol.firSymbol.fir as? FirCallableDeclaration ?: return null
        val parentClassFir = parentClassSymbol.firSymbol.fir as? FirClass ?: return null

@@ -64,7 +63,7 @@ internal class KtFirOverrideInfoProvider(

    override fun getOriginalContainingClassForOverride(symbol: KtCallableSymbol): KtClassOrObjectSymbol? {
        require(symbol is KtFirSymbol<*>)
-        symbol.firSymbol.ensureResolved(FirResolvePhase.STATUS)
+        symbol.firSymbol.lazyResolveToPhase(FirResolvePhase.STATUS)
        val firDeclaration = symbol.firSymbol.fir as FirCallableDeclaration
        val containingClass =
            getOriginalOverriddenSymbol(firDeclaration)?.containingClass()?.toSymbol(rootModuleSession) ?: return null
@@ -74,7 +73,7 @@ internal class KtFirOverrideInfoProvider(

    override fun getOriginalOverriddenSymbol(symbol: KtCallableSymbol): KtCallableSymbol? {
        require(symbol is KtFirSymbol<*>)
-        symbol.firSymbol.ensureResolved(FirResolvePhase.STATUS)
+        symbol.firSymbol.lazyResolveToPhase(FirResolvePhase.STATUS)
        val firDeclaration = symbol.firSymbol.fir as FirCallableDeclaration
        return getOriginalOverriddenSymbol(firDeclaration)
            ?.buildSymbol(analysisSession.firSymbolBuilder) as KtCallableSymbol?
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRefsOwner
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.renderer.FirRenderer
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
@@ -90,7 +90,7 @@ internal fun FirCallableSymbol<*>.dispatchReceiverType(
 }

 internal fun FirVariableSymbol<*>.getKtConstantInitializer(): KtInitializerValue? {
-    ensureResolved(FirResolvePhase.BODY_RESOLVE)
+    lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
    val firInitializer = fir.initializer ?: return null
    return firInitializer.asKtInitializerValue()
 }
@@ -7,14 +7,14 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir

 import org.jetbrains.kotlin.fir.ThreadSafeMutableState
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.symbols.FirPhaseManager
+import org.jetbrains.kotlin.fir.symbols.FirLazyDeclarationResolver
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirResolvableModuleSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSessionInvalidator

@ThreadSafeMutableState
-internal class LLFirPhaseManager(private val sessionInvalidator: LLFirSessionInvalidator) : FirPhaseManager() {
-    override fun ensureResolved(symbol: FirBasedSymbol<*>, requiredPhase: FirResolvePhase) {
+internal class LLFirLazyDeclarationResolver(private val sessionInvalidator: LLFirSessionInvalidator) : FirLazyDeclarationResolver() {
+    override fun lazyResolveToPhase(symbol: FirBasedSymbol<*>, toPhase: FirResolvePhase) {
        val fir = symbol.fir
        val session = fir.moduleData.session
        if (session !is LLFirResolvableModuleSession) return
@@ -23,7 +23,7 @@ internal class LLFirPhaseManager(private val sessionInvalidator: LLFirSessionInv
            moduleComponents.lazyFirDeclarationsResolver.lazyResolveDeclaration(
                firDeclarationToResolve = fir,
                scopeSession = moduleComponents.scopeSessionProvider.getScopeSession(),
-                toPhase = requiredPhase,
+                toPhase = toPhase,
                checkPCE = true,
            )
        } catch (e: Throwable) {
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.BodyResolveContext
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDesignatedBodyResolveTransformerForReturnTypeCalculator
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation
@@ -64,7 +64,7 @@ private class LLFirDesignatedBodyResolveTransformerForReturnTypeCalculatorImpl(
    private inline fun <D : FirCallableDeclaration> D.processCallable(body: (FirDeclarationDesignation) -> Unit) {
        if (this !== targetDeclaration) return
        if (resolvePhase < FirResolvePhase.TYPES && returnTypeRef is FirResolvedTypeRef) return
-        ensureResolved(FirResolvePhase.TYPES)
+        lazyResolveToPhase(FirResolvePhase.TYPES)
        if (returnTypeRef is FirImplicitTypeRef) {
            val declarationList = designation.filterIsInstance<FirDeclaration>()
            check(declarationList.isNotEmpty()) { "Invalid empty declaration designation" }
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.ReturnTypeCalculator
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.BodyResolveContext
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDesignatedBodyResolveTransformerForReturnTypeCalculator
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef

@@ -62,9 +62,9 @@ private class LLFirEnsureBasedTransformerForReturnTypeCalculatorImpl(
    private fun <T : FirCallableDeclaration> T.ensureReturnType() {
        if (this !== targetDeclaration) return
        if (resolvePhase < FirResolvePhase.TYPES && returnTypeRef is FirResolvedTypeRef) return
-        ensureResolved(FirResolvePhase.TYPES)
+        lazyResolveToPhase(FirResolvePhase.TYPES)
        if (returnTypeRef is FirImplicitTypeRef) {
-            ensureResolved(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
+            lazyResolveToPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
        }
    }

@@ -19,11 +19,11 @@ import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped
-import org.jetbrains.kotlin.fir.resolve.transformers.FirPhaseCheckingPhaseManager
+import org.jetbrains.kotlin.fir.resolve.transformers.FirCompilerLazyDeclarationResolver
 import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
 import org.jetbrains.kotlin.fir.session.registerCommonComponents
 import org.jetbrains.kotlin.fir.session.registerModuleData
-import org.jetbrains.kotlin.fir.symbols.FirPhaseManager
+import org.jetbrains.kotlin.fir.symbols.FirLazyDeclarationResolver
 import java.util.concurrent.ConcurrentHashMap
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.platform.TargetPlatform
@@ -50,7 +50,7 @@ import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
                bindSession(this@session)
            }
            registerIdeComponents(project)
-            register(FirPhaseManager::class, FirPhaseCheckingPhaseManager)
+            register(FirLazyDeclarationResolver::class, FirCompilerLazyDeclarationResolver)
            registerCommonComponents(LanguageVersionSettingsImpl.DEFAULT/*TODO*/)
            registerModuleData(moduleData)

@@ -20,13 +20,13 @@ import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped
-import org.jetbrains.kotlin.fir.resolve.transformers.FirPhaseCheckingPhaseManager
+import org.jetbrains.kotlin.fir.resolve.transformers.FirCompilerLazyDeclarationResolver
 import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
 import org.jetbrains.kotlin.fir.session.registerCommonComponents
 import org.jetbrains.kotlin.fir.session.registerCommonJavaComponents
 import org.jetbrains.kotlin.fir.session.registerJavaSpecificResolveComponents
 import org.jetbrains.kotlin.fir.session.registerModuleData
-import org.jetbrains.kotlin.fir.symbols.FirPhaseManager
+import org.jetbrains.kotlin.fir.symbols.FirLazyDeclarationResolver
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleResolver

@OptIn(PrivateSessionConstructor::class, SessionConfiguration::class)
@@ -47,7 +47,7 @@ internal class LLFirLibrarySessionFactory(
            val moduleData = LLFirModuleData(ktLibraryModule).apply { bindSession(this@session) }
            registerModuleData(moduleData)
            registerIdeComponents(project)
-            register(FirPhaseManager::class, FirPhaseCheckingPhaseManager)
+            register(FirLazyDeclarationResolver::class, FirCompilerLazyDeclarationResolver)
            registerCommonComponents(LanguageVersionSettingsImpl.DEFAULT/*TODO*/)
            registerCommonJavaComponents(JavaModuleResolver.getInstance(project))
            registerJavaSpecificResolveComponents()
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirGlobalResolveComponents
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirModuleResolveComponents
-import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseManager
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirLazyDeclarationResolver
 import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirDependentModuleProvidersBySessions
 import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirModuleWithDependenciesSymbolProvider
 import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirProvider
@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped
 import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
 import org.jetbrains.kotlin.fir.session.*
-import org.jetbrains.kotlin.fir.symbols.FirPhaseManager
+import org.jetbrains.kotlin.fir.symbols.FirLazyDeclarationResolver
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleResolver
 import java.util.concurrent.ConcurrentHashMap
@@ -77,7 +77,7 @@ internal class LLFirNonUnderContentRootSessionFactory(private val project: Proje
            )

            register(FirProvider::class, provider)
-            register(FirPhaseManager::class, LLFirPhaseManager(sessionInvalidator))
+            register(FirLazyDeclarationResolver::class, LLFirLazyDeclarationResolver(sessionInvalidator))

            val dependencyProvider = LLFirDependentModuleProvidersBySessions(this) {
                add(builtinsSession)
@@ -10,7 +10,7 @@ import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.search.ProjectScope
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirGlobalResolveComponents
 import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirModuleResolveComponents
-import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseManager
+import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirLazyDeclarationResolver
 import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.*
 import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.LLFirLibrarySessionFactory
 import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.registerIdeComponents
@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.scopes.wrapScopeWithJvmMapped
 import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider
 import org.jetbrains.kotlin.fir.session.*
-import org.jetbrains.kotlin.fir.symbols.FirPhaseManager
+import org.jetbrains.kotlin.fir.symbols.FirLazyDeclarationResolver
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.resolve.jvm.modules.JavaModuleResolver
@@ -101,7 +101,7 @@ internal object LLFirSessionFactory {
            )

            register(FirProvider::class, provider)
-            register(FirPhaseManager::class, LLFirPhaseManager(sessionInvalidator))
+            register(FirLazyDeclarationResolver::class, LLFirLazyDeclarationResolver(sessionInvalidator))

            registerCompilerPluginServices(contentScope, project, module)
            registerCompilerPluginExtensions(project, module)
@@ -206,7 +206,7 @@ internal object LLFirSessionFactory {

            register(FirProvider::class, provider)

-            register(FirPhaseManager::class, LLFirPhaseManager(sessionInvalidator))
+            register(FirLazyDeclarationResolver::class, LLFirLazyDeclarationResolver(sessionInvalidator))

            // We need FirRegisteredPluginAnnotations during extensions' registration process
            val annotationsResolver = project.createAnnotationResolver(contentScope)
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.realPsi
 import org.jetbrains.kotlin.fir.renderer.FirDeclarationRendererWithAttributes
 import org.jetbrains.kotlin.fir.renderer.FirRenderer
 import org.jetbrains.kotlin.fir.renderer.FirResolvePhaseRenderer
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtFile
@@ -66,7 +66,7 @@ abstract class AbstractFirLazyDeclarationResolveTest : AbstractLowLevelApiSingle
                .findResolveMe()
            for (currentPhase in FirResolvePhase.values()) {
                if (currentPhase == FirResolvePhase.SEALED_CLASS_INHERITORS) continue
-                declarationToResolve.ensureResolved(currentPhase)
+                declarationToResolve.lazyResolveToPhase(currentPhase)
                val firFile = firResolveSession.getOrBuildFirFile(ktFile)
                resultBuilder.append("\n${currentPhase.name}:\n")
                renderer.renderElementAsString(firFile)
@@ -76,7 +76,7 @@ abstract class AbstractFirLazyDeclarationResolveTest : AbstractLowLevelApiSingle
        resolveWithClearCaches(ktFile) { firResolveSession ->
            check(firResolveSession is LLFirSourceResolveSession)
            val firFile = firResolveSession.getOrBuildFirFile(ktFile)
-            firFile.ensureResolved(FirResolvePhase.BODY_RESOLVE)
+            firFile.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
            resultBuilder.append("\nFILE RAW TO BODY:\n")
            renderer.renderElementAsString(firFile)
        }
@@ -13,11 +13,8 @@ import org.jetbrains.kotlin.fir.AbstractFirAnalyzerFacade
 import org.jetbrains.kotlin.fir.backend.Fir2IrExtensions
 import org.jetbrains.kotlin.fir.backend.Fir2IrResult
 import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.transformers.FirSealedClassInheritorsProcessor
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.model.TestFile

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.resolve.transformers.FirSealedClassInheritorsProcessor
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.services.PreAnalysisHandler
@@ -58,7 +58,7 @@ class SealedClassesInheritorsCaclulatorPreAnalysisHandler(
        firFiles: List<FirFile>,
        tmpFirResolveSession: LLFirResolveSession
    ): Map<ClassId, List<ClassId>> {
-        firFiles.forEach { it.ensureResolved(FirResolvePhase.TYPES) }
+        firFiles.forEach { it.lazyResolveToPhase(FirResolvePhase.TYPES) }
        val inheritorsCollector = FirSealedClassInheritorsProcessor.InheritorsCollector(tmpFirResolveSession.useSiteFirSession)
        val sealedClassInheritorsMap = mutableMapOf<FirRegularClass, MutableList<ClassId>>()
        firFiles.forEach { it.accept(inheritorsCollector, sealedClassInheritorsMap) }
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.resolve.toFirRegularClassSymbol
 import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenFunctions
 import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenProperties
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.classId
@@ -63,7 +63,7 @@ object FirJvmOverridesBackwardCompatibilityHelper : FirOverridesBackwardCompatib
        visitedSymbols += symbol

        val originalMemberSymbol = symbol.originalOrSelf()
-        originalMemberSymbol.ensureResolved(FirResolvePhase.BODY_RESOLVE)
+        originalMemberSymbol.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
        @OptIn(SymbolInternals::class)
        val originalMember = originalMemberSymbol.fir
        if (originalMember.annotations.any { it.annotationTypeRef.coneTypeSafe<ConeClassLikeType>()?.classId == platformDependentAnnotation }) {
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.resolved
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.*
@@ -50,7 +50,7 @@ fun FirAnnotation.getAllowedAnnotationTargets(session: FirSession): Set<KotlinTa
    if (annotationTypeRef is FirErrorTypeRef) return KotlinTarget.values().toSet()
    val annotationClassSymbol = (this.annotationTypeRef.coneType as? ConeClassLikeType)
        ?.fullyExpandedType(session)?.lookupTag?.toSymbol(session) ?: return defaultAnnotationTargets
-    annotationClassSymbol.ensureResolved(FirResolvePhase.BODY_RESOLVE)
+    annotationClassSymbol.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
    return annotationClassSymbol.getAllowedAnnotationTargets()
 }

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.languageVersionSettings
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
@@ -75,7 +75,7 @@ private fun FirDeclaration.getOwnSinceKotlinVersion(session: FirSession): FirSin
    }

    fun FirClassLikeSymbol<*>.consider() {
-        ensureResolved(FirResolvePhase.BODY_RESOLVE)
+        lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
        @OptIn(SymbolInternals::class)
        this.fir.consider()
    }
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeAmbiguityError
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs

 object FirCommonConstructorDelegationIssuesChecker : FirRegularClassChecker() {
@@ -95,7 +95,7 @@ object FirCommonConstructorDelegationIssuesChecker : FirRegularClassChecker() {
    }

    private fun FirConstructor.getDelegated(): FirConstructor? {
-        this.symbol.ensureResolved(FirResolvePhase.BODY_RESOLVE)
+        this.symbol.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
        val delegatedConstructorSymbol = delegatedConstructor
            ?.calleeReference.safeAs<FirResolvedNamedReference>()
            ?.resolvedSymbol
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirPackageMemberScope
 import org.jetbrains.kotlin.fir.scopes.impl.PACKAGE_MEMBER
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
 import org.jetbrains.kotlin.fir.util.ListMultimap
@@ -83,7 +83,7 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
            conflictingFile: FirFile?,
            session: FirSession
        ) {
-            conflictingSymbol.ensureResolved(FirResolvePhase.STATUS)
+            conflictingSymbol.lazyResolveToPhase(FirResolvePhase.STATUS)
            @OptIn(SymbolInternals::class)
            val conflicting = conflictingSymbol.fir
            if (declaration.moduleData != conflicting.moduleData) return
@@ -130,7 +130,7 @@ object FirConflictsChecker : FirBasicDeclarationChecker() {
                            )
                        }
                        packageMemberScope.processClassifiersByNameWithSubstitution(declarationName) { symbol, _ ->
-                            symbol.ensureResolved(FirResolvePhase.STATUS)
+                            symbol.lazyResolveToPhase(FirResolvePhase.STATUS)
                            @OptIn(SymbolInternals::class)
                            val classWithSameName = symbol.fir as? FirRegularClass
                            classWithSameName?.onConstructors { constructor ->
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeInapplicableCandidateErr
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError
 import org.jetbrains.kotlin.fir.resolvedSymbol
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.types.*
@@ -186,7 +186,7 @@ object FirDestructuringDeclarationChecker : FirPropertyChecker() {
    private val FirQualifiedAccessExpression.resolvedVariable: FirVariable?
        get() {
            val symbol = calleeReference.resolvedSymbol as? FirVariableSymbol<*> ?: return null
-            symbol.ensureResolved(FirResolvePhase.BODY_RESOLVE)
+            symbol.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
            @OptIn(SymbolInternals::class)
            return symbol.fir
        }
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenFunctions
 import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenProperties
 import org.jetbrains.kotlin.fir.scopes.impl.toConeType
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.visibilityChecker
@@ -160,7 +160,7 @@ object FirOverrideChecker : FirClassChecker() {
        val containingDeclarations = context.containingDeclarations + containingClass
        val visibilityChecker = context.session.visibilityChecker
        val hasVisibleBase = overriddenSymbols.any {
-            it.ensureResolved(FirResolvePhase.STATUS)
+            it.lazyResolveToPhase(FirResolvePhase.STATUS)
            @OptIn(SymbolInternals::class)
            val fir = it.fir
            visibilityChecker.isVisible(
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.resolvedSymbol
 import org.jetbrains.kotlin.fir.scopes.impl.toConeType
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.lexer.KtTokens.QUEST
@@ -75,7 +75,7 @@ object FirClassLiteralChecker : FirGetClassCallChecker() {
        // TODO: differentiate RESERVED_SYNTAX_IN_CALLABLE_REFERENCE_LHS
        if (argument.typeArguments.isNotEmpty() && !argument.typeRef.coneType.isAllowedInClassLiteral(context)) {
            val symbol = argument.symbol
-            symbol?.ensureResolved(FirResolvePhase.TYPES)
+            symbol?.lazyResolveToPhase(FirResolvePhase.TYPES)
            @OptIn(SymbolInternals::class)
            val typeParameters = (symbol?.fir as? FirTypeParameterRefsOwner)?.typeParameters
            // Among type parameter references, only count actual type parameter while discarding [FirOuterClassTypeParameterRef]
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.fir.scopes.processDirectlyOverriddenFunctions
 import org.jetbrains.kotlin.fir.scopes.processDirectlyOverriddenProperties
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
@@ -69,13 +69,13 @@ object FirOptInUsageBaseChecker {

    // Note: receiver is an OptIn marker class and parameter is an annotated member owner class / self class name
    fun FirRegularClassSymbol.loadExperimentalityForMarkerAnnotation(annotatedOwnerClassName: String? = null): Experimentality? {
-        ensureResolved(FirResolvePhase.BODY_RESOLVE)
+        lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
        @OptIn(SymbolInternals::class)
        return fir.loadExperimentalityForMarkerAnnotation(annotatedOwnerClassName)
    }

    fun FirBasedSymbol<*>.loadExperimentalitiesFromAnnotationTo(session: FirSession, result: MutableCollection<Experimentality>) {
-        ensureResolved(FirResolvePhase.STATUS)
+        lazyResolveToPhase(FirResolvePhase.STATUS)
        @OptIn(SymbolInternals::class)
        fir.loadExperimentalitiesFromAnnotationTo(session, result)
    }
@@ -133,7 +133,7 @@ object FirOptInUsageBaseChecker {
        fromSetter: Boolean,
        dispatchReceiverType: ConeKotlinType?,
    ): Set<Experimentality> {
-        ensureResolved(FirResolvePhase.STATUS)
+        lazyResolveToPhase(FirResolvePhase.STATUS)
        val fir = this.fir
        if (!visited.add(fir)) return emptySet()
        val result = knownExperimentalities ?: SmartSet.create()
@@ -141,7 +141,7 @@ object FirOptInUsageBaseChecker {
        if (fir is FirCallableDeclaration) {
            val parentClassSymbol = fir.containingClass()?.toSymbol(session) as? FirRegularClassSymbol
            if (fir.isSubstitutionOrIntersectionOverride) {
-                parentClassSymbol?.ensureResolved(FirResolvePhase.STATUS)
+                parentClassSymbol?.lazyResolveToPhase(FirResolvePhase.STATUS)
                val parentClassScope = parentClassSymbol?.unsubstitutedScope(context)
                if (this is FirNamedFunctionSymbol) {
                    parentClassScope?.processDirectlyOverriddenFunctions(this) {
@@ -188,7 +188,7 @@ object FirOptInUsageBaseChecker {
            val accessibility = fir.checkSinceKotlinVersionAccessibility(context)
            if (accessibility is FirSinceKotlinAccessibility.NotAccessibleButWasExperimental) {
                accessibility.markerClasses.forEach {
-                    it.ensureResolved(FirResolvePhase.STATUS)
+                    it.lazyResolveToPhase(FirResolvePhase.STATUS)
                    result.addIfNotNull(it.fir.loadExperimentalityForMarkerAnnotation())
                }
            }
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.isEnumClass
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.resolvedSymbol
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirEnumEntrySymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
@@ -221,7 +221,7 @@ object FirUninitializedEnumChecker : FirQualifiedAccessExpressionChecker() {

    private val FirPropertySymbol.lazyDelegation: FirAnonymousFunction?
        get() {
-            ensureResolved(FirResolvePhase.BODY_RESOLVE)
+            lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
            @OptIn(SymbolInternals::class)
            val property = this.fir
            if (property.delegate == null || property.delegate !is FirFunctionCall) return null
@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.fir.resolved
 import org.jetbrains.kotlin.fir.resolvedSymbol
 import org.jetbrains.kotlin.fir.types.isFunctionalType
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.fir.types.coneType
@@ -75,7 +75,7 @@ object UnusedChecker : FirControlFlowChecker() {
            for (dataPerLabel in dataPerNode.values) {
                val data = dataPerLabel[variableSymbol] ?: continue

-                variableSymbol.ensureResolved(FirResolvePhase.BODY_RESOLVE)
+                variableSymbol.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
                @OptIn(SymbolInternals::class)
                val variable = variableSymbol.fir
                val variableSource = variable.source.takeIf { it?.elementType != KtNodeTypes.DESTRUCTURING_DECLARATION }
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.declarations.getAnnotationByClassId
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -44,7 +44,7 @@ object FirOptInUsageTypeRefChecker : FirTypeRefChecker() {
        }

        val symbol = coneType.lookupTag.toSymbol(context.session) ?: return
-        symbol.ensureResolved(FirResolvePhase.STATUS)
+        symbol.lazyResolveToPhase(FirResolvePhase.STATUS)
        val classId = symbol.classId
        val lastAnnotationCall = context.qualifiedAccessOrAnnotationCalls.lastOrNull() as? FirAnnotation
        if (lastAnnotationCall == null || lastAnnotationCall.annotationTypeRef !== typeRef) {
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.fir.resolve.calls.jvm.JvmCallConflictResolverFactory
 import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirQualifierResolverImpl
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirTypeResolverImpl
-import org.jetbrains.kotlin.fir.resolve.transformers.FirPhaseCheckingPhaseManager
+import org.jetbrains.kotlin.fir.resolve.transformers.FirCompilerLazyDeclarationResolver
 import org.jetbrains.kotlin.fir.resolve.transformers.plugin.GeneratedClassIndex
 import org.jetbrains.kotlin.fir.scopes.FirOverrideService
 import org.jetbrains.kotlin.fir.scopes.FirPlatformClassMapper
@@ -37,7 +37,7 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirDeclaredMemberScopeProvider
 import org.jetbrains.kotlin.fir.scopes.impl.FirDynamicMembersStorage
 import org.jetbrains.kotlin.fir.scopes.impl.FirIntersectionOverrideStorage
 import org.jetbrains.kotlin.fir.scopes.impl.FirSubstitutionOverrideStorage
-import org.jetbrains.kotlin.fir.symbols.FirPhaseManager
+import org.jetbrains.kotlin.fir.symbols.FirLazyDeclarationResolver
 import org.jetbrains.kotlin.fir.types.FirCorrespondingSupertypesCache
 import org.jetbrains.kotlin.fir.types.TypeComponents
 import org.jetbrains.kotlin.incremental.components.EnumWhenTracker
@@ -70,7 +70,7 @@ fun FirSession.registerCommonComponents(languageVersionSettings: LanguageVersion
 fun FirSession.registerCliCompilerOnlyComponents() {
    register(FirCachesFactory::class, FirThreadUnsafeCachesFactory)
    register(SealedClassInheritorsProvider::class, SealedClassInheritorsProviderImpl)
-    register(FirPhaseManager::class, FirPhaseCheckingPhaseManager)
+    register(FirLazyDeclarationResolver::class, FirCompilerLazyDeclarationResolver)

    register(FirRegisteredPluginAnnotations::class, FirRegisteredPluginAnnotationsImpl(this))
    register(FirPredicateBasedProvider::class, FirPredicateBasedProviderImpl(this))
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.impl.FirAbstractOverrideChecker
 import org.jetbrains.kotlin.fir.scopes.jvm.computeJvmDescriptorRepresentation
 import org.jetbrains.kotlin.fir.scopes.processOverriddenFunctions
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.name.StandardClassIds

@@ -205,8 +205,8 @@ class JavaOverrideChecker internal constructor(
        overrideCandidate: FirCallableDeclaration,
        baseDeclaration: FirCallableDeclaration
    ): ConeSubstitutor {
-        overrideCandidate.ensureResolved(FirResolvePhase.TYPES)
-        baseDeclaration.ensureResolved(FirResolvePhase.TYPES)
+        overrideCandidate.lazyResolveToPhase(FirResolvePhase.TYPES)
+        baseDeclaration.lazyResolveToPhase(FirResolvePhase.TYPES)

        if (!overrideCandidate.isTypeParameterDependent() && !baseDeclaration.isTypeParameterDependent()) {
            return ConeSubstitutor.Empty
@@ -220,8 +220,8 @@ class JavaOverrideChecker internal constructor(
    override fun isOverriddenFunction(overrideCandidate: FirSimpleFunction, baseDeclaration: FirSimpleFunction): Boolean {
        if (overrideCandidate.isStatic != baseDeclaration.isStatic) return false

-        overrideCandidate.ensureResolved(FirResolvePhase.TYPES)
-        baseDeclaration.ensureResolved(FirResolvePhase.TYPES)
+        overrideCandidate.lazyResolveToPhase(FirResolvePhase.TYPES)
+        baseDeclaration.lazyResolveToPhase(FirResolvePhase.TYPES)

        // NB: overrideCandidate is from Java and has no receiver
        val receiverTypeRef = baseDeclaration.receiverTypeRef
@@ -244,8 +244,8 @@ class JavaOverrideChecker internal constructor(
    override fun isOverriddenProperty(overrideCandidate: FirCallableDeclaration, baseDeclaration: FirProperty): Boolean {
        if (baseDeclaration.modality == Modality.FINAL) return false

-        overrideCandidate.ensureResolved(FirResolvePhase.TYPES)
-        baseDeclaration.ensureResolved(FirResolvePhase.TYPES)
+        overrideCandidate.lazyResolveToPhase(FirResolvePhase.TYPES)
+        baseDeclaration.lazyResolveToPhase(FirResolvePhase.TYPES)

        val receiverTypeRef = baseDeclaration.receiverTypeRef
        return when (overrideCandidate) {
@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.isInline
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.substitution.createTypeSubstitutorByTypeConstructor
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.name.Name
@@ -32,7 +32,7 @@ internal fun ConeKotlinType.unsubstitutedUnderlyingTypeForInlineClass(session: F
        ?.lookupTag
        ?.toSymbol(session) as? FirRegularClassSymbol
        ?: return null
-    symbol.ensureResolved(FirResolvePhase.STATUS)
+    symbol.lazyResolveToPhase(FirResolvePhase.STATUS)
    return symbol.fir.inlineClassRepresentation?.underlyingType
 }

@@ -63,9 +63,9 @@ private fun ConeSimpleKotlinType.valueClassRepresentationTypeMarkersList(session
    val symbol = this.toSymbol(session) as? FirRegularClassSymbol ?: return null
    if (!symbol.fir.isInline) return null
    symbol.fir.valueClassRepresentation?.let { return it.underlyingPropertyNamesToTypes }
-    symbol.ensureResolved(FirResolvePhase.TYPES)
+    symbol.lazyResolveToPhase(FirResolvePhase.TYPES)
    val constructorSymbol = symbol.fir.primaryConstructorIfAny(session) ?: return null
    return constructorSymbol.valueParameterSymbols
-        .onEach { it.ensureResolved(FirResolvePhase.TYPES) }
+        .onEach { it.lazyResolveToPhase(FirResolvePhase.TYPES) }
        .map { it.name to it.resolvedReturnType as ConeSimpleKotlinType }
 }
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.scopes.FirUnstableSmartcastTypeScope
 import org.jetbrains.kotlin.fir.scopes.impl.*
 import org.jetbrains.kotlin.fir.scopes.scopeForClass
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
@@ -61,7 +61,7 @@ private fun ConeKotlinType.scope(useSiteSession: FirSession, scopeSession: Scope
            val fullyExpandedType = fullyExpandedType(useSiteSession)
            val fir = fullyExpandedType.lookupTag.toSymbol(useSiteSession)?.fir as? FirClass ?: return null

-            fir.symbol.ensureResolved(requiredPhase)
+            fir.symbol.lazyResolveToPhase(requiredPhase)

            val substitution = createSubstitution(fir.typeParameters, fullyExpandedType, useSiteSession)

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.types.model.CaptureStatus
@@ -34,13 +34,13 @@ abstract class SupertypeSupplier {
        override fun forClass(firClass: FirClass, useSiteSession: FirSession): List<ConeClassLikeType> {
            if (!firClass.isLocal) {
                // for local classes the phase may not be updated till that moment
-                firClass.ensureResolved(FirResolvePhase.SUPER_TYPES)
+                firClass.lazyResolveToPhase(FirResolvePhase.SUPER_TYPES)
            }
            return firClass.superConeTypes
        }

        override fun expansionForTypeAlias(typeAlias: FirTypeAlias, useSiteSession: FirSession): ConeClassLikeType? {
-            typeAlias.ensureResolved(FirResolvePhase.SUPER_TYPES)
+            typeAlias.lazyResolveToPhase(FirResolvePhase.SUPER_TYPES)
            return typeAlias.expandedConeType
        }
    }
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.declarations.FirTypeAlias
 import org.jetbrains.kotlin.fir.declarations.utils.expandedConeType
 import org.jetbrains.kotlin.fir.resolve.substitution.AbstractConeSubstitutor
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.util.component2
 fun ConeClassLikeType.fullyExpandedType(
    useSiteSession: FirSession,
    expandedConeType: (FirTypeAlias) -> ConeClassLikeType? = { alias ->
-        alias.ensureResolved(FirResolvePhase.SUPER_TYPES)
+        alias.lazyResolveToPhase(FirResolvePhase.SUPER_TYPES)
        alias.expandedConeType
    },
 ): ConeClassLikeType {
@@ -69,7 +69,7 @@ private fun ConeClassLikeType.fullyExpandedTypeNoCache(
 fun ConeClassLikeType.directExpansionType(
    useSiteSession: FirSession,
    expandedConeType: (FirTypeAlias) -> ConeClassLikeType? = { alias ->
-        alias.ensureResolved(FirResolvePhase.SUPER_TYPES)
+        alias.lazyResolveToPhase(FirResolvePhase.SUPER_TYPES)
        alias.expandedConeType
    },
 ): ConeClassLikeType? {
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.toSymbol
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -21,8 +21,8 @@ fun ConeKotlinType.ensureResolvedTypeDeclaration(
 ) {
    if (this !is ConeClassLikeType) return

-    lookupTag.toSymbol(useSiteSession)?.ensureResolved(requiredPhase)
-    fullyExpandedType(useSiteSession).lookupTag.toSymbol(useSiteSession)?.ensureResolved(requiredPhase)
+    lookupTag.toSymbol(useSiteSession)?.lazyResolveToPhase(requiredPhase)
+    fullyExpandedType(useSiteSession).lookupTag.toSymbol(useSiteSession)?.lazyResolveToPhase(requiredPhase)
 }

 fun FirTypeRef.ensureResolvedTypeDeclaration(
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.scopes.FakeOverrideSubstitution
 import org.jetbrains.kotlin.fir.scopes.FirTypeScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.name.Name
@@ -279,7 +279,7 @@ class FirClassSubstitutionScope(
    )

    private fun createSubstitutedData(member: FirCallableDeclaration, symbolForOverride: FirBasedSymbol<*>): SubstitutedData {
-        member.ensureResolved(FirResolvePhase.TYPES)
+        member.lazyResolveToPhase(FirResolvePhase.TYPES)
        val (newTypeParameters, substitutor) = FirFakeOverrideGenerator.createNewTypeParametersAndSubstitutor(
            session,
            member as FirTypeParameterRefsOwner,
@@ -293,7 +293,7 @@ class FirClassSubstitutionScope(

        val newDispatchReceiverType = dispatchReceiverTypeForSubstitutedMembers.substitute(substitutor)

-        member.ensureResolved(FirResolvePhase.STATUS)
+        member.lazyResolveToPhase(FirResolvePhase.STATUS)
        val returnType = member.returnTypeRef.coneTypeSafe<ConeKotlinType>()
        val fakeOverrideSubstitution = runIf(returnType == null) { FakeOverrideSubstitution(substitutor, member.symbol) }
        val newReturnType = returnType?.substitute(substitutor)
@@ -312,7 +312,7 @@ class FirClassSubstitutionScope(
        val member = original.fir
        if (skipPrivateMembers && member.visibility == Visibilities.Private) return original

-        member.symbol.ensureResolved(FirResolvePhase.STATUS)
+        member.symbol.lazyResolveToPhase(FirResolvePhase.STATUS)
        val returnType = member.returnTypeRef.coneTypeSafe<ConeKotlinType>()
        // TODO: do we have fields with implicit type?
        val newReturnType = returnType?.substitute() ?: return original
@@ -325,7 +325,7 @@ class FirClassSubstitutionScope(
        val member = original.fir as FirSyntheticProperty
        if (skipPrivateMembers && member.visibility == Visibilities.Private) return original

-        member.symbol.ensureResolved(FirResolvePhase.STATUS)
+        member.symbol.lazyResolveToPhase(FirResolvePhase.STATUS)
        val returnType = member.returnTypeRef.coneTypeSafe<ConeKotlinType>()
        val fakeOverrideSubstitution = runIf(returnType == null) { FakeOverrideSubstitution(substitutor, original) }
        val newReturnType = returnType?.substitute()
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.resolve.scope
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.scopes.*
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.ConeFlexibleType
@@ -49,7 +49,7 @@ class FirDelegatedMemberScope(
    }

    private fun buildScope(delegateField: FirField): FirTypeScope? {
-        delegateField.ensureResolved(FirResolvePhase.TYPES)
+        delegateField.lazyResolveToPhase(FirResolvePhase.TYPES)
        return delegateField.returnTypeRef.coneType.scope(session, scopeSession, FakeOverrideTypeCalculator.DoNothing)
    }

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.transformers.ensureResolvedTypeDeclaration
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.types.AbstractTypeChecker
 import org.jetbrains.kotlin.types.model.KotlinTypeMarker
@@ -102,8 +102,8 @@ class FirStandardOverrideChecker(private val session: FirSession) : FirAbstractO
        overrideCandidate: FirCallableDeclaration,
        baseDeclaration: FirCallableDeclaration
    ): ConeSubstitutor? {
-        overrideCandidate.ensureResolved(FirResolvePhase.TYPES)
-        baseDeclaration.ensureResolved(FirResolvePhase.TYPES)
+        overrideCandidate.lazyResolveToPhase(FirResolvePhase.TYPES)
+        baseDeclaration.lazyResolveToPhase(FirResolvePhase.TYPES)
        val substitutor = buildSubstitutorForOverridesCheck(overrideCandidate, baseDeclaration, session) ?: return null
        if (
            overrideCandidate.typeParameters.isNotEmpty() &&
@@ -128,8 +128,8 @@ class FirStandardOverrideChecker(private val session: FirSession) : FirAbstractO

        val substitutor = buildTypeParametersSubstitutorIfCompatible(overrideCandidate, baseDeclaration) ?: return false

-        overrideCandidate.ensureResolved(FirResolvePhase.TYPES)
-        baseDeclaration.ensureResolved(FirResolvePhase.TYPES)
+        overrideCandidate.lazyResolveToPhase(FirResolvePhase.TYPES)
+        baseDeclaration.lazyResolveToPhase(FirResolvePhase.TYPES)
        if (!isEqualReceiverTypes(overrideCandidate.receiverTypeRef, baseDeclaration.receiverTypeRef, substitutor)) return false

        return overrideCandidate.valueParameters.zip(baseDeclaration.valueParameters).all { (memberParam, selfParam) ->
@@ -145,8 +145,8 @@ class FirStandardOverrideChecker(private val session: FirSession) : FirAbstractO

        if (overrideCandidate !is FirProperty) return false
        val substitutor = buildTypeParametersSubstitutorIfCompatible(overrideCandidate, baseDeclaration) ?: return false
-        overrideCandidate.ensureResolved(FirResolvePhase.TYPES)
-        baseDeclaration.ensureResolved(FirResolvePhase.TYPES)
+        overrideCandidate.lazyResolveToPhase(FirResolvePhase.TYPES)
+        baseDeclaration.lazyResolveToPhase(FirResolvePhase.TYPES)
        return isEqualReceiverTypes(overrideCandidate.receiverTypeRef, baseDeclaration.receiverTypeRef, substitutor)
    }
 }
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.fir.resolve.substitution.substitutorByMap
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.name.*
 import org.jetbrains.kotlin.types.TypeCheckerState
@@ -286,7 +286,7 @@ interface ConeTypeContext : TypeSystemContext, TypeSystemOptimizationContext, Ty
            is ConeTypeVariableTypeConstructor -> emptyList()
            is ConeTypeParameterLookupTag -> symbol.resolvedBounds.map { it.coneType }
            is ConeClassLikeLookupTag -> {
-                when (val symbol = toClassLikeSymbol().also { it?.ensureResolved(FirResolvePhase.TYPES) }) {
+                when (val symbol = toClassLikeSymbol().also { it?.lazyResolveToPhase(FirResolvePhase.TYPES) }) {
                    is FirClassSymbol<*> -> symbol.fir.superConeTypes
                    is FirTypeAliasSymbol -> listOfNotNull(symbol.fir.expandedConeType)
                    else -> listOf(session.builtinTypes.anyType.type)
@@ -40,7 +40,7 @@ import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData
 import org.jetbrains.kotlin.fir.scopes.impl.importedFromObjectData
 import org.jetbrains.kotlin.fir.scopes.processOverriddenFunctions
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
@@ -183,7 +183,7 @@ fun BodyResolveComponents.typeForQualifier(resolvedQualifier: FirResolvedQualifi
    val classSymbol = resolvedQualifier.symbol
    val resultType = resolvedQualifier.resultType
    if (classSymbol != null) {
-        classSymbol.ensureResolved(FirResolvePhase.TYPES)
+        classSymbol.lazyResolveToPhase(FirResolvePhase.TYPES)
        val declaration = classSymbol.fir
        if (declaration !is FirTypeAlias || resolvedQualifier.typeArguments.isEmpty()) {
            typeForQualifierByDeclaration(declaration, resultType, session)?.let { return it }
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.impl.FirFakeOverrideGenerator
 import org.jetbrains.kotlin.fir.scopes.processClassifiersByName
 import org.jetbrains.kotlin.fir.scopes.scopeForClass
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.visibilityChecker
@@ -242,7 +242,7 @@ private fun processConstructors(
        if (matchedSymbol != null) {
            val scope = when (matchedSymbol) {
                is FirTypeAliasSymbol -> {
-                    matchedSymbol.ensureResolved(FirResolvePhase.TYPES)
+                    matchedSymbol.lazyResolveToPhase(FirResolvePhase.TYPES)
                    val type = matchedSymbol.fir.expandedTypeRef.coneTypeUnsafe<ConeClassLikeType>().fullyExpandedType(session)
                    val basicScope = type.scope(session, bodyResolveComponents.scopeSession, FakeOverrideTypeCalculator.DoNothing)

@@ -15,7 +15,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.scopes.impl.toConeType
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.name.StandardClassIds
 import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemOperation
@@ -24,7 +24,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)
+        candidate.symbol.lazyResolveToPhase(FirResolvePhase.STATUS)
        if (declaration !is FirTypeParameterRefsOwner || declaration.typeParameters.isEmpty()) {
            candidate.substitutor = ConeSubstitutor.Empty
            candidate.freshVariables = emptyList()
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.fir.scopes.FirUnstableSmartcastTypeScope
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.processOverriddenFunctions
 import org.jetbrains.kotlin.fir.symbols.SyntheticSymbol
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.visibilityChecker
@@ -432,7 +432,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)
+        candidate.symbol.lazyResolveToPhase(FirResolvePhase.STATUS)
        val argumentMapping =
            candidate.argumentMapping ?: error("Argument should be already mapped while checking arguments!")
        for (argument in callInfo.arguments) {
@@ -7,9 +7,12 @@ package org.jetbrains.kotlin.fir.resolve.transformers

 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.FirPhaseManager
+import org.jetbrains.kotlin.fir.symbols.FirLazyDeclarationResolver

-object FirPhaseCheckingPhaseManager : FirPhaseManager() {
-    override fun ensureResolved(symbol: FirBasedSymbol<*>, requiredPhase: FirResolvePhase) {
+/**
+ * Compiler is non-lazy, so it does nothing.
+ */
+object FirCompilerLazyDeclarationResolver : FirLazyDeclarationResolver() {
+    override fun lazyResolveToPhase(symbol: FirBasedSymbol<*>, toPhase: FirResolvePhase) {
    }
 }
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.getSymbolByLookupTag
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
@@ -73,7 +73,7 @@ class FirSealedClassInheritorsProcessor(
            return when (classLikeSymbol) {
                is FirRegularClassSymbol -> classLikeSymbol.fir
                is FirTypeAliasSymbol -> {
-                    classLikeSymbol.ensureResolved(FirResolvePhase.SUPER_TYPES)
+                    classLikeSymbol.lazyResolveToPhase(FirResolvePhase.SUPER_TYPES)
                    extractClassFromTypeRef(symbolProvider, classLikeSymbol.fir.expandedTypeRef)
                }
                else -> null
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.LocalClassesNavigationInfo
 import org.jetbrains.kotlin.fir.scopes.FirCompositeScope
 import org.jetbrains.kotlin.fir.scopes.FirScope
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol
@@ -167,7 +167,7 @@ open class FirDesignatedStatusResolveTransformer(
        data: FirResolvedDeclarationStatus?
    ): FirStatement {
        if (shouldSkipClass(regularClass)) return regularClass
-        regularClass.symbol.ensureResolved(FirResolvePhase.TYPES)
+        regularClass.symbol.lazyResolveToPhase(FirResolvePhase.TYPES)
        val classLocated = this.classLocated
        /*
         * In designated status resolve we should resolve status only of target class and it's members
@@ -383,7 +383,7 @@ abstract class AbstractFirStatusResolveTransformer(

    private fun forceResolveStatusOfCorrespondingClass(typeRef: FirTypeRef) {
        val superClassSymbol = typeRef.coneType.toSymbol(session)
-        superClassSymbol?.ensureResolved(FirResolvePhase.SUPER_TYPES)
+        superClassSymbol?.lazyResolveToPhase(FirResolvePhase.SUPER_TYPES)
        when (superClassSymbol) {
            is FirRegularClassSymbol -> forceResolveStatusesOfClass(superClassSymbol.fir)
            is FirTypeAliasSymbol -> forceResolveStatusOfCorrespondingClass(superClassSymbol.fir.expandedTypeRef)
@@ -487,12 +487,12 @@ abstract class AbstractFirStatusResolveTransformer(
        val overridden = statusResolver.getOverriddenProperties(property, containingClass)

        val overriddenProperties = overridden.map {
-            it.ensureResolved(FirResolvePhase.STATUS)
+            it.lazyResolveToPhase(FirResolvePhase.STATUS)
            it.status as FirResolvedDeclarationStatus
        }

        val overriddenSetters = overridden.mapNotNull {
-            it.setter?.ensureResolved(FirResolvePhase.STATUS)
+            it.setter?.lazyResolveToPhase(FirResolvePhase.STATUS)
            it.setter?.status as? FirResolvedDeclarationStatus
        }

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.toEffectiveVisibility
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.name.StandardClassIds
@@ -108,7 +108,7 @@ class FirStatusResolver(
    ): FirResolvedDeclarationStatus {
        val statuses = overriddenStatuses ?: getOverriddenProperties(property, containingClass)
            .map {
-                it.ensureResolved(FirResolvePhase.STATUS)
+                it.lazyResolveToPhase(FirResolvePhase.STATUS)
                it.status as FirResolvedDeclarationStatus
            }

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.TransformImplicitType
 import org.jetbrains.kotlin.fir.resolve.transformers.contracts.runContractResolveForLocalClass
 import org.jetbrains.kotlin.fir.scopes.FakeOverrideTypeCalculator
 import org.jetbrains.kotlin.fir.scopes.fakeOverrideSubstitution
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirSyntheticPropertySymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
@@ -271,7 +271,7 @@ private class ReturnTypeCalculatorWithJump(
        }

        if (canHaveContracts) {
-            declaration.ensureResolved(FirResolvePhase.CONTRACTS)
+            declaration.lazyResolveToPhase(FirResolvePhase.CONTRACTS)
        }
    }

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.packageFqName
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.scopeSessionKey
 import org.jetbrains.kotlin.fir.scopes.impl.*
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.name.FqName

 private val ALL_IMPORTS = scopeSessionKey<FirFile, ListStorageFirScope>()
@@ -39,7 +39,7 @@ private fun doCreateImportingScopes(
    session: FirSession,
    scopeSession: ScopeSession
 ): List<FirScope> {
-    file.ensureResolved(FirResolvePhase.IMPORTS)
+    file.lazyResolveToPhase(FirResolvePhase.IMPORTS)
    val excludedImportNames =
        file.imports.filter { it.aliasName != null }.mapNotNullTo(hashSetOf()) { it.importedFqName }.ifEmpty { emptySet() }
    return listOf(
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationDataKey
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationDataRegistry
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol

 private object PublishedApiEffectiveVisibilityKey : FirDeclarationDataKey()
@@ -18,6 +18,6 @@ var FirDeclaration.publishedApiEffectiveVisibility: EffectiveVisibility? by FirD

 inline val FirCallableSymbol<*>.publishedApiEffectiveVisibility: EffectiveVisibility?
    get() {
-        ensureResolved(FirResolvePhase.STATUS)
+        lazyResolveToPhase(FirResolvePhase.STATUS)
        return fir.publishedApiEffectiveVisibility
    }
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.declarations
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.SymbolInternals
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.resolve.multiplatform.ExpectActualCompatibility
 import java.util.*

@@ -23,7 +23,7 @@ private var FirDeclaration.actualForExpectMap: WeakHashMap<FirSession, FirBasedS

 val FirBasedSymbol<*>.expectForActual: ExpectForActualData?
    get() {
-        ensureResolved(FirResolvePhase.EXPECT_ACTUAL_MATCHING)
+        lazyResolveToPhase(FirResolvePhase.EXPECT_ACTUAL_MATCHING)
        return fir.expectForActual
    }

@@ -46,7 +46,7 @@ fun FirDeclaration.getActualForExpect(useSiteSession: FirSession): FirBasedSymbo
 }

 fun FirBasedSymbol<*>.getActualForExpect(session: FirSession): FirBasedSymbol<*>? {
-    ensureResolved(FirResolvePhase.EXPECT_ACTUAL_MATCHING)
+    lazyResolveToPhase(FirResolvePhase.EXPECT_ACTUAL_MATCHING)
    return fir.getActualForExpect(session)
 }

@@ -44,19 +44,19 @@ abstract class FirBasedSymbol<E : FirDeclaration> {
            // NB: annotation argument mapping (w/ vararg) are built/replaced during call completion, hence BODY_RESOLVE.
            // TODO(KT-53371): optimize ARGUMENTS_OF_ANNOTATIONS to build annotation argument mapping too.
            // TODO(KT-53519): Even with BODY_RESOLVE, argument mapping for annotations on [FirValueParameter] is not properly built.
-            ensureResolved(FirResolvePhase.BODY_RESOLVE)
+            lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
            return fir.annotations
        }

    val resolvedAnnotationsWithClassIds: List<FirAnnotation>
        get() {
-            ensureResolved(FirResolvePhase.TYPES)
+            lazyResolveToPhase(FirResolvePhase.TYPES)
            return fir.annotations
        }

    val resolvedAnnotationClassIds: List<ClassId>
        get() {
-            ensureResolved(FirResolvePhase.TYPES)
+            lazyResolveToPhase(FirResolvePhase.TYPES)
            return fir.annotations.mapNotNull { (it.annotationTypeRef.coneType as? ConeClassLikeType)?.lookupTag?.classId }
        }
 }
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2010-2021 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.symbols
+
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSessionComponent
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+
+abstract class FirLazyDeclarationResolver : FirSessionComponent {
+    abstract fun lazyResolveToPhase(symbol: FirBasedSymbol<*>, toPhase: FirResolvePhase)
+}
+
+val FirSession.lazyDeclarationResolver: FirLazyDeclarationResolver by FirSession.sessionComponentAccessor()
+
+fun FirBasedSymbol<*>.lazyResolveToPhase(toPhase: FirResolvePhase) {
+    val session = fir.moduleData.session
+    val phaseManager = session.lazyDeclarationResolver
+    phaseManager.lazyResolveToPhase(this, toPhase)
+}
+
+fun FirDeclaration.lazyResolveToPhase(toPhase: FirResolvePhase) {
+    symbol.lazyResolveToPhase(toPhase)
+}
@@ -1,30 +0,0 @@
-/*
- * Copyright 2010-2021 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.symbols
-
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.FirSessionComponent
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-
-abstract class FirPhaseManager : FirSessionComponent {
-    abstract fun ensureResolved(
-        symbol: FirBasedSymbol<*>,
-        requiredPhase: FirResolvePhase = FirResolvePhase.DECLARATIONS
-    )
-}
-
-val FirSession.phaseManager: FirPhaseManager by FirSession.sessionComponentAccessor()
-
-fun FirBasedSymbol<*>.ensureResolved(requiredPhase: FirResolvePhase) {
-    val session = fir.moduleData.session
-    val phaseManager = session.phaseManager
-    phaseManager.ensureResolved(this, requiredPhase)
-}
-
-fun FirDeclaration.ensureResolved(requiredPhase: FirResolvePhase) {
-    symbol.ensureResolved(requiredPhase)
-}
@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.symbols.impl

 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.Name
@@ -33,13 +33,13 @@ abstract class FirCallableSymbol<D : FirCallableDeclaration> : FirBasedSymbol<D>

    val resolvedContextReceivers: List<FirContextReceiver>
        get() {
-            ensureResolved(FirResolvePhase.TYPES)
+            lazyResolveToPhase(FirResolvePhase.TYPES)
            return fir.contextReceivers
        }

    val resolvedStatus: FirResolvedDeclarationStatus
        get() {
-            ensureResolved(FirResolvePhase.STATUS)
+            lazyResolveToPhase(FirResolvePhase.STATUS)
            return fir.status as FirResolvedDeclarationStatus
        }

@@ -60,15 +60,15 @@ abstract class FirCallableSymbol<D : FirCallableDeclaration> : FirBasedSymbol<D>

    val deprecation: DeprecationsPerUseSite?
        get() {
-            ensureResolved(FirResolvePhase.STATUS)
+            lazyResolveToPhase(FirResolvePhase.STATUS)
            return fir.deprecation
        }

    private fun ensureType(typeRef: FirTypeRef?) {
        when (typeRef) {
            null, is FirResolvedTypeRef -> {}
-            is FirImplicitTypeRef -> ensureResolved(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
-            else -> ensureResolved(FirResolvePhase.TYPES)
+            is FirImplicitTypeRef -> lazyResolveToPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
+            else -> lazyResolveToPhase(FirResolvePhase.TYPES)
        }
    }

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.coneType
@@ -26,7 +26,7 @@ sealed class FirClassLikeSymbol<D : FirClassLikeDeclaration>(

    val deprecation: DeprecationsPerUseSite?
        get() {
-            ensureResolved(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS)
+            lazyResolveToPhase(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS)
            return fir.deprecation
        }

@@ -45,7 +45,7 @@ sealed class FirClassSymbol<C : FirClass>(classId: ClassId) : FirClassLikeSymbol

    val resolvedSuperTypeRefs: List<FirResolvedTypeRef>
        get() {
-            ensureResolved(FirResolvePhase.SUPER_TYPES)
+            lazyResolveToPhase(FirResolvePhase.SUPER_TYPES)
            @Suppress("UNCHECKED_CAST")
            return fir.superTypeRefs as List<FirResolvedTypeRef>
        }
@@ -68,7 +68,7 @@ sealed class FirClassSymbol<C : FirClass>(classId: ClassId) : FirClassLikeSymbol

    val resolvedStatus: FirResolvedDeclarationStatus
        get() {
-            ensureResolved(FirResolvePhase.STATUS)
+            lazyResolveToPhase(FirResolvePhase.STATUS)
            return fir.status as FirResolvedDeclarationStatus
        }
 }
@@ -79,7 +79,7 @@ class FirRegularClassSymbol(classId: ClassId) : FirClassSymbol<FirRegularClass>(

    val resolvedContextReceivers: List<FirContextReceiver>
        get() {
-            ensureResolved(FirResolvePhase.TYPES)
+            lazyResolveToPhase(FirResolvePhase.TYPES)
            return fir.contextReceivers
        }
 }
@@ -93,13 +93,13 @@ class FirTypeAliasSymbol(classId: ClassId) : FirClassLikeSymbol<FirTypeAlias>(cl

    val resolvedStatus: FirResolvedDeclarationStatus
        get() {
-            ensureResolved(FirResolvePhase.STATUS)
+            lazyResolveToPhase(FirResolvePhase.STATUS)
            return fir.status as FirResolvedDeclarationStatus
        }

    val resolvedExpandedTypeRef: FirResolvedTypeRef
        get() {
-            ensureResolved(FirResolvePhase.SUPER_TYPES)
+            lazyResolveToPhase(FirResolvePhase.SUPER_TYPES)
            return fir.expandedTypeRef as FirResolvedTypeRef
        }

@@ -10,9 +10,8 @@ import org.jetbrains.kotlin.fir.contracts.FirResolvedContractDescription
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
-import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolvedSymbol
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.name.*

 sealed class FirFunctionSymbol<D : FirFunction>(
@@ -23,7 +22,7 @@ sealed class FirFunctionSymbol<D : FirFunction>(

    val resolvedContractDescription: FirResolvedContractDescription?
        get() {
-            ensureResolved(FirResolvePhase.CONTRACTS)
+            lazyResolveToPhase(FirResolvePhase.CONTRACTS)
            return when (this) {
                is FirNamedFunctionSymbol -> fir.contractDescription
                is FirPropertyAccessorSymbol -> fir.contractDescription
@@ -33,7 +32,7 @@ sealed class FirFunctionSymbol<D : FirFunction>(

    val resolvedControlFlowGraphReference: FirControlFlowGraphReference?
        get() {
-            ensureResolved(FirResolvePhase.BODY_RESOLVE)
+            lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
            return fir.controlFlowGraphReference
        }
 }
@@ -70,7 +69,7 @@ class FirConstructorSymbol(
    val resolvedDelegatedConstructorCall: FirDelegatedConstructorCall?
        get() {
            if (fir.delegatedConstructor == null) return null
-            ensureResolved(FirResolvePhase.BODY_RESOLVE)
+            lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
            return fir.delegatedConstructor
        }

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.Variance
@@ -26,7 +26,7 @@ class FirTypeParameterSymbol : FirClassifierSymbol<FirTypeParameter>() {

    val resolvedBounds: List<FirResolvedTypeRef>
        get() {
-            ensureResolved(FirResolvePhase.TYPES)
+            lazyResolveToPhase(FirResolvePhase.TYPES)
            @Suppress("UNCHECKED_CAST")
            return fir.bounds as List<FirResolvedTypeRef>
        }
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.symbols.impl
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
-import org.jetbrains.kotlin.fir.symbols.ensureResolved
+import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase
 import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -44,7 +44,7 @@ open class FirPropertySymbol(

    val controlFlowGraphReference: FirControlFlowGraphReference?
        get() {
-            ensureResolved(FirResolvePhase.BODY_RESOLVE)
+            lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)
            return fir.controlFlowGraphReference
        }