From 3ad2b8a2097f25647fb0e22ba7d40bb458872ca1 Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Wed, 7 Dec 2022 17:42:25 +0100 Subject: [PATCH] [LL FIR] rework FirDeclarationDesignation, so it can work with FirElementWithResolvePhase as a target --- .../fir/components/KtFirVisibilityChecker.kt | 2 +- .../low/level/api/fir/FirDesignationState.kt | 20 ++--- ...rationDesignation.kt => FirDesignation.kt} | 86 +++++++++++-------- .../LowLevelFirApiFacadeForResolveOnAir.kt | 21 +++-- ...extCollectingDiagnosticCollectorVisitor.kt | 15 ++-- ...solveTransformerForReturnTypeCalculator.kt | 6 +- .../lazy/resolve/FirLazyBodiesCalculator.kt | 39 ++++----- .../LLFirModuleLazyDeclarationResolver.kt | 22 ++--- .../RawFirNonLocalDeclarationBuilder.kt | 15 ++-- .../fir/project/structure/LLFirModuleData.kt | 4 +- .../sessions/LLFirResolvableModuleSession.kt | 7 +- .../level/api/fir/sessions/LLFirSession.kt | 4 +- .../LLFirDeclarationTransformer.kt | 11 +-- ...edAnnotationArgumentsMappingTransformer.kt | 25 +++--- ...edAnnotationArgumentsResolveTransformer.kt | 30 ++++--- ...DesignatedAnnotationsResolveTransformed.kt | 19 ++-- .../LLFirDesignatedBodyResolveTransformer.kt | 19 ++-- ...irDesignatedContractsResolveTransformer.kt | 22 ++--- ...esignatedExpectActualMatcherTransformer.kt | 19 ++-- ...eratedCompanionObjectResolveTransformer.kt | 17 ++-- ...LLFirDesignatedImplicitTypesTransformer.kt | 23 ++--- ...LLFirDesignatedStatusResolveTransformer.kt | 25 +++--- ...rDesignatedSupertypeResolverTransformer.kt | 49 +++++------ .../LLFirDesignatedTypeResolverTransformer.kt | 33 +++---- .../LLFirFileAnnotationsResolveTransformer.kt | 3 +- .../fir/transformers/LLFirLazyTransformer.kt | 18 ++-- .../LLFirLazyTransformerExecutor.kt | 4 +- .../transformers/LazyTransformerFactory.kt | 4 +- .../api/fir/util/contrainingFileUtils.kt | 6 +- .../api/fir/util/firCheckResolvedUtils.kt | 5 +- .../util/firDeclarationDesignationUtils.kt | 25 +++--- .../AbstractPartialRawFirBuilderTestCase.kt | 6 +- 32 files changed, 319 insertions(+), 285 deletions(-) rename analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/{FirDeclarationDesignation.kt => FirDesignation.kt} (58%) diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirVisibilityChecker.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirVisibilityChecker.kt index 9a24288d35e..2b53c7f13cb 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirVisibilityChecker.kt +++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirVisibilityChecker.kt @@ -10,7 +10,6 @@ import org.jetbrains.kotlin.analysis.api.components.KtVisibilityChecker import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirFileSymbol import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbol -import org.jetbrains.kotlin.analysis.api.fir.utils.firSymbol import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtFileSymbol @@ -84,6 +83,7 @@ internal class KtFirVisibilityChecker( return designation .toSequence(includeTarget = true) // we include the starting declaration in case it is a class or an object + .filterIsInstance() .toList() } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/FirDesignationState.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/FirDesignationState.kt index f2a4ee3ea8b..2c7f1ebddd0 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/FirDesignationState.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/FirDesignationState.kt @@ -5,16 +5,16 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir -import org.jetbrains.kotlin.fir.declarations.FirDeclaration -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignation import org.jetbrains.kotlin.analysis.low.level.api.fir.util.errorWithFirSpecificEntries +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase -abstract class ContextByDesignationCollector(private val designation: FirDeclarationDesignation) { +abstract class ContextByDesignationCollector(private val designation: FirDesignation) { private var context: C? = null private val designationState = FirDesignationState(designation) protected abstract fun getCurrentContext(): C - protected abstract fun goToNestedDeclaration(declaration: FirDeclaration) + protected abstract fun goToNestedDeclaration(target: FirElementWithResolvePhase) fun getCollectedContext(): C { return context @@ -24,20 +24,20 @@ abstract class ContextByDesignationCollector(private val designation: F fun nextStep() { if (designationState.canGoNext()) { designationState.goNext() - if (designationState.currentDeclarationIfPresent == designation.declaration) { + if (designationState.currentDeclarationIfPresent == designation.target) { check(context == null) context = getCurrentContext() } goToNestedDeclaration(designationState.currentDeclaration) } else { - if (designationState.currentDeclarationIfPresent == designation.declaration) { + if (designationState.currentDeclarationIfPresent == designation.target) { designationState.goToInnerDeclaration() } } } } -private class FirDesignationState(val designation: FirDeclarationDesignation) { +private class FirDesignationState(val designation: FirDesignation) { /** * Holds current declaration index * if `currentIndex in [0, designation.path.lastIndex]` then current declaration is in path @@ -48,14 +48,14 @@ private class FirDesignationState(val designation: FirDeclarationDesignation) { fun canGoNext(): Boolean = currentIndex < designation.path.size - val currentDeclarationIfPresent: FirDeclaration? + val currentDeclarationIfPresent: FirElementWithResolvePhase? get() = when (currentIndex) { in designation.path.indices -> designation.path[currentIndex] - designation.path.size -> designation.declaration + designation.path.size -> designation.target else -> null } - val currentDeclaration: FirDeclaration + val currentDeclaration: FirElementWithResolvePhase get() = currentDeclarationIfPresent ?: errorWithFirSpecificEntries("Went inside target declaration") diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/FirDeclarationDesignation.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/FirDesignation.kt similarity index 58% rename from analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/FirDeclarationDesignation.kt rename to analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/FirDesignation.kt index 473ced556d3..1a8c683eef1 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/FirDeclarationDesignation.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/FirDesignation.kt @@ -7,42 +7,45 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.api import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getContainingFile import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withFirEntry +import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment +import org.jetbrains.kotlin.analysis.utils.errors.checkWithAttachmentBuilder +import org.jetbrains.kotlin.analysis.utils.errors.unexpectedElementError import org.jetbrains.kotlin.descriptors.Visibilities +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase +import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.containingClassLookupTag import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.utils.classId import org.jetbrains.kotlin.fir.declarations.utils.isLocal +import org.jetbrains.kotlin.fir.diagnostics.ConeDestructuringDeclarationsOnTopLevel +import org.jetbrains.kotlin.fir.java.javaSymbolProvider import org.jetbrains.kotlin.fir.resolve.providers.firProvider import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLookupTagWithFixedSymbol -import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment -import org.jetbrains.kotlin.analysis.utils.errors.checkWithAttachmentBuilder -import org.jetbrains.kotlin.fir.diagnostics.ConeDestructuringDeclarationsOnTopLevel -import org.jetbrains.kotlin.fir.java.javaSymbolProvider -class FirDeclarationDesignationWithFile( +class FirDesignationWithFile( path: List, - declaration: FirDeclaration, + target: FirElementWithResolvePhase, val firFile: FirFile -) : FirDeclarationDesignation( +) : FirDesignation( path, - declaration, + target, ) { - fun toSequenceWithFile(includeTarget: Boolean): Sequence = sequence { + fun toSequenceWithFile(includeTarget: Boolean): Sequence = sequence { yield(firFile) yieldAll(path) - if (includeTarget) yield(declaration) + if (includeTarget) yield(target) } } -open class FirDeclarationDesignation( +open class FirDesignation( val path: List, - val declaration: FirDeclaration, + val target: FirElementWithResolvePhase, ) { - fun toSequence(includeTarget: Boolean): Sequence = sequence { + fun toSequence(includeTarget: Boolean): Sequence = sequence { yieldAll(path) - if (includeTarget) yield(declaration) + if (includeTarget) yield(target) } } @@ -59,19 +62,19 @@ private fun FirRegularClass.collectForNonLocal(): List { return designation } -private fun collectDesignationPath(declaration: FirDeclaration): List? { - val containingClass = when (declaration) { +private fun collectDesignationPath(resolvable: FirElementWithResolvePhase): List? { + val containingClass = when (resolvable) { is FirCallableDeclaration -> { - if (declaration !is FirConstructor && declaration.symbol.callableId.isLocal) return null - if ((declaration as? FirCallableDeclaration)?.status?.visibility == Visibilities.Local) return null - when (declaration) { + if (resolvable !is FirConstructor && resolvable.symbol.callableId.isLocal) return null + if ((resolvable as? FirCallableDeclaration)?.status?.visibility == Visibilities.Local) return null + when (resolvable) { is FirSimpleFunction, is FirProperty, is FirField, is FirConstructor, is FirEnumEntry, is FirPropertyAccessor -> { - val klass = declaration.containingClassLookupTag() ?: return emptyList() + val klass = resolvable.containingClassLookupTag() ?: return emptyList() if (klass.classId.isLocal) return null - klass.toFirRegularClassFromSameSession(declaration.moduleData.session) + klass.toFirRegularClassFromSameSession(resolvable.moduleData.session) } is FirErrorProperty -> { - return if (declaration.diagnostic == ConeDestructuringDeclarationsOnTopLevel) { + return if (resolvable.diagnostic == ConeDestructuringDeclarationsOnTopLevel) { emptyList() } else { null @@ -81,10 +84,10 @@ private fun collectDesignationPath(declaration: FirDeclaration): List { - if (declaration.isLocal) return null - val outerClassId = declaration.symbol.classId.outerClassId - outerClassId?.let(declaration.moduleData.session.firProvider::getFirClassifierByFqName) - ?: outerClassId?.let(declaration.moduleData.session.javaSymbolProvider::getClassLikeSymbolByClassId)?.fir + if (resolvable.isLocal) return null + val outerClassId = resolvable.symbol.classId.outerClassId + outerClassId?.let(resolvable.moduleData.session.firProvider::getFirClassifierByFqName) + ?: outerClassId?.let(resolvable.moduleData.session.javaSymbolProvider::getClassLikeSymbolByClassId)?.fir } else -> return null } ?: return emptyList() @@ -100,35 +103,44 @@ private fun ConeClassLikeLookupTag.toFirRegularClassFromSameSession(useSiteSessi return useSiteSession.firProvider.getFirClassifierByFqName(classId) as? FirRegularClass } -fun FirDeclaration.collectDesignation(firFile: FirFile): FirDeclarationDesignationWithFile = +fun FirElementWithResolvePhase.collectDesignation(firFile: FirFile): FirDesignationWithFile = tryCollectDesignation(firFile) ?: buildErrorWithAttachment("No designation of local declaration") { withFirEntry("firFile", firFile) } -fun FirDeclaration.collectDesignation(): FirDeclarationDesignation = +fun FirElementWithResolvePhase.collectDesignation(): FirDesignation = tryCollectDesignation() ?: buildErrorWithAttachment("No designation of local declaration") { withFirEntry("FirDeclaration", this@collectDesignation) } -fun FirDeclaration.collectDesignationWithFile(): FirDeclarationDesignationWithFile = +fun FirElementWithResolvePhase.collectDesignationWithFile(): FirDesignationWithFile = tryCollectDesignationWithFile() ?: buildErrorWithAttachment("No designation of local declaration") { withFirEntry("FirDeclaration", this@collectDesignationWithFile) } -fun FirDeclaration.tryCollectDesignation(firFile: FirFile): FirDeclarationDesignationWithFile? = +fun FirElementWithResolvePhase.tryCollectDesignation(firFile: FirFile): FirDesignationWithFile? = collectDesignationPath(this)?.let { - FirDeclarationDesignationWithFile(it, this, firFile) + FirDesignationWithFile(it, this, firFile) } -fun FirDeclaration.tryCollectDesignation(): FirDeclarationDesignation? = +fun FirElementWithResolvePhase.tryCollectDesignation(): FirDesignation? = collectDesignationPath(this)?.let { - FirDeclarationDesignation(it, this) + FirDesignation(it, this) } -fun FirDeclaration.tryCollectDesignationWithFile(): FirDeclarationDesignationWithFile? { - val path = collectDesignationPath(this) ?: return null - val firFile = getContainingFile() ?: return null - return FirDeclarationDesignationWithFile(path, this, firFile) +fun FirElementWithResolvePhase.tryCollectDesignationWithFile(): FirDesignationWithFile? { + return when (this) { + is FirDeclaration -> { + val path = collectDesignationPath(this) ?: return null + val firFile = getContainingFile() ?: return null + FirDesignationWithFile(path, this, firFile) + } + is FirFileAnnotationsContainer -> { + val firFile = getContainingFile() ?: return null + FirDesignationWithFile(path = emptyList(), this, firFile) + } + else -> unexpectedElementError(this) + } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/LowLevelFirApiFacadeForResolveOnAir.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/LowLevelFirApiFacadeForResolveOnAir.kt index 855671e522a..29d9561fda3 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/LowLevelFirApiFacadeForResolveOnAir.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/LowLevelFirApiFacadeForResolveOnAir.kt @@ -8,20 +8,25 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.api import com.intellij.psi.util.PsiTreeUtil import org.jetbrains.kotlin.analysis.low.level.api.fir.DeclarationCopyBuilder.withBodyFrom import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveSessionDepended -import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirResolvableResolveSession import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FileTowerProvider import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirTowerContextProvider import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirTowerDataContextAllElementsCollector import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.runCustomResolveUnderLock import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.FirElementsRecorder import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.KtToFirMapping -import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.* +import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.RawFirNonLocalDeclarationBuilder +import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.RawFirReplacement +import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.buildFileFirAnnotation +import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.buildFirUserTypeRef import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirResolvableModuleSession import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirResolvableSession import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirSession +import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirResolvableResolveSession import org.jetbrains.kotlin.analysis.low.level.api.fir.util.errorWithFirSpecificEntries import org.jetbrains.kotlin.analysis.low.level.api.fir.util.originalDeclaration import org.jetbrains.kotlin.analysis.project.structure.getKtModule +import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment +import org.jetbrains.kotlin.analysis.utils.errors.withPsiEntry import org.jetbrains.kotlin.analysis.utils.printer.getElementTextInContext import org.jetbrains.kotlin.analysis.utils.printer.parentOfType import org.jetbrains.kotlin.analysis.utils.printer.parentsOfType @@ -34,14 +39,12 @@ import org.jetbrains.kotlin.fir.resolve.transformers.FirTypeResolveTransformer import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataContextCollector import org.jetbrains.kotlin.fir.scopes.createImportingScopes import org.jetbrains.kotlin.fir.scopes.kotlinScopeProvider +import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid import org.jetbrains.kotlin.psi.* -import org.jetbrains.kotlin.psi.psiUtil.isAncestor -import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment -import org.jetbrains.kotlin.analysis.utils.errors.* -import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject +import org.jetbrains.kotlin.psi.psiUtil.isAncestor import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf object LowLevelFirApiFacadeForResolveOnAir { @@ -254,12 +257,12 @@ object LowLevelFirApiFacadeForResolveOnAir { } } else newDeclarationWithReplacement - val onAirDesignation = FirDeclarationDesignationWithFile( + val onAirDesignation = FirDesignationWithFile( path = originalDesignation.path, - declaration = copiedFirDeclaration, + target = copiedFirDeclaration, firFile = originalFirFile ) - val resolvableSession = onAirDesignation.declaration.llFirResolvableSession + val resolvableSession = onAirDesignation.target.llFirResolvableSession ?: error("Expected resolvable session") resolvableSession.moduleComponents.firModuleLazyDeclarationResolver .runLazyDesignatedOnAirResolveToBodyWithoutLock( diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostics/fir/ContextCollectingDiagnosticCollectorVisitor.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostics/fir/ContextCollectingDiagnosticCollectorVisitor.kt index c452e240473..a71fb71ba7d 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostics/fir/ContextCollectingDiagnosticCollectorVisitor.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostics/fir/ContextCollectingDiagnosticCollectorVisitor.kt @@ -5,7 +5,11 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.fir +import org.jetbrains.kotlin.analysis.low.level.api.fir.ContextByDesignationCollector +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDesignation import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollectorVisitor import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration @@ -14,21 +18,18 @@ import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.renderWithType import org.jetbrains.kotlin.fir.resolve.SessionHolder -import org.jetbrains.kotlin.analysis.low.level.api.fir.ContextByDesignationCollector -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDesignation private class ContextCollectingDiagnosticCollectorVisitor private constructor( sessionHolder: SessionHolder, - designation: FirDeclarationDesignationWithFile, + designation: FirDesignationWithFile, ) : AbstractDiagnosticCollectorVisitor( PersistentCheckerContextFactory.createEmptyPersistenceCheckerContext(sessionHolder) ) { private val contextCollector = object : ContextByDesignationCollector(designation) { override fun getCurrentContext(): CheckerContext = context - override fun goToNestedDeclaration(declaration: FirDeclaration) { - declaration.accept(this@ContextCollectingDiagnosticCollectorVisitor, null) + override fun goToNestedDeclaration(target: FirElementWithResolvePhase) { + target.accept(this@ContextCollectingDiagnosticCollectorVisitor, null) } } @@ -43,7 +44,7 @@ private class ContextCollectingDiagnosticCollectorVisitor private constructor( override fun checkElement(element: FirElement) {} companion object { - fun collect(sessionHolder: SessionHolder, designation: FirDeclarationDesignationWithFile): CheckerContext { + fun collect(sessionHolder: SessionHolder, designation: FirDesignationWithFile): CheckerContext { val visitor = ContextCollectingDiagnosticCollectorVisitor(sessionHolder, designation) designation.firFile.accept(visitor, null) return visitor.contextCollector.getCollectedContext() 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 3a1f2d50ef4..82a8e72659f 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 @@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyRe 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 +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignation import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator fun LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator( @@ -60,14 +60,14 @@ private class LLFirDesignatedBodyResolveTransformerForReturnTypeCalculatorImpl( ) { private val targetDeclaration = designation.last() - private inline fun D.processCallable(body: (FirDeclarationDesignation) -> Unit) { + private inline fun D.processCallable(body: (FirDesignation) -> Unit) { if (this !== targetDeclaration) return if (resolvePhase < FirResolvePhase.TYPES && returnTypeRef is FirResolvedTypeRef) return lazyResolveToPhase(FirResolvePhase.TYPES) if (returnTypeRef is FirImplicitTypeRef) { val declarationList = designation.filterIsInstance() check(declarationList.isNotEmpty()) { "Invalid empty declaration designation" } - body(FirDeclarationDesignation(declarationList.dropLast(1), this)) + body(FirDesignation(declarationList.dropLast(1), this)) } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/FirLazyBodiesCalculator.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/FirLazyBodiesCalculator.kt index 9424bd6952c..965d1b4cc23 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/FirLazyBodiesCalculator.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/FirLazyBodiesCalculator.kt @@ -8,10 +8,9 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve import kotlinx.collections.immutable.PersistentList import kotlinx.collections.immutable.persistentListOf import kotlinx.collections.immutable.toPersistentList -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignation import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.declarations.* -import org.jetbrains.kotlin.fir.declarations.impl.FirPrimaryConstructor import org.jetbrains.kotlin.fir.declarations.utils.getExplicitBackingField import org.jetbrains.kotlin.fir.expressions.FirFunctionCall import org.jetbrains.kotlin.fir.expressions.FirStatement @@ -26,10 +25,10 @@ import org.jetbrains.kotlin.fir.visitors.transformSingle import org.jetbrains.kotlin.psi.* internal object FirLazyBodiesCalculator { - fun calculateLazyBodiesInside(designation: FirDeclarationDesignation) { - designation.declaration.transform>( + fun calculateLazyBodiesInside(designation: FirDesignation) { + designation.target.transform>( FirLazyBodiesCalculatorTransformer, - designation.toSequence(includeTarget = false).toList().toPersistentList() + designation.path.toPersistentList(), ) } @@ -46,8 +45,8 @@ internal object FirLazyBodiesCalculator { } } - fun calculateLazyBodiesForFunction(designation: FirDeclarationDesignation) { - val simpleFunction = designation.declaration as FirSimpleFunction + fun calculateLazyBodiesForFunction(designation: FirDesignation) { + val simpleFunction = designation.target as FirSimpleFunction require(needCalculatingLazyBodyForFunction(simpleFunction)) val newFunction = RawFirNonLocalDeclarationBuilder.buildWithFunctionSymbolRebind( session = simpleFunction.moduleData.session, @@ -62,8 +61,8 @@ internal object FirLazyBodiesCalculator { } } - fun calculateLazyBodyForConstructor(designation: FirDeclarationDesignation) { - val constructor = designation.declaration as FirConstructor + fun calculateLazyBodyForConstructor(designation: FirDesignation) { + val constructor = designation.target as FirConstructor require(constructor.psi is KtConstructor<*>) require(needCalculatingLazyBodyForConstructor(constructor)) @@ -81,8 +80,8 @@ internal object FirLazyBodiesCalculator { } } - fun calculateLazyBodyForProperty(designation: FirDeclarationDesignation) { - val firProperty = designation.declaration as FirProperty + fun calculateLazyBodyForProperty(designation: FirDesignation) { + val firProperty = designation.target as FirProperty if (!needCalculatingLazyBodyForProperty(firProperty)) return val newProperty = RawFirNonLocalDeclarationBuilder.buildWithFunctionSymbolRebind( @@ -130,8 +129,8 @@ internal object FirLazyBodiesCalculator { } } - fun calculateLazyInitializerForEnumEntry(designation: FirDeclarationDesignation) { - val enumEntry = designation.declaration as FirEnumEntry + fun calculateLazyInitializerForEnumEntry(designation: FirDesignation) { + val enumEntry = designation.target as FirEnumEntry require(enumEntry.initializer is FirLazyExpression) val newEntry = RawFirNonLocalDeclarationBuilder.buildWithFunctionSymbolRebind( session = enumEntry.moduleData.session, @@ -144,8 +143,8 @@ internal object FirLazyBodiesCalculator { } } - fun calculateLazyBodyForAnonymousInitializer(designation: FirDeclarationDesignation) { - val initializer = designation.declaration as FirAnonymousInitializer + fun calculateLazyBodyForAnonymousInitializer(designation: FirDesignation) { + val initializer = designation.target as FirAnonymousInitializer require(initializer.body is FirLazyBlock) val newInitializer = RawFirNonLocalDeclarationBuilder.buildWithFunctionSymbolRebind( session = initializer.moduleData.session, @@ -197,7 +196,7 @@ private object FirLazyBodiesCalculatorTransformer : FirTransformer ): FirSimpleFunction { if (FirLazyBodiesCalculator.needCalculatingLazyBodyForFunction(simpleFunction)) { - val designation = FirDeclarationDesignation(data, simpleFunction) + val designation = FirDesignation(data, simpleFunction) FirLazyBodiesCalculator.calculateLazyBodiesForFunction(designation) } return simpleFunction @@ -208,7 +207,7 @@ private object FirLazyBodiesCalculatorTransformer : FirTransformer ): FirConstructor { if (FirLazyBodiesCalculator.needCalculatingLazyBodyForConstructor(constructor)) { - val designation = FirDeclarationDesignation(data, constructor) + val designation = FirDesignation(data, constructor) FirLazyBodiesCalculator.calculateLazyBodyForConstructor(designation) } return constructor @@ -216,7 +215,7 @@ private object FirLazyBodiesCalculatorTransformer : FirTransformer): FirProperty { if (FirLazyBodiesCalculator.needCalculatingLazyBodyForProperty(property)) { - val designation = FirDeclarationDesignation(data, property) + val designation = FirDesignation(data, property) FirLazyBodiesCalculator.calculateLazyBodyForProperty(designation) } return property @@ -228,7 +227,7 @@ private object FirLazyBodiesCalculatorTransformer : FirTransformer): FirStatement { if (enumEntry.initializer is FirLazyExpression) { - val designation = FirDeclarationDesignation(data, enumEntry) + val designation = FirDesignation(data, enumEntry) FirLazyBodiesCalculator.calculateLazyInitializerForEnumEntry(designation) } return enumEntry @@ -238,7 +237,7 @@ private object FirLazyBodiesCalculatorTransformer : FirTransformer ): FirAnonymousInitializer { if (anonymousInitializer.body is FirLazyBlock) { - val designation = FirDeclarationDesignation(data, anonymousInitializer) + val designation = FirDesignation(data, anonymousInitializer) FirLazyBodiesCalculator.calculateLazyBodyForAnonymousInitializer(designation) } return anonymousInitializer diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt index c3936f38890..39e545d3a4b 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirModuleResolveComponents -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDesignationWithFile import org.jetbrains.kotlin.analysis.low.level.api.fir.api.tryCollectDesignationWithFile import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.getNonLocalContainingOrThisDeclaration @@ -180,7 +180,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod if (validForResolveDeclarations.isEmpty()) return val designations = validForResolveDeclarations.map { - FirDeclarationDesignationWithFile(path = emptyList(), declaration = it, firFile = firFile) + FirDesignationWithFile(path = emptyList(), target = it, firFile = firFile) } var currentPhase = FirResolvePhase.IMPORTS @@ -189,7 +189,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod if (checkPCE) checkCanceled() val transformersToApply = designations.filter { designation -> - designation.declaration.resolvePhase < currentPhase + designation.target.resolvePhase < currentPhase } if (transformersToApply.isEmpty()) continue @@ -283,7 +283,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod val requestedDeclarationDesignation = firDeclarationToResolve.tryCollectDesignationWithFile() - val designation: FirDeclarationDesignationWithFile + val designation: FirDesignationWithFile val neededPhase: FirResolvePhase if (requestedDeclarationDesignation != null) { @@ -322,7 +322,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod designation = declarationToResolve.collectDesignationWithFile() } - if (designation.declaration.resolvePhase >= neededPhase) return + if (designation.target.resolvePhase >= neededPhase) return if (neededPhase == FirResolvePhase.IMPORTS) { resolveFileToImports(designation.firFile, checkPCE) @@ -336,13 +336,13 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod toPhase = neededPhase, checkPCE = checkPCE, ) - designation.declaration + designation.target } } private fun runLazyDesignatedResolveWithoutLock( - designation: FirDeclarationDesignationWithFile, + designation: FirDesignationWithFile, scopeSession: ScopeSession, toPhase: FirResolvePhase, checkPCE: Boolean, @@ -351,7 +351,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod resolveFileToImportsWithoutLock(designation.firFile, checkPCE) if (toPhase == FirResolvePhase.IMPORTS) return - val declarationResolvePhase = designation.declaration.resolvePhase + val declarationResolvePhase = designation.target.resolvePhase if (declarationResolvePhase >= toPhase) return var currentPhase = maxOf(declarationResolvePhase, FirResolvePhase.IMPORTS) @@ -374,13 +374,13 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod } internal fun runLazyDesignatedOnAirResolveToBodyWithoutLock( - designation: FirDeclarationDesignationWithFile, + designation: FirDesignationWithFile, checkPCE: Boolean, onAirCreatedDeclaration: Boolean, towerDataContextCollector: FirTowerDataContextCollector?, ) { resolveFileToImportsWithoutLock(designation.firFile, checkPCE) - var currentPhase = maxOf(designation.declaration.resolvePhase, FirResolvePhase.IMPORTS) + var currentPhase = maxOf(designation.target.resolvePhase, FirResolvePhase.IMPORTS) val scopeSession = ScopeSession() @@ -388,7 +388,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod LLFirFirProviderInterceptor.createForFirElement( session = designation.firFile.moduleData.session, firFile = designation.firFile, - element = designation.declaration + element = designation.target ) } else null diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/RawFirNonLocalDeclarationBuilder.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/RawFirNonLocalDeclarationBuilder.kt index 0c82c5f8bdf..52fb95e3c69 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/RawFirNonLocalDeclarationBuilder.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/RawFirNonLocalDeclarationBuilder.kt @@ -7,7 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve import com.intellij.psi.PsiElement import org.jetbrains.kotlin.KtSourceElement -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignation import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment import org.jetbrains.kotlin.analysis.utils.errors.withPsiEntry import org.jetbrains.kotlin.fir.* @@ -20,7 +20,8 @@ import org.jetbrains.kotlin.fir.references.FirSuperReference import org.jetbrains.kotlin.fir.scopes.FirScopeProvider import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol -import org.jetbrains.kotlin.fir.types.* +import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef +import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.psi import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.hasExpectModifier @@ -38,7 +39,7 @@ internal class RawFirNonLocalDeclarationBuilder private constructor( fun buildWithReplacement( session: FirSession, scopeProvider: FirScopeProvider, - designation: FirDeclarationDesignation, + designation: FirDesignation, rootNonLocalDeclaration: KtDeclaration, replacement: RawFirReplacement? ): FirDeclaration { @@ -46,7 +47,7 @@ internal class RawFirNonLocalDeclarationBuilder private constructor( val builder = RawFirNonLocalDeclarationBuilder( session = session, baseScopeProvider = scopeProvider, - originalDeclaration = designation.declaration, + originalDeclaration = designation.target as FirDeclaration, declarationToBuild = rootNonLocalDeclaration, replacementApplier = replacementApplier ) @@ -59,10 +60,10 @@ internal class RawFirNonLocalDeclarationBuilder private constructor( fun buildWithFunctionSymbolRebind( session: FirSession, scopeProvider: FirScopeProvider, - designation: FirDeclarationDesignation, + designation: FirDesignation, rootNonLocalDeclaration: KtDeclaration, ): FirDeclaration { - val functionsToRebind = when (val originalDeclaration = designation.declaration) { + val functionsToRebind = when (val originalDeclaration = designation.target) { is FirFunction -> setOf(originalDeclaration) is FirProperty -> setOfNotNull(originalDeclaration.getter, originalDeclaration.setter) else -> null @@ -71,7 +72,7 @@ internal class RawFirNonLocalDeclarationBuilder private constructor( val builder = RawFirNonLocalDeclarationBuilder( session = session, baseScopeProvider = scopeProvider, - originalDeclaration = designation.declaration, + originalDeclaration = designation.target as FirDeclaration, declarationToBuild = rootNonLocalDeclaration, functionsToRebind = functionsToRebind, ) diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirModuleData.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirModuleData.kt index 386896d7c4b..cb102a02897 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirModuleData.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirModuleData.kt @@ -7,15 +7,15 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure import org.jetbrains.kotlin.analysis.project.structure.KtModule import org.jetbrains.kotlin.fir.FirModuleData +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.moduleData import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.platform.TargetPlatform import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices -val FirDeclaration.llFirModuleData: LLFirModuleData +val FirElementWithResolvePhase.llFirModuleData: LLFirModuleData get() { return moduleData as LLFirModuleData } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirResolvableModuleSession.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirResolvableModuleSession.kt index fc706e281a9..4316913bc2d 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirResolvableModuleSession.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirResolvableModuleSession.kt @@ -6,12 +6,9 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.sessions import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirModuleResolveComponents -import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.ModuleFileCache -import org.jetbrains.kotlin.analysis.low.level.api.fir.providers.LLFirProvider import org.jetbrains.kotlin.fir.BuiltinTypes -import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase import org.jetbrains.kotlin.fir.resolve.ScopeSession -import org.jetbrains.kotlin.fir.resolve.providers.firProvider import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol abstract class LLFirResolvableModuleSession( @@ -24,7 +21,7 @@ abstract class LLFirResolvableModuleSession( } } -internal val FirDeclaration.llFirResolvableSession: LLFirResolvableModuleSession? +internal val FirElementWithResolvePhase.llFirResolvableSession: LLFirResolvableModuleSession? get() = llFirSession as? LLFirResolvableModuleSession internal val FirBasedSymbol<*>.llFirResolvableSession: LLFirResolvableModuleSession? diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirSession.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirSession.kt index c2f9f82d443..7693bae119f 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirSession.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirSession.kt @@ -8,9 +8,9 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.sessions import com.intellij.openapi.project.Project import org.jetbrains.kotlin.analysis.project.structure.KtModule import org.jetbrains.kotlin.fir.BuiltinTypes +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.PrivateSessionConstructor -import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol @@ -24,7 +24,7 @@ abstract class LLFirSession(override val builtinTypes: BuiltinTypes, kind: Kind) abstract class LLFirModuleSession(builtinTypes: BuiltinTypes, kind: Kind) : LLFirSession(builtinTypes, kind) -val FirDeclaration.llFirSession: LLFirSession +val FirElementWithResolvePhase.llFirSession: LLFirSession get() = moduleData.session as LLFirSession val FirBasedSymbol<*>.llFirSession: LLFirSession diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDeclarationTransformer.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDeclarationTransformer.kt index 4d62811b11d..4a263099391 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDeclarationTransformer.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDeclarationTransformer.kt @@ -5,14 +5,15 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignation import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer import org.jetbrains.kotlin.fir.visitors.FirVisitor -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation -internal class LLFirDeclarationTransformer(private val designation: FirDeclarationDesignation) { +internal class LLFirDeclarationTransformer(private val designation: FirDesignation) { private val designationWithoutTargetIterator = designation.toSequence(includeTarget = false).iterator() private var isInsideTargetDeclaration: Boolean = false private var designationPassed: Boolean = false @@ -42,7 +43,7 @@ internal class LLFirDeclarationTransformer(private val designation: FirDeclarati private inline fun processDeclarationContent( declaration: FirDeclaration, default: () -> FirDeclaration, - applyToDesignated: (FirDeclaration) -> Unit, + applyToDesignated: (FirElementWithResolvePhase) -> Unit, ): FirDeclaration { //It means that we are inside the target declaration if (isInsideTargetDeclaration) { @@ -60,7 +61,7 @@ internal class LLFirDeclarationTransformer(private val designation: FirDeclarati try { isInsideTargetDeclaration = true designationPassed = true - applyToDesignated(designation.declaration) + applyToDesignated(designation.target) } finally { isInsideTargetDeclaration = false } @@ -70,6 +71,6 @@ internal class LLFirDeclarationTransformer(private val designation: FirDeclarati } fun ensureDesignationPassed() { - check(designationPassed) { "Designation not passed for declaration ${designation.declaration::class.simpleName}" } + check(designationPassed) { "Designation not passed for declaration ${designation.target::class.simpleName}" } } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationArgumentsMappingTransformer.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationArgumentsMappingTransformer.kt index 79f069d5437..dc4176de632 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationArgumentsMappingTransformer.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationArgumentsMappingTransformer.kt @@ -6,10 +6,12 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkAnnotationArgumentsMappingIsResolved import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase +import org.jetbrains.kotlin.fir.FirAnnotationContainer +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirFile @@ -23,7 +25,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirAnnotationArgumen * Transform designation into ANNOTATIONS_ARGUMENTS_MAPPING declaration. Affects only for target declaration, it's children and dependents */ internal class LLFirDesignatedAnnotationArgumentsMappingTransformer( - private val designation: FirDeclarationDesignationWithFile, + private val designation: FirDesignationWithFile, session: FirSession, scopeSession: ScopeSession, ) : LLFirLazyTransformer, FirAnnotationArgumentsMappingTransformer(session, scopeSession, FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) { @@ -35,24 +37,25 @@ internal class LLFirDesignatedAnnotationArgumentsMappingTransformer( } override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { - if (designation.declaration.resolvePhase >= FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) return - designation.declaration.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) + if (designation.target.resolvePhase >= FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) return + designation.target.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) { designation.firFile.transform(this, ResolutionMode.ContextIndependent) } - updatePhaseDeep(designation.declaration, FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) - checkIsResolved(designation.declaration) + updatePhaseDeep(designation.target, FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) + checkIsResolved(designation.target) } - override fun checkIsResolved(declaration: FirDeclaration) { - declaration.checkPhase(FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) - for (annotation in declaration.annotations) { + override fun checkIsResolved(resolvable: FirElementWithResolvePhase) { + resolvable.checkPhase(FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) + if (resolvable !is FirAnnotationContainer) return + for (annotation in resolvable.annotations) { if (annotation is FirAnnotationCall) { - checkAnnotationArgumentsMappingIsResolved(annotation, declaration) + checkAnnotationArgumentsMappingIsResolved(annotation, resolvable) } } - checkNestedDeclarationsAreResolved(declaration) + checkNestedDeclarationsAreResolved(resolvable) } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationArgumentsResolveTransformer.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationArgumentsResolveTransformer.kt index 77fd5b08774..f28eb91fbef 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationArgumentsResolveTransformer.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationArgumentsResolveTransformer.kt @@ -6,10 +6,11 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkTypeRefIsResolved import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withFirEntry +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.ResolutionMode @@ -18,14 +19,14 @@ import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirAnnotationArgumen import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef internal class LLFirDesignatedAnnotationArgumentsResolveTransformer( - private val designation: FirDeclarationDesignationWithFile, + private val designation: FirDesignationWithFile, session: FirSession, scopeSession: ScopeSession, ) : LLFirLazyTransformer, FirAnnotationArgumentsResolveTransformer(session, scopeSession, FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) { - private fun moveNextDeclaration(designationIterator: Iterator) { + private fun moveNextDeclaration(designationIterator: Iterator) { if (!designationIterator.hasNext()) { - designation.declaration.transform(declarationsTransformer, ResolutionMode.ContextIndependent) + designation.target.transform(declarationsTransformer, ResolutionMode.ContextIndependent) return } when (val nextElement = designationIterator.next()) { @@ -51,8 +52,8 @@ internal class LLFirDesignatedAnnotationArgumentsResolveTransformer( } override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { - if (designation.declaration.resolvePhase >= FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) return - designation.declaration.checkPhase(FirResolvePhase.STATUS) + if (designation.target.resolvePhase >= FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) return + designation.target.checkPhase(FirResolvePhase.STATUS) val designationIterator = designation.toSequenceWithFile(includeTarget = false).iterator() @@ -61,26 +62,27 @@ internal class LLFirDesignatedAnnotationArgumentsResolveTransformer( } - LLFirLazyTransformer.updatePhaseDeep(designation.declaration, FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) - checkIsResolved(designation.declaration) + LLFirLazyTransformer.updatePhaseDeep(designation.target, FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) + checkIsResolved(designation.target) } - override fun checkIsResolved(declaration: FirDeclaration) { - val unresolvedAnnotation = declaration.annotations.firstOrNull { it.annotationTypeRef !is FirResolvedTypeRef } + override fun checkIsResolved(resolvable: FirElementWithResolvePhase) { + if (resolvable !is FirDeclaration) return + val unresolvedAnnotation = resolvable.annotations.firstOrNull { it.annotationTypeRef !is FirResolvedTypeRef } check(unresolvedAnnotation == null) { "Unexpected annotationTypeRef annotation, expected resolvedType but actual ${unresolvedAnnotation?.annotationTypeRef}" } - declaration.checkPhase(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) + resolvable.checkPhase(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) - for (annotation in declaration.annotations) { + for (annotation in resolvable.annotations) { for (argument in annotation.argumentMapping.mapping.values) { - checkTypeRefIsResolved(argument.typeRef, "annotation argument", declaration) { + checkTypeRefIsResolved(argument.typeRef, "annotation argument", resolvable) { withFirEntry("firAnnotation", annotation) withFirEntry("firArgument", argument) } } } - checkNestedDeclarationsAreResolved(declaration) + checkNestedDeclarationsAreResolved(resolvable) } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationsResolveTransformed.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationsResolveTransformed.kt index 448af3096fa..30c0855b6e7 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationsResolveTransformed.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationsResolveTransformed.kt @@ -6,8 +6,9 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.ScopeSession @@ -15,14 +16,14 @@ import org.jetbrains.kotlin.fir.resolve.transformers.plugin.CompilerRequiredAnno import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirCompilerRequiredAnnotationsResolveTransformer internal class LLFirDesignatedAnnotationsResolveTransformed( - private val designation: FirDeclarationDesignationWithFile, + private val designation: FirDesignationWithFile, session: FirSession, scopeSession: ScopeSession, ) : LLFirLazyTransformer, FirCompilerRequiredAnnotationsResolveTransformer(session, scopeSession, CompilerRequiredAnnotationsComputationSession()) { - private fun moveNextDeclaration(designationIterator: Iterator) { + private fun moveNextDeclaration(designationIterator: Iterator) { if (!designationIterator.hasNext()) { - val declaration = designation.declaration + val declaration = designation.target if (declaration is FirRegularClass || declaration is FirTypeAlias) { declaration.transform(this, null) } @@ -44,7 +45,7 @@ internal class LLFirDesignatedAnnotationsResolveTransformed( } override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { - if (designation.declaration.resolvePhase >= FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) return + if (designation.target.resolvePhase >= FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) return val designationIterator = designation.toSequenceWithFile(includeTarget = false).iterator() @@ -52,12 +53,12 @@ internal class LLFirDesignatedAnnotationsResolveTransformed( moveNextDeclaration(designationIterator) } - LLFirLazyTransformer.updatePhaseDeep(designation.declaration, FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) - checkIsResolved(designation.declaration) + LLFirLazyTransformer.updatePhaseDeep(designation.target, FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) + checkIsResolved(designation.target) } - override fun checkIsResolved(declaration: FirDeclaration) { - declaration.checkPhase(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) + override fun checkIsResolved(resolvable: FirElementWithResolvePhase) { + resolvable.checkPhase(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) // todo add proper check that COMPILER_REQUIRED_ANNOTATIONS are resolved // checkNestedDeclarationsAreResolved(declaration) } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedBodyResolveTransformer.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedBodyResolveTransformer.kt index d30c063456c..1e3eb0ca68a 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedBodyResolveTransformer.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedBodyResolveTransformer.kt @@ -15,16 +15,17 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataCo import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTypeCalculatorForIDE import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirEnsureBasedTransformerForReturnTypeCalculator import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase /** * Transform designation into BODY_RESOLVE declaration. Affects only for target declaration and it's children */ internal class LLFirDesignatedBodyResolveTransformer( - private val designation: FirDeclarationDesignationWithFile, + private val designation: FirDesignationWithFile, session: FirSession, scopeSession: ScopeSession, towerDataContextCollector: FirTowerDataContextCollector?, @@ -50,8 +51,8 @@ internal class LLFirDesignatedBodyResolveTransformer( } override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { - if (designation.declaration.resolvePhase >= FirResolvePhase.BODY_RESOLVE) return - designation.declaration.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) + if (designation.target.resolvePhase >= FirResolvePhase.BODY_RESOLVE) return + designation.target.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.BODY_RESOLVE) { designation.firFile.transform(this, ResolutionMode.ContextIndependent) @@ -59,13 +60,13 @@ internal class LLFirDesignatedBodyResolveTransformer( ideDeclarationTransformer.ensureDesignationPassed() - updatePhaseDeep(designation.declaration, FirResolvePhase.BODY_RESOLVE, withNonLocalDeclarations = true) - checkIsResolved(designation.declaration) + updatePhaseDeep(designation.target, FirResolvePhase.BODY_RESOLVE, withNonLocalDeclarations = true) + checkIsResolved(designation.target) } - override fun checkIsResolved(declaration: FirDeclaration) { - declaration.checkPhase(FirResolvePhase.BODY_RESOLVE) - checkNestedDeclarationsAreResolved(declaration) + override fun checkIsResolved(resolvable: FirElementWithResolvePhase) { + resolvable.checkPhase(FirResolvePhase.BODY_RESOLVE) + checkNestedDeclarationsAreResolved(resolvable) } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedContractsResolveTransformer.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedContractsResolveTransformer.kt index 8b9c9012363..a2efcdfaa72 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedContractsResolveTransformer.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedContractsResolveTransformer.kt @@ -9,19 +9,19 @@ import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.ScopeSession -import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirDeclarationsResolveTransformer import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase import org.jetbrains.kotlin.fir.resolve.transformers.contracts.FirAbstractContractResolveTransformerDispatcher /** * Transform designation into CONTRACTS declaration. Affects only for target declaration and it's children */ internal class LLFirDesignatedContractsResolveTransformer( - private val designation: FirDeclarationDesignationWithFile, + private val designation: FirDesignationWithFile, session: FirSession, scopeSession: ScopeSession, ) : LLFirLazyTransformer, FirAbstractContractResolveTransformerDispatcher(session, scopeSession) { @@ -44,8 +44,8 @@ internal class LLFirDesignatedContractsResolveTransformer( } override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { - if (designation.declaration.resolvePhase >= FirResolvePhase.CONTRACTS) return - designation.declaration.checkPhase(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) + if (designation.target.resolvePhase >= FirResolvePhase.CONTRACTS) return + designation.target.checkPhase(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) FirLazyBodiesCalculator.calculateLazyBodiesInside(designation) phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.CONTRACTS) { @@ -53,15 +53,15 @@ internal class LLFirDesignatedContractsResolveTransformer( } ideDeclarationTransformer.ensureDesignationPassed() - updatePhaseDeep(designation.declaration, FirResolvePhase.CONTRACTS) - checkIsResolved(designation.declaration) + updatePhaseDeep(designation.target, FirResolvePhase.CONTRACTS) + checkIsResolved(designation.target) } - override fun checkIsResolved(declaration: FirDeclaration) { - declaration.checkPhase(FirResolvePhase.CONTRACTS) - if (declaration is FirContractDescriptionOwner) { + override fun checkIsResolved(resolvable: FirElementWithResolvePhase) { + resolvable.checkPhase(FirResolvePhase.CONTRACTS) + if (resolvable is FirContractDescriptionOwner) { // TODO checkContractDescriptionIsResolved(declaration) } - checkNestedDeclarationsAreResolved(declaration) + checkNestedDeclarationsAreResolved(resolvable) } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedExpectActualMatcherTransformer.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedExpectActualMatcherTransformer.kt index c6efbbeeb84..21515a5d775 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedExpectActualMatcherTransformer.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedExpectActualMatcherTransformer.kt @@ -6,10 +6,11 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.expressions.FirStatement @@ -17,7 +18,7 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.mpp.FirExpectActualMatcherTransformer internal class LLFirDesignatedExpectActualMatcherTransformer( - private val designation: FirDeclarationDesignationWithFile, + private val designation: FirDesignationWithFile, session: FirSession, scopeSession: ScopeSession, ) : LLFirLazyTransformer, FirExpectActualMatcherTransformer(session, scopeSession) { @@ -37,8 +38,8 @@ internal class LLFirDesignatedExpectActualMatcherTransformer( } override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { - if (designation.declaration.resolvePhase >= FirResolvePhase.EXPECT_ACTUAL_MATCHING) return - designation.declaration.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) + if (designation.target.resolvePhase >= FirResolvePhase.EXPECT_ACTUAL_MATCHING) return + designation.target.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) FirLazyBodiesCalculator.calculateLazyBodiesInside(designation) phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.EXPECT_ACTUAL_MATCHING) { @@ -47,14 +48,14 @@ internal class LLFirDesignatedExpectActualMatcherTransformer( declarationTransformer.ensureDesignationPassed() - updatePhaseDeep(designation.declaration, FirResolvePhase.EXPECT_ACTUAL_MATCHING) - checkIsResolved(designation.declaration) + updatePhaseDeep(designation.target, FirResolvePhase.EXPECT_ACTUAL_MATCHING) + checkIsResolved(designation.target) } - override fun checkIsResolved(declaration: FirDeclaration) { - declaration.checkPhase(FirResolvePhase.EXPECT_ACTUAL_MATCHING) + override fun checkIsResolved(resolvable: FirElementWithResolvePhase) { + resolvable.checkPhase(FirResolvePhase.EXPECT_ACTUAL_MATCHING) // TODO check if expect-actual matching is present - checkNestedDeclarationsAreResolved(declaration) + checkNestedDeclarationsAreResolved(resolvable) } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedGeneratedCompanionObjectResolveTransformer.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedGeneratedCompanionObjectResolveTransformer.kt index 472d2555d9e..835320b2ee7 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedGeneratedCompanionObjectResolveTransformer.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedGeneratedCompanionObjectResolveTransformer.kt @@ -6,30 +6,31 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirCompanionGenerationTransformer internal class LLFirDesignatedGeneratedCompanionObjectResolveTransformer( - val designation: FirDeclarationDesignationWithFile, + val designation: FirDesignationWithFile, session: FirSession ) : LLFirLazyTransformer { private val transformer: FirCompanionGenerationTransformer = FirCompanionGenerationTransformer(session) override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { - if (designation.declaration.resolvePhase >= FirResolvePhase.COMPANION_GENERATION) return + if (designation.target.resolvePhase >= FirResolvePhase.COMPANION_GENERATION) return phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.COMPANION_GENERATION) { - designation.declaration.transform(transformer, null) + designation.target.transform(transformer, null) } - LLFirLazyTransformer.updatePhaseDeep(designation.declaration, FirResolvePhase.COMPANION_GENERATION) - checkIsResolved(designation.declaration) + LLFirLazyTransformer.updatePhaseDeep(designation.target, FirResolvePhase.COMPANION_GENERATION) + checkIsResolved(designation.target) } - override fun checkIsResolved(declaration: FirDeclaration) { - check(declaration.resolvePhase >= FirResolvePhase.COMPANION_GENERATION) + override fun checkIsResolved(resolvable: FirElementWithResolvePhase) { + check(resolvable.resolvePhase >= FirResolvePhase.COMPANION_GENERATION) } } \ No newline at end of file diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedImplicitTypesTransformer.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedImplicitTypesTransformer.kt index 51504dbc23c..230605d3b44 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedImplicitTypesTransformer.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedImplicitTypesTransformer.kt @@ -14,17 +14,18 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataCo import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyResolveComputationSession import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTypeCalculatorForIDE import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkReturnTypeRefIsResolved +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase /** * Transform designation into IMPLICIT_TYPES_BODY_RESOLVE declaration. Affects only for target declaration, it's children and dependents */ internal class LLFirDesignatedImplicitTypesTransformer( - private val designation: FirDeclarationDesignationWithFile, + private val designation: FirDesignationWithFile, session: FirSession, scopeSession: ScopeSession, towerDataContextCollector: FirTowerDataContextCollector?, @@ -50,8 +51,8 @@ internal class LLFirDesignatedImplicitTypesTransformer( } override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { - if (designation.declaration.resolvePhase >= FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) return - designation.declaration.checkPhase(FirResolvePhase.CONTRACTS) + if (designation.target.resolvePhase >= FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) return + designation.target.checkPhase(FirResolvePhase.CONTRACTS) phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { designation.firFile.transform(this, ResolutionMode.ContextIndependent) @@ -59,15 +60,15 @@ internal class LLFirDesignatedImplicitTypesTransformer( ideDeclarationTransformer.ensureDesignationPassed() - updatePhaseDeep(designation.declaration, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) - checkIsResolved(designation.declaration) + updatePhaseDeep(designation.target, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) + checkIsResolved(designation.target) } - override fun checkIsResolved(declaration: FirDeclaration) { - declaration.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) - if (declaration is FirCallableDeclaration) { - checkReturnTypeRefIsResolved(declaration) + override fun checkIsResolved(resolvable: FirElementWithResolvePhase) { + resolvable.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) + if (resolvable is FirCallableDeclaration) { + checkReturnTypeRefIsResolved(resolvable) } - checkNestedDeclarationsAreResolved(declaration) + checkNestedDeclarationsAreResolved(resolvable) } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedStatusResolveTransformer.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedStatusResolveTransformer.kt index cb648259c05..d623143eeb8 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedStatusResolveTransformer.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedStatusResolveTransformer.kt @@ -12,16 +12,17 @@ import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.transformers.FirStatusResolveTransformer import org.jetbrains.kotlin.fir.resolve.transformers.StatusComputationSession import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkDeclarationStatusIsResolved import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase /** * Transform designation into STATUS phase. Affects only for designation, target declaration, it's children and dependents */ internal class LLFirDesignatedStatusResolveTransformer( - private val designation: FirDeclarationDesignationWithFile, + private val designation: FirDesignationWithFile, private val session: FirSession, private val scopeSession: ScopeSession, ) : LLFirLazyTransformer { @@ -37,8 +38,8 @@ internal class LLFirDesignatedStatusResolveTransformer( } override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { - if (designation.declaration.resolvePhase >= FirResolvePhase.STATUS) return - designation.declaration.checkPhase(FirResolvePhase.TYPES) + if (designation.target.resolvePhase >= FirResolvePhase.STATUS) return + designation.target.checkPhase(FirResolvePhase.TYPES) val transformer = FirDesignatedStatusResolveTransformerForIDE() phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.STATUS) { @@ -46,17 +47,17 @@ internal class LLFirDesignatedStatusResolveTransformer( } transformer.designationTransformer.ensureDesignationPassed() - updatePhaseDeep(designation.declaration, FirResolvePhase.STATUS) - checkIsResolved(designation.declaration) + updatePhaseDeep(designation.target, FirResolvePhase.STATUS) + checkIsResolved(designation.target) } - override fun checkIsResolved(declaration: FirDeclaration) { - if (declaration !is FirAnonymousInitializer) { - declaration.checkPhase(FirResolvePhase.STATUS) + override fun checkIsResolved(resolvable: FirElementWithResolvePhase) { + if (resolvable !is FirAnonymousInitializer) { + resolvable.checkPhase(FirResolvePhase.STATUS) } - if (declaration is FirMemberDeclaration) { - checkDeclarationStatusIsResolved(declaration) + if (resolvable is FirMemberDeclaration) { + checkDeclarationStatusIsResolved(resolvable) } - checkNestedDeclarationsAreResolved(declaration) + checkNestedDeclarationsAreResolved(resolvable) } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedSupertypeResolverTransformer.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedSupertypeResolverTransformer.kt index f5606261e1c..71eaf11aadd 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedSupertypeResolverTransformer.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedSupertypeResolverTransformer.kt @@ -6,8 +6,8 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignation +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDesignation import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.runCustomResolveUnderLock @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkCanceled import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkTypeRefIsResolved import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass @@ -29,7 +30,7 @@ import org.jetbrains.kotlin.fir.types.toSymbol * Transform designation into SUPER_TYPES phase. Affects only for designation, target declaration, it's children and dependents */ internal class LLFirDesignatedSupertypeResolverTransformer( - private val designation: FirDeclarationDesignationWithFile, + private val designation: FirDesignationWithFile, private val session: FirSession, private val scopeSession: ScopeSession, private val lockProvider: LLFirLockProvider, @@ -39,7 +40,7 @@ internal class LLFirDesignatedSupertypeResolverTransformer( private val supertypeComputationSession = SupertypeComputationSession() - private inner class DesignatedFirSupertypeResolverVisitor(classDesignation: FirDeclarationDesignation) : + private inner class DesignatedFirSupertypeResolverVisitor(classDesignation: FirDesignation) : FirSupertypeResolverVisitor( session = session, supertypeComputationSession = supertypeComputationSession, @@ -58,7 +59,7 @@ internal class LLFirDesignatedSupertypeResolverTransformer( } } - private inner class DesignatedFirApplySupertypesTransformer(classDesignation: FirDeclarationDesignation) : + private inner class DesignatedFirApplySupertypesTransformer(classDesignation: FirDesignation) : FirApplySupertypesTransformer(supertypeComputationSession, session, scopeSession) { val declarationTransformer = LLFirDeclarationTransformer(classDesignation) @@ -70,9 +71,9 @@ internal class LLFirDesignatedSupertypeResolverTransformer( } } - private fun collect(designation: FirDeclarationDesignationWithFile): Collection { - val visited = mutableMapOf() - val toVisit = mutableListOf() + private fun collect(designation: FirDesignationWithFile): Collection { + val visited = mutableMapOf() + val toVisit = mutableListOf() toVisit.add(designation) while (toVisit.isNotEmpty()) { @@ -84,7 +85,7 @@ internal class LLFirDesignatedSupertypeResolverTransformer( nowVisit.firFile.accept(resolver, null) } resolver.declarationTransformer.ensureDesignationPassed() - visited[nowVisit.declaration] = nowVisit + visited[nowVisit.target] = nowVisit } toVisit.clear() @@ -104,8 +105,8 @@ internal class LLFirDesignatedSupertypeResolverTransformer( return visited.values } - private fun apply(visited: Collection) { - fun applyToFileSymbols(designations: List) { + private fun apply(visited: Collection) { + fun applyToFileSymbols(designations: List) { for (designation in designations) { if (checkPCE) checkCanceled() val applier = DesignatedFirApplySupertypesTransformer(designation) @@ -128,18 +129,18 @@ internal class LLFirDesignatedSupertypeResolverTransformer( } override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { - if (designation.declaration.resolvePhase >= FirResolvePhase.SUPER_TYPES) return + if (designation.target.resolvePhase >= FirResolvePhase.SUPER_TYPES) return designation.firFile.checkPhase(FirResolvePhase.IMPORTS) - val targetDesignation = if (designation.declaration !is FirClassLikeDeclaration) { + val targetDesignation = if (designation.target !is FirClassLikeDeclaration) { val resolvableTarget = designation.path.lastOrNull() if (resolvableTarget == null) { - updatePhaseDeep(designation.declaration, FirResolvePhase.SUPER_TYPES) + updatePhaseDeep(designation.target, FirResolvePhase.SUPER_TYPES) return } check(resolvableTarget is FirClassLikeDeclaration) val targetPath = designation.path.dropLast(1) - FirDeclarationDesignationWithFile(targetPath, resolvableTarget, designation.firFile) + FirDesignationWithFile(targetPath, resolvableTarget, designation.firFile) } else designation phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.SUPER_TYPES) { @@ -148,25 +149,25 @@ internal class LLFirDesignatedSupertypeResolverTransformer( apply(collected) } - updatePhaseDeep(designation.declaration, FirResolvePhase.SUPER_TYPES) - checkIsResolved(designation.declaration) + updatePhaseDeep(designation.target, FirResolvePhase.SUPER_TYPES) + checkIsResolved(designation.target) } - override fun checkIsResolved(declaration: FirDeclaration) { - declaration.checkPhase(FirResolvePhase.SUPER_TYPES) - when (declaration) { + override fun checkIsResolved(resolvable: FirElementWithResolvePhase) { + resolvable.checkPhase(FirResolvePhase.SUPER_TYPES) + when (resolvable) { is FirClass -> { - for (superTypeRef in declaration.superTypeRefs) { - checkTypeRefIsResolved(superTypeRef, "class super type", declaration) + for (superTypeRef in resolvable.superTypeRefs) { + checkTypeRefIsResolved(superTypeRef, "class super type", resolvable) } } is FirTypeAlias -> { - checkTypeRefIsResolved(declaration.expandedTypeRef, typeRefName = "type alias expanded type", declaration) + checkTypeRefIsResolved(resolvable.expandedTypeRef, typeRefName = "type alias expanded type", resolvable) } else -> {} } - checkNestedDeclarationsAreResolved(declaration) + checkNestedDeclarationsAreResolved(resolvable) } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedTypeResolverTransformer.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedTypeResolverTransformer.kt index bc90d0d580a..bc82a0dfcf5 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedTypeResolverTransformer.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedTypeResolverTransformer.kt @@ -6,10 +6,11 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep import org.jetbrains.kotlin.analysis.low.level.api.fir.util.* import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.ScopeSession @@ -19,7 +20,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.FirTypeResolveTransformer * Transform designation into TYPES phase. Affects only for designation, target declaration and it's children */ internal class LLFirDesignatedTypeResolverTransformer( - private val designation: FirDeclarationDesignationWithFile, + private val designation: FirDesignationWithFile, session: FirSession, scopeSession: ScopeSession, ) : LLFirLazyTransformer, FirTypeResolveTransformer(session, scopeSession) { @@ -38,37 +39,37 @@ internal class LLFirDesignatedTypeResolverTransformer( } override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { - if (designation.declaration.resolvePhase >= FirResolvePhase.TYPES) return - designation.declaration.checkPhase(FirResolvePhase.SUPER_TYPES) + if (designation.target.resolvePhase >= FirResolvePhase.TYPES) return + designation.target.checkPhase(FirResolvePhase.SUPER_TYPES) phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.TYPES) { designation.firFile.transform(this, null) } declarationTransformer.ensureDesignationPassed() - updatePhaseDeep(designation.declaration, FirResolvePhase.TYPES) + updatePhaseDeep(designation.target, FirResolvePhase.TYPES) - checkIsResolved(designation.declaration) - checkClassMembersAreResolved(designation.declaration) + checkIsResolved(designation.target) + (designation.target as? FirDeclaration)?.let { checkClassMembersAreResolved(it) } } - override fun checkIsResolved(declaration: FirDeclaration) { - declaration.checkPhase(FirResolvePhase.TYPES) - when (declaration) { + override fun checkIsResolved(resolvable: FirElementWithResolvePhase) { + resolvable.checkPhase(FirResolvePhase.TYPES) + when (resolvable) { is FirCallableDeclaration -> { - checkReturnTypeRefIsResolved(declaration, acceptImplicitTypeRef = true) - checkReceiverTypeRefIsResolved(declaration) + checkReturnTypeRefIsResolved(resolvable, acceptImplicitTypeRef = true) + checkReceiverTypeRefIsResolved(resolvable) } is FirTypeParameter -> { - for (bound in declaration.bounds) { - checkTypeRefIsResolved(bound, "type parameter bound", declaration) + for (bound in resolvable.bounds) { + checkTypeRefIsResolved(bound, "type parameter bound", resolvable) } } else -> {} } - checkNestedDeclarationsAreResolved(declaration) - checkTypeParametersAreResolved(declaration) + checkNestedDeclarationsAreResolved(resolvable) + (resolvable as? FirDeclaration)?.let { checkTypeParametersAreResolved(it) } } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirFileAnnotationsResolveTransformer.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirFileAnnotationsResolveTransformer.kt index ae4ada2ce0f..8c90ada5ebd 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirFileAnnotationsResolveTransformer.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirFileAnnotationsResolveTransformer.kt @@ -14,6 +14,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.ImplicitBodyRe import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTypeCalculatorForIDE import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase internal class LLFirFileAnnotationsResolveTransformer( private val firFile: FirFile, @@ -55,5 +56,5 @@ internal class LLFirFileAnnotationsResolveTransformer( } } - override fun checkIsResolved(declaration: FirDeclaration) = error("Not implemented") + override fun checkIsResolved(resolvable: FirElementWithResolvePhase) = error("Not implemented") } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyTransformer.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyTransformer.kt index b2d1565cc07..5d748f32498 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyTransformer.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyTransformer.kt @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers import org.jetbrains.annotations.TestOnly import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor import org.jetbrains.kotlin.fir.visitors.FirVisitor @@ -15,12 +16,13 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor internal interface LLFirLazyTransformer { fun transformDeclaration(phaseRunner: LLFirPhaseRunner) - fun checkIsResolved(declaration: FirDeclaration) + fun checkIsResolved(resolvable: FirElementWithResolvePhase) - fun checkNestedDeclarationsAreResolved(declaration: FirDeclaration) { - checkFunctionParametersAreResolved(declaration) - checkPropertyAccessorsAreResolved(declaration) - checkClassMembersAreResolved(declaration) + fun checkNestedDeclarationsAreResolved(resolvable: FirElementWithResolvePhase) { + if (resolvable !is FirDeclaration) return + checkFunctionParametersAreResolved(resolvable) + checkPropertyAccessorsAreResolved(resolvable) + checkClassMembersAreResolved(resolvable) } fun checkClassMembersAreResolved(declaration: FirDeclaration) { @@ -69,7 +71,7 @@ internal interface LLFirLazyTransformer { } } - private fun updatePhaseForNonLocals(element: FirDeclaration, newPhase: FirResolvePhase) { + private fun updatePhaseForNonLocals(element: FirElementWithResolvePhase, newPhase: FirResolvePhase) { if (element.resolvePhase >= newPhase) return element.replaceResolvePhase(newPhase) @@ -99,7 +101,7 @@ internal interface LLFirLazyTransformer { } } - fun updatePhaseDeep(element: FirDeclaration, newPhase: FirResolvePhase, withNonLocalDeclarations: Boolean = false) { + fun updatePhaseDeep(element: FirElementWithResolvePhase, newPhase: FirResolvePhase, withNonLocalDeclarations: Boolean = false) { if (withNonLocalDeclarations) { WholeTreePhaseUpdater.visitElement(element, newPhase) } else { @@ -112,7 +114,7 @@ internal interface LLFirLazyTransformer { val DUMMY = object : LLFirLazyTransformer { override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) = Unit - override fun checkIsResolved(declaration: FirDeclaration) = error("Not implemented") + override fun checkIsResolved(resolvable: FirElementWithResolvePhase) = error("Not implemented") } } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyTransformerExecutor.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyTransformerExecutor.kt index bf6ccda170c..0b27bc6610d 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyTransformerExecutor.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyTransformerExecutor.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.resolve.ScopeSession @@ -17,7 +17,7 @@ internal class LLFirLazyTransformerExecutor { companion object { fun execute( phase: FirResolvePhase, - designation: FirDeclarationDesignationWithFile, + designation: FirDesignationWithFile, scopeSession: ScopeSession, phaseRunner: LLFirPhaseRunner, lockProvider: LLFirLockProvider, diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LazyTransformerFactory.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LazyTransformerFactory.kt index 247ec213785..2b985bb9cfd 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LazyTransformerFactory.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LazyTransformerFactory.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignationWithFile +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignationWithFile import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirLockProvider import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.resolve.ScopeSession @@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataCo internal object LazyTransformerFactory { fun createLazyTransformer( phase: FirResolvePhase, - designation: FirDeclarationDesignationWithFile, + designation: FirDesignationWithFile, scopeSession: ScopeSession, lockProvider: LLFirLockProvider, towerDataContextCollector: FirTowerDataContextCollector?, diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/contrainingFileUtils.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/contrainingFileUtils.kt index 751cb8fc8db..32df6c5e7b5 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/contrainingFileUtils.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/contrainingFileUtils.kt @@ -5,16 +5,18 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.util +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase +import org.jetbrains.kotlin.fir.FirFileAnnotationsContainer import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration -import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.resolve.providers.firProvider -fun FirDeclaration.getContainingFile(): FirFile? { +fun FirElementWithResolvePhase.getContainingFile(): FirFile? { val provider = moduleData.session.firProvider return when (this) { is FirFile -> this + is FirFileAnnotationsContainer -> containingFileSymbol.fir is FirCallableDeclaration -> provider.getFirCallableContainerFile(symbol) is FirClassLikeDeclaration -> provider.getFirClassifierContainerFile(symbol) else -> errorWithFirSpecificEntries("Unsupported declaration ${this::class.java}", fir = this) diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/firCheckResolvedUtils.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/firCheckResolvedUtils.kt index a6dab4add2f..140b0f56528 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/firCheckResolvedUtils.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/firCheckResolvedUtils.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.util import org.jetbrains.kotlin.analysis.utils.errors.ExceptionAttachmentBuilder import org.jetbrains.kotlin.analysis.utils.errors.checkWithAttachmentBuilder +import org.jetbrains.kotlin.fir.FirAnnotationContainer import org.jetbrains.kotlin.fir.contracts.FirResolvedContractDescription import org.jetbrains.kotlin.fir.contracts.impl.FirEmptyContractDescription import org.jetbrains.kotlin.fir.declarations.* @@ -73,7 +74,7 @@ internal fun checkDeclarationStatusIsResolved(declaration: FirMemberDeclaration) internal inline fun checkAnnotationArgumentsMappingIsResolved( annotation: FirAnnotationCall, - owner: FirDeclaration, + owner: FirAnnotationContainer, extraAttachment: ExceptionAttachmentBuilder.() -> Unit = {} ) { checkWithAttachmentBuilder( @@ -81,7 +82,7 @@ internal inline fun checkAnnotationArgumentsMappingIsResolved( message = { buildString { append("Expected ${FirResolvedArgumentList::class.simpleName}") - append(" for ${annotation::class.simpleName} of ${owner::class.simpleName}(${owner.origin})") + append(" for ${annotation::class.simpleName} of ${owner::class.simpleName}(${(owner as? FirDeclaration)?.origin})") append(" but ${annotation.argumentList::class.simpleName} found") } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/firDeclarationDesignationUtils.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/firDeclarationDesignationUtils.kt index f3ed0640e4b..a83cd7dccf5 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/firDeclarationDesignationUtils.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/firDeclarationDesignationUtils.kt @@ -5,14 +5,15 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.util -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignation import org.jetbrains.kotlin.analysis.utils.errors.checkWithAttachmentBuilder +import org.jetbrains.kotlin.fir.FirElementWithResolvePhase import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirResolvePhase -internal fun FirDeclaration.checkPhase(requiredResolvePhase: FirResolvePhase) { +internal fun FirElementWithResolvePhase.checkPhase(requiredResolvePhase: FirResolvePhase) { val declarationResolvePhase = resolvePhase checkWithAttachmentBuilder( declarationResolvePhase >= requiredResolvePhase, @@ -22,24 +23,24 @@ internal fun FirDeclaration.checkPhase(requiredResolvePhase: FirResolvePhase) { } } -internal fun FirDeclarationDesignation.checkPathPhase(firResolvePhase: FirResolvePhase) = +internal fun FirDesignation.checkPathPhase(firResolvePhase: FirResolvePhase) = path.forEach { it.checkPhase(firResolvePhase) } -internal fun FirDeclarationDesignation.checkDesignationPhase(firResolvePhase: FirResolvePhase) { +internal fun FirDesignation.checkDesignationPhase(firResolvePhase: FirResolvePhase) { checkPathPhase(firResolvePhase) - declaration.checkPhase(firResolvePhase) + target.checkPhase(firResolvePhase) } -internal fun FirDeclarationDesignation.checkDesignationPhaseForClasses(firResolvePhase: FirResolvePhase) { +internal fun FirDesignation.checkDesignationPhaseForClasses(firResolvePhase: FirResolvePhase) { checkPathPhase(firResolvePhase) - if (declaration is FirClassLikeDeclaration) { - check(declaration.resolvePhase >= firResolvePhase) { - "Expected $firResolvePhase but found ${declaration.resolvePhase}" + if (target is FirClassLikeDeclaration) { + check(target.resolvePhase >= firResolvePhase) { + "Expected $firResolvePhase but found ${target.resolvePhase}" } } } -internal fun FirDeclarationDesignation.isTargetCallableDeclarationAndInPhase(firResolvePhase: FirResolvePhase): Boolean = - (declaration as? FirCallableDeclaration)?.let { it.resolvePhase >= firResolvePhase } ?: false +internal fun FirDesignation.isTargetCallableDeclarationAndInPhase(firResolvePhase: FirResolvePhase): Boolean = + (target as? FirCallableDeclaration)?.let { it.resolvePhase >= firResolvePhase } ?: false -internal fun FirDeclarationDesignation.targetContainingDeclaration(): FirDeclaration? = path.lastOrNull() +internal fun FirDesignation.targetContainingDeclaration(): FirDeclaration? = path.lastOrNull() diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractPartialRawFirBuilderTestCase.kt b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractPartialRawFirBuilderTestCase.kt index 5fdefc134b4..c53b911d189 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractPartialRawFirBuilderTestCase.kt +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractPartialRawFirBuilderTestCase.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir import junit.framework.TestCase -import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation +import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDesignation import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.RawFirNonLocalDeclarationBuilder import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.AbstractLowLevelApiSingleFileTest import org.jetbrains.kotlin.fir.FirElement @@ -59,7 +59,7 @@ abstract class AbstractPartialRawFirBuilderTestCase : AbstractLowLevelApiSingleF private class DesignationBuilder(private val elementToBuild: KtDeclaration) : FirVisitorVoid() { private val path = mutableListOf() - var resultDesignation: FirDeclarationDesignation? = null + var resultDesignation: FirDesignation? = null private set override fun visitElement(element: FirElement) { @@ -68,7 +68,7 @@ abstract class AbstractPartialRawFirBuilderTestCase : AbstractLowLevelApiSingleF is FirSimpleFunction, is FirProperty -> { if (element.psi == elementToBuild) { val originalDeclaration = element as FirDeclaration - resultDesignation = FirDeclarationDesignation(path, originalDeclaration) + resultDesignation = FirDesignation(path, originalDeclaration) } else { element.acceptChildren(this) }