From 0748f28efecb82f0d0cca3847dcf37ef3b960ee8 Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Tue, 9 Aug 2022 14:13:04 +0200 Subject: [PATCH] [FIR] rename ensureResolve -> lazyResolveToPhase as it better describes function semantics --- .../analysis/api/fir/KtSymbolByFirBuilder.kt | 6 ++-- .../KtFirCompletionCandidateChecker.kt | 4 +-- .../fir/components/KtFirImportOptimizer.kt | 4 +-- .../api/fir/components/KtFirScopeProvider.kt | 9 +++--- ...KtFirSymbolDeclarationOverridesProvider.kt | 9 +++--- .../KtFirSymbolDeclarationRendererProvider.kt | 8 ++--- .../api/fir/components/KtFirTypeProvider.kt | 4 +-- .../FirCompileTimeConstantEvaluator.kt | 4 +-- .../fir/symbols/KtFirKotlinPropertySymbol.kt | 4 +-- .../fir/symbols/KtFirOverrideInfoProvider.kt | 11 ++++--- .../api/fir/symbols/firSymbolUtils.kt | 4 +-- ...ger.kt => LLFirLazyDeclarationResolver.kt} | 8 ++--- ...solveTransformerForReturnTypeCalculator.kt | 4 +-- ...BasedTransformerForReturnTypeCalculator.kt | 6 ++-- .../structure/LLFirBuiltinsSessionFactory.kt | 6 ++-- .../structure/LLFirLibrarySessionFactory.kt | 6 ++-- .../LLFirNonUnderContentRootSessionFactory.kt | 6 ++-- .../api/fir/sessions/LLFirSessionFactory.kt | 8 ++--- .../AbstractFirLazyDeclarationResolveTest.kt | 6 ++-- .../based/LowLevelFirAnalyzerFacade.kt | 3 -- ...sInheritorsCaclulatorPreAnalysisHandler.kt | 4 +-- ...JvmOverridesBackwardCompatibilityHelper.kt | 4 +-- .../analysis/checkers/FirAnnotationHelpers.kt | 4 +-- .../checkers/FirSinceKotlinHelpers.kt | 4 +-- ...ommonConstructorDelegationIssuesChecker.kt | 4 +-- .../declaration/FirConflictsChecker.kt | 6 ++-- .../FirDestructuringDeclarationChecker.kt | 4 +-- .../declaration/FirOverrideChecker.kt | 4 +-- .../expression/FirClassLiteralChecker.kt | 4 +-- .../expression/FirOptInUsageBaseChecker.kt | 12 ++++---- .../expression/FirUninitializedEnumChecker.kt | 4 +-- .../checkers/extended/UnusedChecker.kt | 4 +-- .../type/FirOptInUsageTypeRefChecker.kt | 4 +-- .../fir/session/ComponentsContainers.kt | 6 ++-- .../fir/java/scopes/JavaOverrideChecker.kt | 14 ++++----- .../fir/declarations/ValueClassesUtils.kt | 8 ++--- .../kotlin/fir/resolve/ScopeUtils.kt | 4 +-- .../kotlin/fir/resolve/SupertypeUtils.kt | 6 ++-- .../kotlin/fir/resolve/TypeExpansionUtils.kt | 6 ++-- .../fir/resolve/transformers/PhaseUtils.kt | 6 ++-- .../scopes/impl/FirClassSubstitutionScope.kt | 10 +++---- .../scopes/impl/FirDelegatedMemberScope.kt | 4 +-- .../scopes/impl/FirStandardOverrideChecker.kt | 14 ++++----- .../kotlin/fir/types/ConeTypeContext.kt | 4 +-- .../kotlin/fir/resolve/ResolveUtils.kt | 4 +-- .../resolve/calls/ConstructorProcessing.kt | 4 +-- ...CreateFreshTypeVariableSubstitutorStage.kt | 4 +-- .../fir/resolve/calls/ResolutionStages.kt | 4 +-- ... => FirCompilerLazyDeclarationResolver.kt} | 9 ++++-- .../FirSealedClassInheritorsProcessor.kt | 4 +-- .../FirStatusResolveTransformer.kt | 10 +++---- .../resolve/transformers/FirStatusResolver.kt | 4 +-- .../body/resolve/FirImplicitBodyResolve.kt | 4 +-- .../kotlin/fir/scopes/ImportingScopes.kt | 4 +-- .../publishedApiEffectiveVisibility.kt | 4 +-- .../declarations/ExpectActualAttributes.kt | 6 ++-- .../kotlin/fir/symbols/FirBasedSymbol.kt | 6 ++-- .../fir/symbols/FirLazyDeclarationResolver.kt | 27 +++++++++++++++++ .../kotlin/fir/symbols/FirPhaseManager.kt | 30 ------------------- .../fir/symbols/impl/FirCallableSymbol.kt | 12 ++++---- .../fir/symbols/impl/FirClassLikeSymbol.kt | 14 ++++----- .../fir/symbols/impl/FirFunctionSymbol.kt | 9 +++--- .../symbols/impl/FirTypeParameterSymbol.kt | 4 +-- .../fir/symbols/impl/FirVariableSymbol.kt | 4 +-- 64 files changed, 210 insertions(+), 221 deletions(-) rename analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/{LLFirPhaseManager.kt => LLFirLazyDeclarationResolver.kt} (79%) rename compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/{FirPhaseCheckingPhaseManager.kt => FirCompilerLazyDeclarationResolver.kt} (57%) create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirLazyDeclarationResolver.kt delete mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirPhaseManager.kt diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtSymbolByFirBuilder.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtSymbolByFirBuilder.kt index 28d390a4919..710548d128f 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtSymbolByFirBuilder.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtSymbolByFirBuilder.kt @@ -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 { - 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 { - firSymbol.ensureResolved(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) + firSymbol.lazyResolveToPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) return KtVariableLikeSignature( buildPropertySymbol(firSymbol), typeBuilder.buildKtType(firSymbol.fir.returnTypeRef), diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompletionCandidateChecker.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompletionCandidateChecker.kt index 9c5349233b3..ea06325f600 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompletionCandidateChecker.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompletionCandidateChecker.kt @@ -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) } diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirImportOptimizer.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirImportOptimizer.kt index 7129fc8faa8..1ca5f07a969 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirImportOptimizer.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirImportOptimizer.kt @@ -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 diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirScopeProvider.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirScopeProvider.kt index a282cf973c8..5d229076ae4 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirScopeProvider.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirScopeProvider.kt @@ -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 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) diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolDeclarationOverridesProvider.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolDeclarationOverridesProvider.kt index 0405602c392..7c447fa23b8 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolDeclarationOverridesProvider.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolDeclarationOverridesProvider.kt @@ -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 diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolDeclarationRendererProvider.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolDeclarationRendererProvider.kt index 1eada5f4d3d..265aebb607b 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolDeclarationRendererProvider.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolDeclarationRendererProvider.kt @@ -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) } } diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeProvider.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeProvider.kt index fe79c791941..1cb60425edb 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeProvider.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeProvider.kt @@ -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(), diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirCompileTimeConstantEvaluator.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirCompileTimeConstantEvaluator.kt index 5ae310a66e7..c82b0c9042b 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirCompileTimeConstantEvaluator.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirCompileTimeConstantEvaluator.kt @@ -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 diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirKotlinPropertySymbol.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirKotlinPropertySymbol.kt index 3166d4ca2db..8705648081f 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirKotlinPropertySymbol.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirKotlinPropertySymbol.kt @@ -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 } diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirOverrideInfoProvider.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirOverrideInfoProvider.kt index 746034d7b81..9c05ab582f4 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirOverrideInfoProvider.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirOverrideInfoProvider.kt @@ -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? diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/firSymbolUtils.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/firSymbolUtils.kt index 235a7411ed3..ff01987ba31 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/firSymbolUtils.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/firSymbolUtils.kt @@ -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() } \ No newline at end of file diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirPhaseManager.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirLazyDeclarationResolver.kt similarity index 79% rename from analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirPhaseManager.kt rename to analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirLazyDeclarationResolver.kt index e2093069b7f..6158d8ffeaf 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirPhaseManager.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirLazyDeclarationResolver.kt @@ -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) { diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirDesignatedBodyResolveTransformerForReturnTypeCalculator.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirDesignatedBodyResolveTransformerForReturnTypeCalculator.kt index 91963622b57..4b4c4873f5a 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirDesignatedBodyResolveTransformerForReturnTypeCalculator.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirDesignatedBodyResolveTransformerForReturnTypeCalculator.kt @@ -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.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() check(declarationList.isNotEmpty()) { "Invalid empty declaration designation" } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirEnsureBasedTransformerForReturnTypeCalculator.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirEnsureBasedTransformerForReturnTypeCalculator.kt index 20f6d9c069b..75a5094a90c 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirEnsureBasedTransformerForReturnTypeCalculator.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirEnsureBasedTransformerForReturnTypeCalculator.kt @@ -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.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) } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirBuiltinsSessionFactory.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirBuiltinsSessionFactory.kt index 477b0758983..1e0a14308c4 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirBuiltinsSessionFactory.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirBuiltinsSessionFactory.kt @@ -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) diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirLibrarySessionFactory.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirLibrarySessionFactory.kt index b50b4893569..c917448e684 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirLibrarySessionFactory.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirLibrarySessionFactory.kt @@ -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() diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirNonUnderContentRootSessionFactory.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirNonUnderContentRootSessionFactory.kt index 17a841c974d..ea377d7749e 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirNonUnderContentRootSessionFactory.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirNonUnderContentRootSessionFactory.kt @@ -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) diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirSessionFactory.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirSessionFactory.kt index d18fc87c0db..1505af14591 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirSessionFactory.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirSessionFactory.kt @@ -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) diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractFirLazyDeclarationResolveTest.kt b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractFirLazyDeclarationResolveTest.kt index c4c16b6cf0c..51d9a4bce84 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractFirLazyDeclarationResolveTest.kt +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractFirLazyDeclarationResolveTest.kt @@ -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) } diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/LowLevelFirAnalyzerFacade.kt b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/LowLevelFirAnalyzerFacade.kt index 7d6304d0f1c..a98c8ffaa05 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/LowLevelFirAnalyzerFacade.kt +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/LowLevelFirAnalyzerFacade.kt @@ -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 diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/SealedClassesInheritorsCaclulatorPreAnalysisHandler.kt b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/SealedClassesInheritorsCaclulatorPreAnalysisHandler.kt index 4e46f1442ef..86ca87a193c 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/SealedClassesInheritorsCaclulatorPreAnalysisHandler.kt +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/SealedClassesInheritorsCaclulatorPreAnalysisHandler.kt @@ -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, tmpFirResolveSession: LLFirResolveSession ): Map> { - firFiles.forEach { it.ensureResolved(FirResolvePhase.TYPES) } + firFiles.forEach { it.lazyResolveToPhase(FirResolvePhase.TYPES) } val inheritorsCollector = FirSealedClassInheritorsProcessor.InheritorsCollector(tmpFirResolveSession.useSiteFirSession) val sealedClassInheritorsMap = mutableMapOf>() firFiles.forEach { it.accept(inheritorsCollector, sealedClassInheritorsMap) } diff --git a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/FirJvmOverridesBackwardCompatibilityHelper.kt b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/FirJvmOverridesBackwardCompatibilityHelper.kt index 2986f5df429..4d19cc8d3fb 100644 --- a/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/FirJvmOverridesBackwardCompatibilityHelper.kt +++ b/compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/FirJvmOverridesBackwardCompatibilityHelper.kt @@ -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()?.classId == platformDependentAnnotation }) { diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirAnnotationHelpers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirAnnotationHelpers.kt index c96d6454336..6eacf8ca7b7 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirAnnotationHelpers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirAnnotationHelpers.kt @@ -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.consider() { - ensureResolved(FirResolvePhase.BODY_RESOLVE) + lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE) @OptIn(SymbolInternals::class) this.fir.consider() } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirCommonConstructorDelegationIssuesChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirCommonConstructorDelegationIssuesChecker.kt index 8ad7e05fa42..479ec442c87 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirCommonConstructorDelegationIssuesChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirCommonConstructorDelegationIssuesChecker.kt @@ -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() ?.resolvedSymbol diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirConflictsChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirConflictsChecker.kt index 2cc402138e5..5bd63afadc4 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirConflictsChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirConflictsChecker.kt @@ -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 -> diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationChecker.kt index f2502af10a9..6e0795f3b40 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationChecker.kt @@ -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 } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOverrideChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOverrideChecker.kt index 3264a97423d..ae927dcce2f 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOverrideChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirOverrideChecker.kt @@ -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( diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirClassLiteralChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirClassLiteralChecker.kt index b7349d411e6..ff5ed8058fe 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirClassLiteralChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirClassLiteralChecker.kt @@ -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] diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt index 73ceb2334cf..fe7a021ce95 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirOptInUsageBaseChecker.kt @@ -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) { - ensureResolved(FirResolvePhase.STATUS) + lazyResolveToPhase(FirResolvePhase.STATUS) @OptIn(SymbolInternals::class) fir.loadExperimentalitiesFromAnnotationTo(session, result) } @@ -133,7 +133,7 @@ object FirOptInUsageBaseChecker { fromSetter: Boolean, dispatchReceiverType: ConeKotlinType?, ): Set { - 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()) } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUninitializedEnumChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUninitializedEnumChecker.kt index 1568d8489c4..c9f87c89778 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUninitializedEnumChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUninitializedEnumChecker.kt @@ -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 diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UnusedChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UnusedChecker.kt index e6db26cbe0f..1e0508cab15 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UnusedChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UnusedChecker.kt @@ -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 } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirOptInUsageTypeRefChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirOptInUsageTypeRefChecker.kt index a56a7f7ce63..7ea2de2a4ee 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirOptInUsageTypeRefChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/type/FirOptInUsageTypeRefChecker.kt @@ -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) { diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/ComponentsContainers.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/ComponentsContainers.kt index 3f5286f2018..5bf7c2dd35b 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/ComponentsContainers.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/ComponentsContainers.kt @@ -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)) diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaOverrideChecker.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaOverrideChecker.kt index 10482a09207..72cb00d890b 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaOverrideChecker.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaOverrideChecker.kt @@ -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) { diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/ValueClassesUtils.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/ValueClassesUtils.kt index 14589619c92..bd29b9127b5 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/ValueClassesUtils.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/declarations/ValueClassesUtils.kt @@ -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 } } diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt index 48cc3beaca0..98c68201548 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/ScopeUtils.kt @@ -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) diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt index 7c76172639c..59842a87c84 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/SupertypeUtils.kt @@ -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 { 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 } } diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/TypeExpansionUtils.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/TypeExpansionUtils.kt index 7581a602542..c329b08a130 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/TypeExpansionUtils.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/TypeExpansionUtils.kt @@ -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? { diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/transformers/PhaseUtils.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/transformers/PhaseUtils.kt index 878ea384db9..71915802112 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/transformers/PhaseUtils.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/resolve/transformers/PhaseUtils.kt @@ -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( diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt index 81e156a2423..1488cd2537d 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/impl/FirClassSubstitutionScope.kt @@ -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() 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() // 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() val fakeOverrideSubstitution = runIf(returnType == null) { FakeOverrideSubstitution(substitutor, original) } val newReturnType = returnType?.substitute() diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/impl/FirDelegatedMemberScope.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/impl/FirDelegatedMemberScope.kt index ecb3986c25d..02c612f2f59 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/impl/FirDelegatedMemberScope.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/impl/FirDelegatedMemberScope.kt @@ -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) } diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/impl/FirStandardOverrideChecker.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/impl/FirStandardOverrideChecker.kt index 3bc67c0c950..373ffa28575 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/impl/FirStandardOverrideChecker.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/scopes/impl/FirStandardOverrideChecker.kt @@ -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) } } diff --git a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt index bbe87ec5cca..f8ec5daa635 100644 --- a/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt +++ b/compiler/fir/providers/src/org/jetbrains/kotlin/fir/types/ConeTypeContext.kt @@ -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) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt index e402a5f21fd..93b1de1de66 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt @@ -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 } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConstructorProcessing.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConstructorProcessing.kt index 82526eb4de3..7eb78739643 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConstructorProcessing.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConstructorProcessing.kt @@ -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().fullyExpandedType(session) val basicScope = type.scope(session, bodyResolveComponents.scopeSession, FakeOverrideTypeCalculator.DoNothing) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CreateFreshTypeVariableSubstitutorStage.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CreateFreshTypeVariableSubstitutorStage.kt index ba2895c014d..6e63c3df17c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CreateFreshTypeVariableSubstitutorStage.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CreateFreshTypeVariableSubstitutorStage.kt @@ -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() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt index 62955ada93e..bc38691625b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt @@ -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) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirPhaseCheckingPhaseManager.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCompilerLazyDeclarationResolver.kt similarity index 57% rename from compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirPhaseCheckingPhaseManager.kt rename to compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCompilerLazyDeclarationResolver.kt index dfcb9be17c6..6dda39e06d8 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirPhaseCheckingPhaseManager.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCompilerLazyDeclarationResolver.kt @@ -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) { } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt index 41d9ec9ab95..3f2720539ff 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSealedClassInheritorsProcessor.kt @@ -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 diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt index 254b2ae3fe7..e13b342cc3b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt @@ -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 } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolver.kt index 876b42370c4..d08b0206ab5 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolver.kt @@ -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 } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt index af651dc79d6..12a3d51645d 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt @@ -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) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/ImportingScopes.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/ImportingScopes.kt index 7b679406994..e07fdb6bb2b 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/ImportingScopes.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/ImportingScopes.kt @@ -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() @@ -39,7 +39,7 @@ private fun doCreateImportingScopes( session: FirSession, scopeSession: ScopeSession ): List { - file.ensureResolved(FirResolvePhase.IMPORTS) + file.lazyResolveToPhase(FirResolvePhase.IMPORTS) val excludedImportNames = file.imports.filter { it.aliasName != null }.mapNotNullTo(hashSetOf()) { it.importedFqName }.ifEmpty { emptySet() } return listOf( diff --git a/compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/transformers/publishedApiEffectiveVisibility.kt b/compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/transformers/publishedApiEffectiveVisibility.kt index d4d9faa2033..36ee318c623 100644 --- a/compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/transformers/publishedApiEffectiveVisibility.kt +++ b/compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/transformers/publishedApiEffectiveVisibility.kt @@ -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 } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/ExpectActualAttributes.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/ExpectActualAttributes.kt index e9b54bd1c4b..dbb1c2ca53d 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/ExpectActualAttributes.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/ExpectActualAttributes.kt @@ -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.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) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirBasedSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirBasedSymbol.kt index b250024fc0b..047456ab660 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirBasedSymbol.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirBasedSymbol.kt @@ -44,19 +44,19 @@ abstract class FirBasedSymbol { // 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 get() { - ensureResolved(FirResolvePhase.TYPES) + lazyResolveToPhase(FirResolvePhase.TYPES) return fir.annotations } val resolvedAnnotationClassIds: List get() { - ensureResolved(FirResolvePhase.TYPES) + lazyResolveToPhase(FirResolvePhase.TYPES) return fir.annotations.mapNotNull { (it.annotationTypeRef.coneType as? ConeClassLikeType)?.lookupTag?.classId } } } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirLazyDeclarationResolver.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirLazyDeclarationResolver.kt new file mode 100644 index 00000000000..0f10f1cceb3 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirLazyDeclarationResolver.kt @@ -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) +} diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirPhaseManager.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirPhaseManager.kt deleted file mode 100644 index 07f9beb186a..00000000000 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/FirPhaseManager.kt +++ /dev/null @@ -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) -} diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirCallableSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirCallableSymbol.kt index a76dbb4a9af..a5e381bbb9a 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirCallableSymbol.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirCallableSymbol.kt @@ -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 : FirBasedSymbol val resolvedContextReceivers: List 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 : FirBasedSymbol 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) } } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt index 22360f3fdca..6ec5b7cf809 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirClassLikeSymbol.kt @@ -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( val deprecation: DeprecationsPerUseSite? get() { - ensureResolved(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) + lazyResolveToPhase(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) return fir.deprecation } @@ -45,7 +45,7 @@ sealed class FirClassSymbol(classId: ClassId) : FirClassLikeSymbol val resolvedSuperTypeRefs: List get() { - ensureResolved(FirResolvePhase.SUPER_TYPES) + lazyResolveToPhase(FirResolvePhase.SUPER_TYPES) @Suppress("UNCHECKED_CAST") return fir.superTypeRefs as List } @@ -68,7 +68,7 @@ sealed class FirClassSymbol(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( val resolvedContextReceivers: List get() { - ensureResolved(FirResolvePhase.TYPES) + lazyResolveToPhase(FirResolvePhase.TYPES) return fir.contextReceivers } } @@ -93,13 +93,13 @@ class FirTypeAliasSymbol(classId: ClassId) : FirClassLikeSymbol(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 } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirFunctionSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirFunctionSymbol.kt index 08ae49f001c..a38bff93882 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirFunctionSymbol.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirFunctionSymbol.kt @@ -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( @@ -23,7 +22,7 @@ sealed class FirFunctionSymbol( 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( 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 } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirTypeParameterSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirTypeParameterSymbol.kt index 03cdfd08a53..23110e822f0 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirTypeParameterSymbol.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirTypeParameterSymbol.kt @@ -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() { val resolvedBounds: List get() { - ensureResolved(FirResolvePhase.TYPES) + lazyResolveToPhase(FirResolvePhase.TYPES) @Suppress("UNCHECKED_CAST") return fir.bounds as List } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirVariableSymbol.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirVariableSymbol.kt index 5421a05f1ac..b18bd78a969 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirVariableSymbol.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/symbols/impl/FirVariableSymbol.kt @@ -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 }