azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[LL FIR] rework FirDeclarationDesignation, so it can work with FirElementWithResolvePhase as a target

Browse Source
This commit is contained in:
Ilya Kirillov
2022-12-07 17:42:25 +01:00
committed by teamcity
parent b962fcddc8
commit 3ad2b8a209
32 changed files with 319 additions and 285 deletions
Download Patch File Download Diff File Expand all files Collapse all files
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirVisibilityChecker.kt
+1 -1
View File
@@ -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.KtFirAnalysisSession
import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirFileSymbol 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.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.lifetime.KtLifetimeToken
import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
import org.jetbrains.kotlin.analysis.api.symbols.KtFileSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtFileSymbol
@@ -84,6 +83,7 @@ internal class KtFirVisibilityChecker(
return designation return designation
.toSequence(includeTarget = true) // we include the starting declaration in case it is a class or an object .toSequence(includeTarget = true) // we include the starting declaration in case it is a class or an object
.filterIsInstance<FirDeclaration>()
.toList() .toList()
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/FirDesignationState.kt
+10 -10
View File
@@ -5,16 +5,16 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir 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.FirDesignation
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation
import org.jetbrains.kotlin.analysis.low.level.api.fir.util.errorWithFirSpecificEntries import org.jetbrains.kotlin.analysis.low.level.api.fir.util.errorWithFirSpecificEntries
import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
abstract class ContextByDesignationCollector<C : Any>(private val designation: FirDeclarationDesignation) { abstract class ContextByDesignationCollector<C : Any>(private val designation: FirDesignation) {
private var context: C? = null private var context: C? = null
private val designationState = FirDesignationState(designation) private val designationState = FirDesignationState(designation)
protected abstract fun getCurrentContext(): C protected abstract fun getCurrentContext(): C
protected abstract fun goToNestedDeclaration(declaration: FirDeclaration) protected abstract fun goToNestedDeclaration(target: FirElementWithResolvePhase)
fun getCollectedContext(): C { fun getCollectedContext(): C {
return context return context
@@ -24,20 +24,20 @@ abstract class ContextByDesignationCollector<C : Any>(private val designation: F
fun nextStep() { fun nextStep() {
if (designationState.canGoNext()) { if (designationState.canGoNext()) {
designationState.goNext() designationState.goNext()
if (designationState.currentDeclarationIfPresent == designation.declaration) { if (designationState.currentDeclarationIfPresent == designation.target) {
check(context == null) check(context == null)
context = getCurrentContext() context = getCurrentContext()
} }
goToNestedDeclaration(designationState.currentDeclaration) goToNestedDeclaration(designationState.currentDeclaration)
} else { } else {
if (designationState.currentDeclarationIfPresent == designation.declaration) { if (designationState.currentDeclarationIfPresent == designation.target) {
designationState.goToInnerDeclaration() designationState.goToInnerDeclaration()
} }
} }
} }
} }
private class FirDesignationState(val designation: FirDeclarationDesignation) { private class FirDesignationState(val designation: FirDesignation) {
/** /**
* Holds current declaration index * Holds current declaration index
* if `currentIndex in [0, designation.path.lastIndex]` then current declaration is in path * 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 fun canGoNext(): Boolean = currentIndex < designation.path.size
val currentDeclarationIfPresent: FirDeclaration? val currentDeclarationIfPresent: FirElementWithResolvePhase?
get() = when (currentIndex) { get() = when (currentIndex) {
in designation.path.indices -> designation.path[currentIndex] in designation.path.indices -> designation.path[currentIndex]
designation.path.size -> designation.declaration designation.path.size -> designation.target
else -> null else -> null
} }
val currentDeclaration: FirDeclaration val currentDeclaration: FirElementWithResolvePhase
get() = currentDeclarationIfPresent get() = currentDeclarationIfPresent
?: errorWithFirSpecificEntries("Went inside target declaration") ?: errorWithFirSpecificEntries("Went inside target declaration")
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/FirDeclarationDesignation.kt → analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/FirDesignation.kt
+49 -37
View File
@@ -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.getContainingFile
import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withFirEntry 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.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.FirSession
import org.jetbrains.kotlin.fir.containingClassLookupTag import org.jetbrains.kotlin.fir.containingClassLookupTag
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.utils.classId import org.jetbrains.kotlin.fir.declarations.utils.classId
import org.jetbrains.kotlin.fir.declarations.utils.isLocal 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.resolve.providers.firProvider
import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLookupTagWithFixedSymbol 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<FirDeclaration>, path: List<FirDeclaration>,
declaration: FirDeclaration, target: FirElementWithResolvePhase,
val firFile: FirFile val firFile: FirFile
) : FirDeclarationDesignation( ) : FirDesignation(
path, path,
declaration, target,
) { ) {
fun toSequenceWithFile(includeTarget: Boolean): Sequence<FirDeclaration> = sequence { fun toSequenceWithFile(includeTarget: Boolean): Sequence<FirElementWithResolvePhase> = sequence {
yield(firFile) yield(firFile)
yieldAll(path) yieldAll(path)
if (includeTarget) yield(declaration) if (includeTarget) yield(target)
} }
} }
open class FirDeclarationDesignation( open class FirDesignation(
val path: List<FirDeclaration>, val path: List<FirDeclaration>,
val declaration: FirDeclaration, val target: FirElementWithResolvePhase,
) { ) {
fun toSequence(includeTarget: Boolean): Sequence<FirDeclaration> = sequence { fun toSequence(includeTarget: Boolean): Sequence<FirElementWithResolvePhase> = sequence {
yieldAll(path) yieldAll(path)
if (includeTarget) yield(declaration) if (includeTarget) yield(target)
} }
} }
@@ -59,19 +62,19 @@ private fun FirRegularClass.collectForNonLocal(): List<FirDeclaration> {
return designation return designation
} }
private fun collectDesignationPath(declaration: FirDeclaration): List<FirDeclaration>? { private fun collectDesignationPath(resolvable: FirElementWithResolvePhase): List<FirDeclaration>? {
val containingClass = when (declaration) { val containingClass = when (resolvable) {
is FirCallableDeclaration -> { is FirCallableDeclaration -> {
if (declaration !is FirConstructor && declaration.symbol.callableId.isLocal) return null if (resolvable !is FirConstructor && resolvable.symbol.callableId.isLocal) return null
if ((declaration as? FirCallableDeclaration)?.status?.visibility == Visibilities.Local) return null if ((resolvable as? FirCallableDeclaration)?.status?.visibility == Visibilities.Local) return null
when (declaration) { when (resolvable) {
is FirSimpleFunction, is FirProperty, is FirField, is FirConstructor, is FirEnumEntry, is FirPropertyAccessor -> { 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 if (klass.classId.isLocal) return null
klass.toFirRegularClassFromSameSession(declaration.moduleData.session) klass.toFirRegularClassFromSameSession(resolvable.moduleData.session)
} }
is FirErrorProperty -> { is FirErrorProperty -> {
return if (declaration.diagnostic == ConeDestructuringDeclarationsOnTopLevel) { return if (resolvable.diagnostic == ConeDestructuringDeclarationsOnTopLevel) {
emptyList() emptyList()
} else { } else {
null null
@@ -81,10 +84,10 @@ private fun collectDesignationPath(declaration: FirDeclaration): List<FirDeclara
} }
} }
is FirClassLikeDeclaration -> { is FirClassLikeDeclaration -> {
if (declaration.isLocal) return null if (resolvable.isLocal) return null
val outerClassId = declaration.symbol.classId.outerClassId val outerClassId = resolvable.symbol.classId.outerClassId
outerClassId?.let(declaration.moduleData.session.firProvider::getFirClassifierByFqName) outerClassId?.let(resolvable.moduleData.session.firProvider::getFirClassifierByFqName)
?: outerClassId?.let(declaration.moduleData.session.javaSymbolProvider::getClassLikeSymbolByClassId)?.fir ?: outerClassId?.let(resolvable.moduleData.session.javaSymbolProvider::getClassLikeSymbolByClassId)?.fir
} }
else -> return null else -> return null
} ?: return emptyList() } ?: return emptyList()
@@ -100,35 +103,44 @@ private fun ConeClassLikeLookupTag.toFirRegularClassFromSameSession(useSiteSessi
return useSiteSession.firProvider.getFirClassifierByFqName(classId) as? FirRegularClass 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") { tryCollectDesignation(firFile) ?: buildErrorWithAttachment("No designation of local declaration") {
withFirEntry("firFile", firFile) withFirEntry("firFile", firFile)
} }
fun FirDeclaration.collectDesignation(): FirDeclarationDesignation = fun FirElementWithResolvePhase.collectDesignation(): FirDesignation =
tryCollectDesignation() tryCollectDesignation()
?: buildErrorWithAttachment("No designation of local declaration") { ?: buildErrorWithAttachment("No designation of local declaration") {
withFirEntry("FirDeclaration", this@collectDesignation) withFirEntry("FirDeclaration", this@collectDesignation)
} }
fun FirDeclaration.collectDesignationWithFile(): FirDeclarationDesignationWithFile = fun FirElementWithResolvePhase.collectDesignationWithFile(): FirDesignationWithFile =
tryCollectDesignationWithFile() tryCollectDesignationWithFile()
?: buildErrorWithAttachment("No designation of local declaration") { ?: buildErrorWithAttachment("No designation of local declaration") {
withFirEntry("FirDeclaration", this@collectDesignationWithFile) withFirEntry("FirDeclaration", this@collectDesignationWithFile)
} }
fun FirDeclaration.tryCollectDesignation(firFile: FirFile): FirDeclarationDesignationWithFile? = fun FirElementWithResolvePhase.tryCollectDesignation(firFile: FirFile): FirDesignationWithFile? =
collectDesignationPath(this)?.let { collectDesignationPath(this)?.let {
FirDeclarationDesignationWithFile(it, this, firFile) FirDesignationWithFile(it, this, firFile)
} }
fun FirDeclaration.tryCollectDesignation(): FirDeclarationDesignation? = fun FirElementWithResolvePhase.tryCollectDesignation(): FirDesignation? =
collectDesignationPath(this)?.let { collectDesignationPath(this)?.let {
FirDeclarationDesignation(it, this) FirDesignation(it, this)
} }
fun FirDeclaration.tryCollectDesignationWithFile(): FirDeclarationDesignationWithFile? { fun FirElementWithResolvePhase.tryCollectDesignationWithFile(): FirDesignationWithFile? {
val path = collectDesignationPath(this) ?: return null return when (this) {
val firFile = getContainingFile() ?: return null is FirDeclaration -> {
return FirDeclarationDesignationWithFile(path, this, firFile) 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<FirElementWithResolvePhase>(this)
}
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/LowLevelFirApiFacadeForResolveOnAir.kt
+12 -9
View File
@@ -8,20 +8,25 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.api
import com.intellij.psi.util.PsiTreeUtil 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.DeclarationCopyBuilder.withBodyFrom
import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveSessionDepended 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.FileTowerProvider
import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirTowerContextProvider 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.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.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.FirElementsRecorder
import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.KtToFirMapping 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.LLFirResolvableModuleSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirResolvableSession 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.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.errorWithFirSpecificEntries
import org.jetbrains.kotlin.analysis.low.level.api.fir.util.originalDeclaration import org.jetbrains.kotlin.analysis.low.level.api.fir.util.originalDeclaration
import org.jetbrains.kotlin.analysis.project.structure.getKtModule 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.getElementTextInContext
import org.jetbrains.kotlin.analysis.utils.printer.parentOfType import org.jetbrains.kotlin.analysis.utils.printer.parentOfType
import org.jetbrains.kotlin.analysis.utils.printer.parentsOfType 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.resolve.transformers.body.resolve.FirTowerDataContextCollector
import org.jetbrains.kotlin.fir.scopes.createImportingScopes import org.jetbrains.kotlin.fir.scopes.createImportingScopes
import org.jetbrains.kotlin.fir.scopes.kotlinScopeProvider 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.types.FirResolvedTypeRef
import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
import org.jetbrains.kotlin.psi.* 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.containingClassOrObject
import org.jetbrains.kotlin.psi.psiUtil.isAncestor
import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
object LowLevelFirApiFacadeForResolveOnAir { object LowLevelFirApiFacadeForResolveOnAir {
@@ -254,12 +257,12 @@ object LowLevelFirApiFacadeForResolveOnAir {
} }
} else newDeclarationWithReplacement } else newDeclarationWithReplacement
val onAirDesignation = FirDeclarationDesignationWithFile( val onAirDesignation = FirDesignationWithFile(
path = originalDesignation.path, path = originalDesignation.path,
declaration = copiedFirDeclaration, target = copiedFirDeclaration,
firFile = originalFirFile firFile = originalFirFile
) )
val resolvableSession = onAirDesignation.declaration.llFirResolvableSession val resolvableSession = onAirDesignation.target.llFirResolvableSession
?: error("Expected resolvable session") ?: error("Expected resolvable session")
resolvableSession.moduleComponents.firModuleLazyDeclarationResolver resolvableSession.moduleComponents.firModuleLazyDeclarationResolver
.runLazyDesignatedOnAirResolveToBodyWithoutLock( .runLazyDesignatedOnAirResolveToBodyWithoutLock(
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostics/fir/ContextCollectingDiagnosticCollectorVisitor.kt
+8 -7
View File
@@ -5,7 +5,11 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.fir 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.FirElement
import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollectorVisitor import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollectorVisitor
import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration 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.declarations.FirFile
import org.jetbrains.kotlin.fir.renderWithType import org.jetbrains.kotlin.fir.renderWithType
import org.jetbrains.kotlin.fir.resolve.SessionHolder 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( private class ContextCollectingDiagnosticCollectorVisitor private constructor(
sessionHolder: SessionHolder, sessionHolder: SessionHolder,
designation: FirDeclarationDesignationWithFile, designation: FirDesignationWithFile,
) : AbstractDiagnosticCollectorVisitor( ) : AbstractDiagnosticCollectorVisitor(
PersistentCheckerContextFactory.createEmptyPersistenceCheckerContext(sessionHolder) PersistentCheckerContextFactory.createEmptyPersistenceCheckerContext(sessionHolder)
) { ) {
private val contextCollector = object : ContextByDesignationCollector<CheckerContext>(designation) { private val contextCollector = object : ContextByDesignationCollector<CheckerContext>(designation) {
override fun getCurrentContext(): CheckerContext = context override fun getCurrentContext(): CheckerContext = context
override fun goToNestedDeclaration(declaration: FirDeclaration) { override fun goToNestedDeclaration(target: FirElementWithResolvePhase) {
declaration.accept(this@ContextCollectingDiagnosticCollectorVisitor, null) target.accept(this@ContextCollectingDiagnosticCollectorVisitor, null)
} }
} }
@@ -43,7 +44,7 @@ private class ContextCollectingDiagnosticCollectorVisitor private constructor(
override fun checkElement(element: FirElement) {} override fun checkElement(element: FirElement) {}
companion object { companion object {
fun collect(sessionHolder: SessionHolder, designation: FirDeclarationDesignationWithFile): CheckerContext { fun collect(sessionHolder: SessionHolder, designation: FirDesignationWithFile): CheckerContext {
val visitor = ContextCollectingDiagnosticCollectorVisitor(sessionHolder, designation) val visitor = ContextCollectingDiagnosticCollectorVisitor(sessionHolder, designation)
designation.firFile.accept(visitor, null) designation.firFile.accept(visitor, null)
return visitor.contextCollector.getCollectedContext() return visitor.contextCollector.getCollectedContext()
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/LLFirDesignatedBodyResolveTransformerForReturnTypeCalculator.kt
+3 -3
View File
@@ -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.symbols.lazyResolveToPhase
import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef 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 import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.FirLazyBodiesCalculator
fun LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator( fun LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator(
@@ -60,14 +60,14 @@ private class LLFirDesignatedBodyResolveTransformerForReturnTypeCalculatorImpl(
) { ) {
private val targetDeclaration = designation.last() private val targetDeclaration = designation.last()
private inline fun <D : FirCallableDeclaration> D.processCallable(body: (FirDeclarationDesignation) -> Unit) { private inline fun <D : FirCallableDeclaration> D.processCallable(body: (FirDesignation) -> Unit) {
if (this !== targetDeclaration) return if (this !== targetDeclaration) return
if (resolvePhase < FirResolvePhase.TYPES && returnTypeRef is FirResolvedTypeRef) return if (resolvePhase < FirResolvePhase.TYPES && returnTypeRef is FirResolvedTypeRef) return
lazyResolveToPhase(FirResolvePhase.TYPES) lazyResolveToPhase(FirResolvePhase.TYPES)
if (returnTypeRef is FirImplicitTypeRef) { if (returnTypeRef is FirImplicitTypeRef) {
val declarationList = designation.filterIsInstance<FirDeclaration>() val declarationList = designation.filterIsInstance<FirDeclaration>()
check(declarationList.isNotEmpty()) { "Invalid empty declaration designation" } check(declarationList.isNotEmpty()) { "Invalid empty declaration designation" }
body(FirDeclarationDesignation(declarationList.dropLast(1), this)) body(FirDesignation(declarationList.dropLast(1), this))
} }
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/FirLazyBodiesCalculator.kt
+19 -20
View File
@@ -8,10 +8,9 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve
import kotlinx.collections.immutable.PersistentList import kotlinx.collections.immutable.PersistentList
import kotlinx.collections.immutable.persistentListOf import kotlinx.collections.immutable.persistentListOf
import kotlinx.collections.immutable.toPersistentList 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.FirElement
import org.jetbrains.kotlin.fir.declarations.* 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.declarations.utils.getExplicitBackingField
import org.jetbrains.kotlin.fir.expressions.FirFunctionCall import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.expressions.FirStatement
@@ -26,10 +25,10 @@ import org.jetbrains.kotlin.fir.visitors.transformSingle
import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.*
internal object FirLazyBodiesCalculator { internal object FirLazyBodiesCalculator {
fun calculateLazyBodiesInside(designation: FirDeclarationDesignation) { fun calculateLazyBodiesInside(designation: FirDesignation) {
designation.declaration.transform<FirElement, PersistentList<FirDeclaration>>( designation.target.transform<FirElement, PersistentList<FirDeclaration>>(
FirLazyBodiesCalculatorTransformer, FirLazyBodiesCalculatorTransformer,
designation.toSequence(includeTarget = false).toList().toPersistentList() designation.path.toPersistentList(),
) )
} }
@@ -46,8 +45,8 @@ internal object FirLazyBodiesCalculator {
} }
} }
fun calculateLazyBodiesForFunction(designation: FirDeclarationDesignation) { fun calculateLazyBodiesForFunction(designation: FirDesignation) {
val simpleFunction = designation.declaration as FirSimpleFunction val simpleFunction = designation.target as FirSimpleFunction
require(needCalculatingLazyBodyForFunction(simpleFunction)) require(needCalculatingLazyBodyForFunction(simpleFunction))
val newFunction = RawFirNonLocalDeclarationBuilder.buildWithFunctionSymbolRebind( val newFunction = RawFirNonLocalDeclarationBuilder.buildWithFunctionSymbolRebind(
session = simpleFunction.moduleData.session, session = simpleFunction.moduleData.session,
@@ -62,8 +61,8 @@ internal object FirLazyBodiesCalculator {
} }
} }
fun calculateLazyBodyForConstructor(designation: FirDeclarationDesignation) { fun calculateLazyBodyForConstructor(designation: FirDesignation) {
val constructor = designation.declaration as FirConstructor val constructor = designation.target as FirConstructor
require(constructor.psi is KtConstructor<*>) require(constructor.psi is KtConstructor<*>)
require(needCalculatingLazyBodyForConstructor(constructor)) require(needCalculatingLazyBodyForConstructor(constructor))
@@ -81,8 +80,8 @@ internal object FirLazyBodiesCalculator {
} }
} }
fun calculateLazyBodyForProperty(designation: FirDeclarationDesignation) { fun calculateLazyBodyForProperty(designation: FirDesignation) {
val firProperty = designation.declaration as FirProperty val firProperty = designation.target as FirProperty
if (!needCalculatingLazyBodyForProperty(firProperty)) return if (!needCalculatingLazyBodyForProperty(firProperty)) return
val newProperty = RawFirNonLocalDeclarationBuilder.buildWithFunctionSymbolRebind( val newProperty = RawFirNonLocalDeclarationBuilder.buildWithFunctionSymbolRebind(
@@ -130,8 +129,8 @@ internal object FirLazyBodiesCalculator {
} }
} }
fun calculateLazyInitializerForEnumEntry(designation: FirDeclarationDesignation) { fun calculateLazyInitializerForEnumEntry(designation: FirDesignation) {
val enumEntry = designation.declaration as FirEnumEntry val enumEntry = designation.target as FirEnumEntry
require(enumEntry.initializer is FirLazyExpression) require(enumEntry.initializer is FirLazyExpression)
val newEntry = RawFirNonLocalDeclarationBuilder.buildWithFunctionSymbolRebind( val newEntry = RawFirNonLocalDeclarationBuilder.buildWithFunctionSymbolRebind(
session = enumEntry.moduleData.session, session = enumEntry.moduleData.session,
@@ -144,8 +143,8 @@ internal object FirLazyBodiesCalculator {
} }
} }
fun calculateLazyBodyForAnonymousInitializer(designation: FirDeclarationDesignation) { fun calculateLazyBodyForAnonymousInitializer(designation: FirDesignation) {
val initializer = designation.declaration as FirAnonymousInitializer val initializer = designation.target as FirAnonymousInitializer
require(initializer.body is FirLazyBlock) require(initializer.body is FirLazyBlock)
val newInitializer = RawFirNonLocalDeclarationBuilder.buildWithFunctionSymbolRebind( val newInitializer = RawFirNonLocalDeclarationBuilder.buildWithFunctionSymbolRebind(
session = initializer.moduleData.session, session = initializer.moduleData.session,
@@ -197,7 +196,7 @@ private object FirLazyBodiesCalculatorTransformer : FirTransformer<PersistentLis
data: PersistentList<FirDeclaration> data: PersistentList<FirDeclaration>
): FirSimpleFunction { ): FirSimpleFunction {
if (FirLazyBodiesCalculator.needCalculatingLazyBodyForFunction(simpleFunction)) { if (FirLazyBodiesCalculator.needCalculatingLazyBodyForFunction(simpleFunction)) {
val designation = FirDeclarationDesignation(data, simpleFunction) val designation = FirDesignation(data, simpleFunction)
FirLazyBodiesCalculator.calculateLazyBodiesForFunction(designation) FirLazyBodiesCalculator.calculateLazyBodiesForFunction(designation)
} }
return simpleFunction return simpleFunction
@@ -208,7 +207,7 @@ private object FirLazyBodiesCalculatorTransformer : FirTransformer<PersistentLis
data: PersistentList<FirDeclaration> data: PersistentList<FirDeclaration>
): FirConstructor { ): FirConstructor {
if (FirLazyBodiesCalculator.needCalculatingLazyBodyForConstructor(constructor)) { if (FirLazyBodiesCalculator.needCalculatingLazyBodyForConstructor(constructor)) {
val designation = FirDeclarationDesignation(data, constructor) val designation = FirDesignation(data, constructor)
FirLazyBodiesCalculator.calculateLazyBodyForConstructor(designation) FirLazyBodiesCalculator.calculateLazyBodyForConstructor(designation)
} }
return constructor return constructor
@@ -216,7 +215,7 @@ private object FirLazyBodiesCalculatorTransformer : FirTransformer<PersistentLis
override fun transformProperty(property: FirProperty, data: PersistentList<FirDeclaration>): FirProperty { override fun transformProperty(property: FirProperty, data: PersistentList<FirDeclaration>): FirProperty {
if (FirLazyBodiesCalculator.needCalculatingLazyBodyForProperty(property)) { if (FirLazyBodiesCalculator.needCalculatingLazyBodyForProperty(property)) {
val designation = FirDeclarationDesignation(data, property) val designation = FirDesignation(data, property)
FirLazyBodiesCalculator.calculateLazyBodyForProperty(designation) FirLazyBodiesCalculator.calculateLazyBodyForProperty(designation)
} }
return property return property
@@ -228,7 +227,7 @@ private object FirLazyBodiesCalculatorTransformer : FirTransformer<PersistentLis
override fun transformEnumEntry(enumEntry: FirEnumEntry, data: PersistentList<FirDeclaration>): FirStatement { override fun transformEnumEntry(enumEntry: FirEnumEntry, data: PersistentList<FirDeclaration>): FirStatement {
if (enumEntry.initializer is FirLazyExpression) { if (enumEntry.initializer is FirLazyExpression) {
val designation = FirDeclarationDesignation(data, enumEntry) val designation = FirDesignation(data, enumEntry)
FirLazyBodiesCalculator.calculateLazyInitializerForEnumEntry(designation) FirLazyBodiesCalculator.calculateLazyInitializerForEnumEntry(designation)
} }
return enumEntry return enumEntry
@@ -238,7 +237,7 @@ private object FirLazyBodiesCalculatorTransformer : FirTransformer<PersistentLis
anonymousInitializer: FirAnonymousInitializer, data: PersistentList<FirDeclaration> anonymousInitializer: FirAnonymousInitializer, data: PersistentList<FirDeclaration>
): FirAnonymousInitializer { ): FirAnonymousInitializer {
if (anonymousInitializer.body is FirLazyBlock) { if (anonymousInitializer.body is FirLazyBlock) {
val designation = FirDeclarationDesignation(data, anonymousInitializer) val designation = FirDesignation(data, anonymousInitializer)
FirLazyBodiesCalculator.calculateLazyBodyForAnonymousInitializer(designation) FirLazyBodiesCalculator.calculateLazyBodyForAnonymousInitializer(designation)
} }
return anonymousInitializer return anonymousInitializer
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/LLFirModuleLazyDeclarationResolver.kt
+11 -11
View File
@@ -6,7 +6,7 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve 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.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.collectDesignationWithFile
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.tryCollectDesignationWithFile import org.jetbrains.kotlin.analysis.low.level.api.fir.api.tryCollectDesignationWithFile
import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.getNonLocalContainingOrThisDeclaration 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 if (validForResolveDeclarations.isEmpty()) return
val designations = validForResolveDeclarations.map { val designations = validForResolveDeclarations.map {
FirDeclarationDesignationWithFile(path = emptyList(), declaration = it, firFile = firFile) FirDesignationWithFile(path = emptyList(), target = it, firFile = firFile)
} }
var currentPhase = FirResolvePhase.IMPORTS var currentPhase = FirResolvePhase.IMPORTS
@@ -189,7 +189,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
if (checkPCE) checkCanceled() if (checkPCE) checkCanceled()
val transformersToApply = designations.filter { designation -> val transformersToApply = designations.filter { designation ->
designation.declaration.resolvePhase < currentPhase designation.target.resolvePhase < currentPhase
} }
if (transformersToApply.isEmpty()) continue if (transformersToApply.isEmpty()) continue
@@ -283,7 +283,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
val requestedDeclarationDesignation = firDeclarationToResolve.tryCollectDesignationWithFile() val requestedDeclarationDesignation = firDeclarationToResolve.tryCollectDesignationWithFile()
val designation: FirDeclarationDesignationWithFile val designation: FirDesignationWithFile
val neededPhase: FirResolvePhase val neededPhase: FirResolvePhase
if (requestedDeclarationDesignation != null) { if (requestedDeclarationDesignation != null) {
@@ -322,7 +322,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
designation = declarationToResolve.collectDesignationWithFile() designation = declarationToResolve.collectDesignationWithFile()
} }
if (designation.declaration.resolvePhase >= neededPhase) return if (designation.target.resolvePhase >= neededPhase) return
if (neededPhase == FirResolvePhase.IMPORTS) { if (neededPhase == FirResolvePhase.IMPORTS) {
resolveFileToImports(designation.firFile, checkPCE) resolveFileToImports(designation.firFile, checkPCE)
@@ -336,13 +336,13 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
toPhase = neededPhase, toPhase = neededPhase,
checkPCE = checkPCE, checkPCE = checkPCE,
) )
designation.declaration designation.target
} }
} }
private fun runLazyDesignatedResolveWithoutLock( private fun runLazyDesignatedResolveWithoutLock(
designation: FirDeclarationDesignationWithFile, designation: FirDesignationWithFile,
scopeSession: ScopeSession, scopeSession: ScopeSession,
toPhase: FirResolvePhase, toPhase: FirResolvePhase,
checkPCE: Boolean, checkPCE: Boolean,
@@ -351,7 +351,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
resolveFileToImportsWithoutLock(designation.firFile, checkPCE) resolveFileToImportsWithoutLock(designation.firFile, checkPCE)
if (toPhase == FirResolvePhase.IMPORTS) return if (toPhase == FirResolvePhase.IMPORTS) return
val declarationResolvePhase = designation.declaration.resolvePhase val declarationResolvePhase = designation.target.resolvePhase
if (declarationResolvePhase >= toPhase) return if (declarationResolvePhase >= toPhase) return
var currentPhase = maxOf(declarationResolvePhase, FirResolvePhase.IMPORTS) var currentPhase = maxOf(declarationResolvePhase, FirResolvePhase.IMPORTS)
@@ -374,13 +374,13 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
} }
internal fun runLazyDesignatedOnAirResolveToBodyWithoutLock( internal fun runLazyDesignatedOnAirResolveToBodyWithoutLock(
designation: FirDeclarationDesignationWithFile, designation: FirDesignationWithFile,
checkPCE: Boolean, checkPCE: Boolean,
onAirCreatedDeclaration: Boolean, onAirCreatedDeclaration: Boolean,
towerDataContextCollector: FirTowerDataContextCollector?, towerDataContextCollector: FirTowerDataContextCollector?,
) { ) {
resolveFileToImportsWithoutLock(designation.firFile, checkPCE) resolveFileToImportsWithoutLock(designation.firFile, checkPCE)
var currentPhase = maxOf(designation.declaration.resolvePhase, FirResolvePhase.IMPORTS) var currentPhase = maxOf(designation.target.resolvePhase, FirResolvePhase.IMPORTS)
val scopeSession = ScopeSession() val scopeSession = ScopeSession()
@@ -388,7 +388,7 @@ internal class LLFirModuleLazyDeclarationResolver(val moduleComponents: LLFirMod
LLFirFirProviderInterceptor.createForFirElement( LLFirFirProviderInterceptor.createForFirElement(
session = designation.firFile.moduleData.session, session = designation.firFile.moduleData.session,
firFile = designation.firFile, firFile = designation.firFile,
element = designation.declaration element = designation.target
) )
} else null } else null
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/RawFirNonLocalDeclarationBuilder.kt
+8 -7
View File
@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.KtSourceElement 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.buildErrorWithAttachment
import org.jetbrains.kotlin.analysis.utils.errors.withPsiEntry import org.jetbrains.kotlin.analysis.utils.errors.withPsiEntry
import org.jetbrains.kotlin.fir.* 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.scopes.FirScopeProvider
import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol 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.* import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.psi.psiUtil.hasExpectModifier import org.jetbrains.kotlin.psi.psiUtil.hasExpectModifier
@@ -38,7 +39,7 @@ internal class RawFirNonLocalDeclarationBuilder private constructor(
fun buildWithReplacement( fun buildWithReplacement(
session: FirSession, session: FirSession,
scopeProvider: FirScopeProvider, scopeProvider: FirScopeProvider,
designation: FirDeclarationDesignation, designation: FirDesignation,
rootNonLocalDeclaration: KtDeclaration, rootNonLocalDeclaration: KtDeclaration,
replacement: RawFirReplacement? replacement: RawFirReplacement?
): FirDeclaration { ): FirDeclaration {
@@ -46,7 +47,7 @@ internal class RawFirNonLocalDeclarationBuilder private constructor(
val builder = RawFirNonLocalDeclarationBuilder( val builder = RawFirNonLocalDeclarationBuilder(
session = session, session = session,
baseScopeProvider = scopeProvider, baseScopeProvider = scopeProvider,
originalDeclaration = designation.declaration, originalDeclaration = designation.target as FirDeclaration,
declarationToBuild = rootNonLocalDeclaration, declarationToBuild = rootNonLocalDeclaration,
replacementApplier = replacementApplier replacementApplier = replacementApplier
) )
@@ -59,10 +60,10 @@ internal class RawFirNonLocalDeclarationBuilder private constructor(
fun buildWithFunctionSymbolRebind( fun buildWithFunctionSymbolRebind(
session: FirSession, session: FirSession,
scopeProvider: FirScopeProvider, scopeProvider: FirScopeProvider,
designation: FirDeclarationDesignation, designation: FirDesignation,
rootNonLocalDeclaration: KtDeclaration, rootNonLocalDeclaration: KtDeclaration,
): FirDeclaration { ): FirDeclaration {
val functionsToRebind = when (val originalDeclaration = designation.declaration) { val functionsToRebind = when (val originalDeclaration = designation.target) {
is FirFunction -> setOf(originalDeclaration) is FirFunction -> setOf(originalDeclaration)
is FirProperty -> setOfNotNull(originalDeclaration.getter, originalDeclaration.setter) is FirProperty -> setOfNotNull(originalDeclaration.getter, originalDeclaration.setter)
else -> null else -> null
@@ -71,7 +72,7 @@ internal class RawFirNonLocalDeclarationBuilder private constructor(
val builder = RawFirNonLocalDeclarationBuilder( val builder = RawFirNonLocalDeclarationBuilder(
session = session, session = session,
baseScopeProvider = scopeProvider, baseScopeProvider = scopeProvider,
originalDeclaration = designation.declaration, originalDeclaration = designation.target as FirDeclaration,
declarationToBuild = rootNonLocalDeclaration, declarationToBuild = rootNonLocalDeclaration,
functionsToRebind = functionsToRebind, functionsToRebind = functionsToRebind,
) )
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/project/structure/LLFirModuleData.kt
+2 -2
View File
@@ -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.analysis.project.structure.KtModule
import org.jetbrains.kotlin.fir.FirModuleData import org.jetbrains.kotlin.fir.FirModuleData
import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.moduleData import org.jetbrains.kotlin.fir.moduleData
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.platform.TargetPlatform import org.jetbrains.kotlin.platform.TargetPlatform
import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
val FirDeclaration.llFirModuleData: LLFirModuleData val FirElementWithResolvePhase.llFirModuleData: LLFirModuleData
get() { get() {
return moduleData as LLFirModuleData return moduleData as LLFirModuleData
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirResolvableModuleSession.kt
+2 -5
View File
@@ -6,12 +6,9 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.sessions 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.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.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.ScopeSession
import org.jetbrains.kotlin.fir.resolve.providers.firProvider
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
abstract class LLFirResolvableModuleSession( abstract class LLFirResolvableModuleSession(
@@ -24,7 +21,7 @@ abstract class LLFirResolvableModuleSession(
} }
} }
internal val FirDeclaration.llFirResolvableSession: LLFirResolvableModuleSession? internal val FirElementWithResolvePhase.llFirResolvableSession: LLFirResolvableModuleSession?
get() = llFirSession as? LLFirResolvableModuleSession get() = llFirSession as? LLFirResolvableModuleSession
internal val FirBasedSymbol<*>.llFirResolvableSession: LLFirResolvableModuleSession? internal val FirBasedSymbol<*>.llFirResolvableSession: LLFirResolvableModuleSession?
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/sessions/LLFirSession.kt
+2 -2
View File
@@ -8,9 +8,9 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.sessions
import com.intellij.openapi.project.Project import com.intellij.openapi.project.Project
import org.jetbrains.kotlin.analysis.project.structure.KtModule import org.jetbrains.kotlin.analysis.project.structure.KtModule
import org.jetbrains.kotlin.fir.BuiltinTypes import org.jetbrains.kotlin.fir.BuiltinTypes
import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.PrivateSessionConstructor 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.resolve.ScopeSession
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol 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) abstract class LLFirModuleSession(builtinTypes: BuiltinTypes, kind: Kind) : LLFirSession(builtinTypes, kind)
val FirDeclaration.llFirSession: LLFirSession val FirElementWithResolvePhase.llFirSession: LLFirSession
get() = moduleData.session as LLFirSession get() = moduleData.session as LLFirSession
val FirBasedSymbol<*>.llFirSession: LLFirSession val FirBasedSymbol<*>.llFirSession: LLFirSession
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDeclarationTransformer.kt
+6 -5
View File
@@ -5,14 +5,15 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers 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.FirElement
import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.render
import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer import org.jetbrains.kotlin.fir.visitors.FirDefaultTransformer
import org.jetbrains.kotlin.fir.visitors.FirVisitor 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 val designationWithoutTargetIterator = designation.toSequence(includeTarget = false).iterator()
private var isInsideTargetDeclaration: Boolean = false private var isInsideTargetDeclaration: Boolean = false
private var designationPassed: Boolean = false private var designationPassed: Boolean = false
@@ -42,7 +43,7 @@ internal class LLFirDeclarationTransformer(private val designation: FirDeclarati
private inline fun processDeclarationContent( private inline fun processDeclarationContent(
declaration: FirDeclaration, declaration: FirDeclaration,
default: () -> FirDeclaration, default: () -> FirDeclaration,
applyToDesignated: (FirDeclaration) -> Unit, applyToDesignated: (FirElementWithResolvePhase) -> Unit,
): FirDeclaration { ): FirDeclaration {
//It means that we are inside the target declaration //It means that we are inside the target declaration
if (isInsideTargetDeclaration) { if (isInsideTargetDeclaration) {
@@ -60,7 +61,7 @@ internal class LLFirDeclarationTransformer(private val designation: FirDeclarati
try { try {
isInsideTargetDeclaration = true isInsideTargetDeclaration = true
designationPassed = true designationPassed = true
applyToDesignated(designation.declaration) applyToDesignated(designation.target)
} finally { } finally {
isInsideTargetDeclaration = false isInsideTargetDeclaration = false
} }
@@ -70,6 +71,6 @@ internal class LLFirDeclarationTransformer(private val designation: FirDeclarati
} }
fun ensureDesignationPassed() { fun ensureDesignationPassed() {
check(designationPassed) { "Designation not passed for declaration ${designation.declaration::class.simpleName}" } check(designationPassed) { "Designation not passed for declaration ${designation.target::class.simpleName}" }
} }
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationArgumentsMappingTransformer.kt
+14 -11
View File
@@ -6,10 +6,12 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers 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.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.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.checkAnnotationArgumentsMappingIsResolved
import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase 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.FirSession
import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.FirFile 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 * Transform designation into ANNOTATIONS_ARGUMENTS_MAPPING declaration. Affects only for target declaration, it's children and dependents
*/ */
internal class LLFirDesignatedAnnotationArgumentsMappingTransformer( internal class LLFirDesignatedAnnotationArgumentsMappingTransformer(
private val designation: FirDeclarationDesignationWithFile, private val designation: FirDesignationWithFile,
session: FirSession, session: FirSession,
scopeSession: ScopeSession, scopeSession: ScopeSession,
) : LLFirLazyTransformer, FirAnnotationArgumentsMappingTransformer(session, scopeSession, FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) { ) : LLFirLazyTransformer, FirAnnotationArgumentsMappingTransformer(session, scopeSession, FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) {
@@ -35,24 +37,25 @@ internal class LLFirDesignatedAnnotationArgumentsMappingTransformer(
} }
override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
if (designation.declaration.resolvePhase >= FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) return if (designation.target.resolvePhase >= FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) return
designation.declaration.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) designation.target.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) { phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) {
designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent) designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent)
} }
updatePhaseDeep(designation.declaration, FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) updatePhaseDeep(designation.target, FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING)
checkIsResolved(designation.declaration) checkIsResolved(designation.target)
} }
override fun checkIsResolved(declaration: FirDeclaration) { override fun checkIsResolved(resolvable: FirElementWithResolvePhase) {
declaration.checkPhase(FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING) resolvable.checkPhase(FirResolvePhase.ANNOTATIONS_ARGUMENTS_MAPPING)
for (annotation in declaration.annotations) { if (resolvable !is FirAnnotationContainer) return
for (annotation in resolvable.annotations) {
if (annotation is FirAnnotationCall) { if (annotation is FirAnnotationCall) {
checkAnnotationArgumentsMappingIsResolved(annotation, declaration) checkAnnotationArgumentsMappingIsResolved(annotation, resolvable)
} }
} }
checkNestedDeclarationsAreResolved(declaration) checkNestedDeclarationsAreResolved(resolvable)
} }
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationArgumentsResolveTransformer.kt
+16 -14
View File
@@ -6,10 +6,11 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers 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.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.checkPhase
import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkTypeRefIsResolved 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.analysis.low.level.api.fir.util.withFirEntry
import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.resolve.ResolutionMode 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 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
internal class LLFirDesignatedAnnotationArgumentsResolveTransformer( internal class LLFirDesignatedAnnotationArgumentsResolveTransformer(
private val designation: FirDeclarationDesignationWithFile, private val designation: FirDesignationWithFile,
session: FirSession, session: FirSession,
scopeSession: ScopeSession, scopeSession: ScopeSession,
) : LLFirLazyTransformer, FirAnnotationArgumentsResolveTransformer(session, scopeSession, FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) { ) : LLFirLazyTransformer, FirAnnotationArgumentsResolveTransformer(session, scopeSession, FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) {
private fun moveNextDeclaration(designationIterator: Iterator<FirDeclaration>) { private fun moveNextDeclaration(designationIterator: Iterator<FirElementWithResolvePhase>) {
if (!designationIterator.hasNext()) { if (!designationIterator.hasNext()) {
designation.declaration.transform<FirDeclaration, ResolutionMode>(declarationsTransformer, ResolutionMode.ContextIndependent) designation.target.transform<FirDeclaration, ResolutionMode>(declarationsTransformer, ResolutionMode.ContextIndependent)
return return
} }
when (val nextElement = designationIterator.next()) { when (val nextElement = designationIterator.next()) {
@@ -51,8 +52,8 @@ internal class LLFirDesignatedAnnotationArgumentsResolveTransformer(
} }
override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
if (designation.declaration.resolvePhase >= FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) return if (designation.target.resolvePhase >= FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) return
designation.declaration.checkPhase(FirResolvePhase.STATUS) designation.target.checkPhase(FirResolvePhase.STATUS)
val designationIterator = designation.toSequenceWithFile(includeTarget = false).iterator() val designationIterator = designation.toSequenceWithFile(includeTarget = false).iterator()
@@ -61,26 +62,27 @@ internal class LLFirDesignatedAnnotationArgumentsResolveTransformer(
} }
LLFirLazyTransformer.updatePhaseDeep(designation.declaration, FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) LLFirLazyTransformer.updatePhaseDeep(designation.target, FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)
checkIsResolved(designation.declaration) checkIsResolved(designation.target)
} }
override fun checkIsResolved(declaration: FirDeclaration) { override fun checkIsResolved(resolvable: FirElementWithResolvePhase) {
val unresolvedAnnotation = declaration.annotations.firstOrNull { it.annotationTypeRef !is FirResolvedTypeRef } if (resolvable !is FirDeclaration) return
val unresolvedAnnotation = resolvable.annotations.firstOrNull { it.annotationTypeRef !is FirResolvedTypeRef }
check(unresolvedAnnotation == null) { check(unresolvedAnnotation == null) {
"Unexpected annotationTypeRef annotation, expected resolvedType but actual ${unresolvedAnnotation?.annotationTypeRef}" "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) { for (argument in annotation.argumentMapping.mapping.values) {
checkTypeRefIsResolved(argument.typeRef, "annotation argument", declaration) { checkTypeRefIsResolved(argument.typeRef, "annotation argument", resolvable) {
withFirEntry("firAnnotation", annotation) withFirEntry("firAnnotation", annotation)
withFirEntry("firArgument", argument) withFirEntry("firArgument", argument)
} }
} }
} }
checkNestedDeclarationsAreResolved(declaration) checkNestedDeclarationsAreResolved(resolvable)
} }
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedAnnotationsResolveTransformed.kt
+10 -9
View File
@@ -6,8 +6,9 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers 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.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.checkPhase
import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.resolve.ScopeSession 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 import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirCompilerRequiredAnnotationsResolveTransformer
internal class LLFirDesignatedAnnotationsResolveTransformed( internal class LLFirDesignatedAnnotationsResolveTransformed(
private val designation: FirDeclarationDesignationWithFile, private val designation: FirDesignationWithFile,
session: FirSession, session: FirSession,
scopeSession: ScopeSession, scopeSession: ScopeSession,
) : LLFirLazyTransformer, FirCompilerRequiredAnnotationsResolveTransformer(session, scopeSession, CompilerRequiredAnnotationsComputationSession()) { ) : LLFirLazyTransformer, FirCompilerRequiredAnnotationsResolveTransformer(session, scopeSession, CompilerRequiredAnnotationsComputationSession()) {
private fun moveNextDeclaration(designationIterator: Iterator<FirDeclaration>) { private fun moveNextDeclaration(designationIterator: Iterator<FirElementWithResolvePhase>) {
if (!designationIterator.hasNext()) { if (!designationIterator.hasNext()) {
val declaration = designation.declaration val declaration = designation.target
if (declaration is FirRegularClass || declaration is FirTypeAlias) { if (declaration is FirRegularClass || declaration is FirTypeAlias) {
declaration.transform<FirDeclaration, Nothing?>(this, null) declaration.transform<FirDeclaration, Nothing?>(this, null)
} }
@@ -44,7 +45,7 @@ internal class LLFirDesignatedAnnotationsResolveTransformed(
} }
override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { 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() val designationIterator = designation.toSequenceWithFile(includeTarget = false).iterator()
@@ -52,12 +53,12 @@ internal class LLFirDesignatedAnnotationsResolveTransformed(
moveNextDeclaration(designationIterator) moveNextDeclaration(designationIterator)
} }
LLFirLazyTransformer.updatePhaseDeep(designation.declaration, FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) LLFirLazyTransformer.updatePhaseDeep(designation.target, FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS)
checkIsResolved(designation.declaration) checkIsResolved(designation.target)
} }
override fun checkIsResolved(declaration: FirDeclaration) { override fun checkIsResolved(resolvable: FirElementWithResolvePhase) {
declaration.checkPhase(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS) resolvable.checkPhase(FirResolvePhase.COMPILER_REQUIRED_ANNOTATIONS)
// todo add proper check that COMPILER_REQUIRED_ANNOTATIONS are resolved // todo add proper check that COMPILER_REQUIRED_ANNOTATIONS are resolved
// checkNestedDeclarationsAreResolved(declaration) // checkNestedDeclarationsAreResolved(declaration)
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedBodyResolveTransformer.kt
+10 -9
View File
@@ -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.ImplicitBodyResolveComputationSession
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTypeCalculatorForIDE 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.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.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.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.checkPhase
import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
/** /**
* Transform designation into BODY_RESOLVE declaration. Affects only for target declaration and it's children * Transform designation into BODY_RESOLVE declaration. Affects only for target declaration and it's children
*/ */
internal class LLFirDesignatedBodyResolveTransformer( internal class LLFirDesignatedBodyResolveTransformer(
private val designation: FirDeclarationDesignationWithFile, private val designation: FirDesignationWithFile,
session: FirSession, session: FirSession,
scopeSession: ScopeSession, scopeSession: ScopeSession,
towerDataContextCollector: FirTowerDataContextCollector?, towerDataContextCollector: FirTowerDataContextCollector?,
@@ -50,8 +51,8 @@ internal class LLFirDesignatedBodyResolveTransformer(
} }
override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
if (designation.declaration.resolvePhase >= FirResolvePhase.BODY_RESOLVE) return if (designation.target.resolvePhase >= FirResolvePhase.BODY_RESOLVE) return
designation.declaration.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) designation.target.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.BODY_RESOLVE) { phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.BODY_RESOLVE) {
designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent) designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent)
@@ -59,13 +60,13 @@ internal class LLFirDesignatedBodyResolveTransformer(
ideDeclarationTransformer.ensureDesignationPassed() ideDeclarationTransformer.ensureDesignationPassed()
updatePhaseDeep(designation.declaration, FirResolvePhase.BODY_RESOLVE, withNonLocalDeclarations = true) updatePhaseDeep(designation.target, FirResolvePhase.BODY_RESOLVE, withNonLocalDeclarations = true)
checkIsResolved(designation.declaration) checkIsResolved(designation.target)
} }
override fun checkIsResolved(declaration: FirDeclaration) { override fun checkIsResolved(resolvable: FirElementWithResolvePhase) {
declaration.checkPhase(FirResolvePhase.BODY_RESOLVE) resolvable.checkPhase(FirResolvePhase.BODY_RESOLVE)
checkNestedDeclarationsAreResolved(declaration) checkNestedDeclarationsAreResolved(resolvable)
} }
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedContractsResolveTransformer.kt
+11 -11
View File
@@ -9,19 +9,19 @@ import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.resolve.ResolutionMode import org.jetbrains.kotlin.fir.resolve.ResolutionMode
import org.jetbrains.kotlin.fir.resolve.ScopeSession 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.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.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.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.checkPhase
import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
import org.jetbrains.kotlin.fir.resolve.transformers.contracts.FirAbstractContractResolveTransformerDispatcher import org.jetbrains.kotlin.fir.resolve.transformers.contracts.FirAbstractContractResolveTransformerDispatcher
/** /**
* Transform designation into CONTRACTS declaration. Affects only for target declaration and it's children * Transform designation into CONTRACTS declaration. Affects only for target declaration and it's children
*/ */
internal class LLFirDesignatedContractsResolveTransformer( internal class LLFirDesignatedContractsResolveTransformer(
private val designation: FirDeclarationDesignationWithFile, private val designation: FirDesignationWithFile,
session: FirSession, session: FirSession,
scopeSession: ScopeSession, scopeSession: ScopeSession,
) : LLFirLazyTransformer, FirAbstractContractResolveTransformerDispatcher(session, scopeSession) { ) : LLFirLazyTransformer, FirAbstractContractResolveTransformerDispatcher(session, scopeSession) {
@@ -44,8 +44,8 @@ internal class LLFirDesignatedContractsResolveTransformer(
} }
override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
if (designation.declaration.resolvePhase >= FirResolvePhase.CONTRACTS) return if (designation.target.resolvePhase >= FirResolvePhase.CONTRACTS) return
designation.declaration.checkPhase(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS) designation.target.checkPhase(FirResolvePhase.ARGUMENTS_OF_ANNOTATIONS)
FirLazyBodiesCalculator.calculateLazyBodiesInside(designation) FirLazyBodiesCalculator.calculateLazyBodiesInside(designation)
phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.CONTRACTS) { phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.CONTRACTS) {
@@ -53,15 +53,15 @@ internal class LLFirDesignatedContractsResolveTransformer(
} }
ideDeclarationTransformer.ensureDesignationPassed() ideDeclarationTransformer.ensureDesignationPassed()
updatePhaseDeep(designation.declaration, FirResolvePhase.CONTRACTS) updatePhaseDeep(designation.target, FirResolvePhase.CONTRACTS)
checkIsResolved(designation.declaration) checkIsResolved(designation.target)
} }
override fun checkIsResolved(declaration: FirDeclaration) { override fun checkIsResolved(resolvable: FirElementWithResolvePhase) {
declaration.checkPhase(FirResolvePhase.CONTRACTS) resolvable.checkPhase(FirResolvePhase.CONTRACTS)
if (declaration is FirContractDescriptionOwner) { if (resolvable is FirContractDescriptionOwner) {
// TODO checkContractDescriptionIsResolved(declaration) // TODO checkContractDescriptionIsResolved(declaration)
} }
checkNestedDeclarationsAreResolved(declaration) checkNestedDeclarationsAreResolved(resolvable)
} }
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedExpectActualMatcherTransformer.kt
+10 -9
View File
@@ -6,10 +6,11 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers 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.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.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.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.checkPhase
import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.expressions.FirStatement 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 import org.jetbrains.kotlin.fir.resolve.transformers.mpp.FirExpectActualMatcherTransformer
internal class LLFirDesignatedExpectActualMatcherTransformer( internal class LLFirDesignatedExpectActualMatcherTransformer(
private val designation: FirDeclarationDesignationWithFile, private val designation: FirDesignationWithFile,
session: FirSession, session: FirSession,
scopeSession: ScopeSession, scopeSession: ScopeSession,
) : LLFirLazyTransformer, FirExpectActualMatcherTransformer(session, scopeSession) { ) : LLFirLazyTransformer, FirExpectActualMatcherTransformer(session, scopeSession) {
@@ -37,8 +38,8 @@ internal class LLFirDesignatedExpectActualMatcherTransformer(
} }
override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
if (designation.declaration.resolvePhase >= FirResolvePhase.EXPECT_ACTUAL_MATCHING) return if (designation.target.resolvePhase >= FirResolvePhase.EXPECT_ACTUAL_MATCHING) return
designation.declaration.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) designation.target.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
FirLazyBodiesCalculator.calculateLazyBodiesInside(designation) FirLazyBodiesCalculator.calculateLazyBodiesInside(designation)
phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.EXPECT_ACTUAL_MATCHING) { phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.EXPECT_ACTUAL_MATCHING) {
@@ -47,14 +48,14 @@ internal class LLFirDesignatedExpectActualMatcherTransformer(
declarationTransformer.ensureDesignationPassed() declarationTransformer.ensureDesignationPassed()
updatePhaseDeep(designation.declaration, FirResolvePhase.EXPECT_ACTUAL_MATCHING) updatePhaseDeep(designation.target, FirResolvePhase.EXPECT_ACTUAL_MATCHING)
checkIsResolved(designation.declaration) checkIsResolved(designation.target)
} }
override fun checkIsResolved(declaration: FirDeclaration) { override fun checkIsResolved(resolvable: FirElementWithResolvePhase) {
declaration.checkPhase(FirResolvePhase.EXPECT_ACTUAL_MATCHING) resolvable.checkPhase(FirResolvePhase.EXPECT_ACTUAL_MATCHING)
// TODO check if expect-actual matching is present // TODO check if expect-actual matching is present
checkNestedDeclarationsAreResolved(declaration) checkNestedDeclarationsAreResolved(resolvable)
} }
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedGeneratedCompanionObjectResolveTransformer.kt
+9 -8
View File
@@ -6,30 +6,31 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers 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.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.FirSession
import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirCompanionGenerationTransformer import org.jetbrains.kotlin.fir.resolve.transformers.plugin.FirCompanionGenerationTransformer
internal class LLFirDesignatedGeneratedCompanionObjectResolveTransformer( internal class LLFirDesignatedGeneratedCompanionObjectResolveTransformer(
val designation: FirDeclarationDesignationWithFile, val designation: FirDesignationWithFile,
session: FirSession session: FirSession
) : LLFirLazyTransformer { ) : LLFirLazyTransformer {
private val transformer: FirCompanionGenerationTransformer = FirCompanionGenerationTransformer(session) private val transformer: FirCompanionGenerationTransformer = FirCompanionGenerationTransformer(session)
override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { 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) { phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.COMPANION_GENERATION) {
designation.declaration.transform<FirDeclaration, Nothing?>(transformer, null) designation.target.transform<FirDeclaration, Nothing?>(transformer, null)
} }
LLFirLazyTransformer.updatePhaseDeep(designation.declaration, FirResolvePhase.COMPANION_GENERATION) LLFirLazyTransformer.updatePhaseDeep(designation.target, FirResolvePhase.COMPANION_GENERATION)
checkIsResolved(designation.declaration) checkIsResolved(designation.target)
} }
override fun checkIsResolved(declaration: FirDeclaration) { override fun checkIsResolved(resolvable: FirElementWithResolvePhase) {
check(declaration.resolvePhase >= FirResolvePhase.COMPANION_GENERATION) check(resolvable.resolvePhase >= FirResolvePhase.COMPANION_GENERATION)
} }
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedImplicitTypesTransformer.kt
+12 -11
View File
@@ -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.ImplicitBodyResolveComputationSession
import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.createReturnTypeCalculatorForIDE 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.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.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.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.checkPhase
import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkReturnTypeRefIsResolved 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 * Transform designation into IMPLICIT_TYPES_BODY_RESOLVE declaration. Affects only for target declaration, it's children and dependents
*/ */
internal class LLFirDesignatedImplicitTypesTransformer( internal class LLFirDesignatedImplicitTypesTransformer(
private val designation: FirDeclarationDesignationWithFile, private val designation: FirDesignationWithFile,
session: FirSession, session: FirSession,
scopeSession: ScopeSession, scopeSession: ScopeSession,
towerDataContextCollector: FirTowerDataContextCollector?, towerDataContextCollector: FirTowerDataContextCollector?,
@@ -50,8 +51,8 @@ internal class LLFirDesignatedImplicitTypesTransformer(
} }
override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
if (designation.declaration.resolvePhase >= FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) return if (designation.target.resolvePhase >= FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) return
designation.declaration.checkPhase(FirResolvePhase.CONTRACTS) designation.target.checkPhase(FirResolvePhase.CONTRACTS)
phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) {
designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent) designation.firFile.transform<FirFile, ResolutionMode>(this, ResolutionMode.ContextIndependent)
@@ -59,15 +60,15 @@ internal class LLFirDesignatedImplicitTypesTransformer(
ideDeclarationTransformer.ensureDesignationPassed() ideDeclarationTransformer.ensureDesignationPassed()
updatePhaseDeep(designation.declaration, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) updatePhaseDeep(designation.target, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
checkIsResolved(designation.declaration) checkIsResolved(designation.target)
} }
override fun checkIsResolved(declaration: FirDeclaration) { override fun checkIsResolved(resolvable: FirElementWithResolvePhase) {
declaration.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) resolvable.checkPhase(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
if (declaration is FirCallableDeclaration) { if (resolvable is FirCallableDeclaration) {
checkReturnTypeRefIsResolved(declaration) checkReturnTypeRefIsResolved(resolvable)
} }
checkNestedDeclarationsAreResolved(declaration) checkNestedDeclarationsAreResolved(resolvable)
} }
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedStatusResolveTransformer.kt
+13 -12
View File
@@ -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.FirStatusResolveTransformer
import org.jetbrains.kotlin.fir.resolve.transformers.StatusComputationSession 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.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.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.checkDeclarationStatusIsResolved
import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkPhase 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 * Transform designation into STATUS phase. Affects only for designation, target declaration, it's children and dependents
*/ */
internal class LLFirDesignatedStatusResolveTransformer( internal class LLFirDesignatedStatusResolveTransformer(
private val designation: FirDeclarationDesignationWithFile, private val designation: FirDesignationWithFile,
private val session: FirSession, private val session: FirSession,
private val scopeSession: ScopeSession, private val scopeSession: ScopeSession,
) : LLFirLazyTransformer { ) : LLFirLazyTransformer {
@@ -37,8 +38,8 @@ internal class LLFirDesignatedStatusResolveTransformer(
} }
override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
if (designation.declaration.resolvePhase >= FirResolvePhase.STATUS) return if (designation.target.resolvePhase >= FirResolvePhase.STATUS) return
designation.declaration.checkPhase(FirResolvePhase.TYPES) designation.target.checkPhase(FirResolvePhase.TYPES)
val transformer = FirDesignatedStatusResolveTransformerForIDE() val transformer = FirDesignatedStatusResolveTransformerForIDE()
phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.STATUS) { phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.STATUS) {
@@ -46,17 +47,17 @@ internal class LLFirDesignatedStatusResolveTransformer(
} }
transformer.designationTransformer.ensureDesignationPassed() transformer.designationTransformer.ensureDesignationPassed()
updatePhaseDeep(designation.declaration, FirResolvePhase.STATUS) updatePhaseDeep(designation.target, FirResolvePhase.STATUS)
checkIsResolved(designation.declaration) checkIsResolved(designation.target)
} }
override fun checkIsResolved(declaration: FirDeclaration) { override fun checkIsResolved(resolvable: FirElementWithResolvePhase) {
if (declaration !is FirAnonymousInitializer) { if (resolvable !is FirAnonymousInitializer) {
declaration.checkPhase(FirResolvePhase.STATUS) resolvable.checkPhase(FirResolvePhase.STATUS)
} }
if (declaration is FirMemberDeclaration) { if (resolvable is FirMemberDeclaration) {
checkDeclarationStatusIsResolved(declaration) checkDeclarationStatusIsResolved(resolvable)
} }
checkNestedDeclarationsAreResolved(declaration) checkNestedDeclarationsAreResolved(resolvable)
} }
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedSupertypeResolverTransformer.kt
+25 -24
View File
@@ -6,8 +6,8 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers 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.LLFirPhaseRunner
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.api.FirDeclarationDesignationWithFile 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.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.LLFirLockProvider
import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.runCustomResolveUnderLock 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.checkPhase
import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkTypeRefIsResolved import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkTypeRefIsResolved
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass 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 * Transform designation into SUPER_TYPES phase. Affects only for designation, target declaration, it's children and dependents
*/ */
internal class LLFirDesignatedSupertypeResolverTransformer( internal class LLFirDesignatedSupertypeResolverTransformer(
private val designation: FirDeclarationDesignationWithFile, private val designation: FirDesignationWithFile,
private val session: FirSession, private val session: FirSession,
private val scopeSession: ScopeSession, private val scopeSession: ScopeSession,
private val lockProvider: LLFirLockProvider, private val lockProvider: LLFirLockProvider,
@@ -39,7 +40,7 @@ internal class LLFirDesignatedSupertypeResolverTransformer(
private val supertypeComputationSession = SupertypeComputationSession() private val supertypeComputationSession = SupertypeComputationSession()
private inner class DesignatedFirSupertypeResolverVisitor(classDesignation: FirDeclarationDesignation) : private inner class DesignatedFirSupertypeResolverVisitor(classDesignation: FirDesignation) :
FirSupertypeResolverVisitor( FirSupertypeResolverVisitor(
session = session, session = session,
supertypeComputationSession = supertypeComputationSession, 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) { FirApplySupertypesTransformer(supertypeComputationSession, session, scopeSession) {
val declarationTransformer = LLFirDeclarationTransformer(classDesignation) val declarationTransformer = LLFirDeclarationTransformer(classDesignation)
@@ -70,9 +71,9 @@ internal class LLFirDesignatedSupertypeResolverTransformer(
} }
} }
private fun collect(designation: FirDeclarationDesignationWithFile): Collection<FirDeclarationDesignationWithFile> { private fun collect(designation: FirDesignationWithFile): Collection<FirDesignationWithFile> {
val visited = mutableMapOf<FirDeclaration, FirDeclarationDesignationWithFile>() val visited = mutableMapOf<FirElementWithResolvePhase, FirDesignationWithFile>()
val toVisit = mutableListOf<FirDeclarationDesignationWithFile>() val toVisit = mutableListOf<FirDesignationWithFile>()
toVisit.add(designation) toVisit.add(designation)
while (toVisit.isNotEmpty()) { while (toVisit.isNotEmpty()) {
@@ -84,7 +85,7 @@ internal class LLFirDesignatedSupertypeResolverTransformer(
nowVisit.firFile.accept(resolver, null) nowVisit.firFile.accept(resolver, null)
} }
resolver.declarationTransformer.ensureDesignationPassed() resolver.declarationTransformer.ensureDesignationPassed()
visited[nowVisit.declaration] = nowVisit visited[nowVisit.target] = nowVisit
} }
toVisit.clear() toVisit.clear()
@@ -104,8 +105,8 @@ internal class LLFirDesignatedSupertypeResolverTransformer(
return visited.values return visited.values
} }
private fun apply(visited: Collection<FirDeclarationDesignationWithFile>) { private fun apply(visited: Collection<FirDesignationWithFile>) {
fun applyToFileSymbols(designations: List<FirDeclarationDesignationWithFile>) { fun applyToFileSymbols(designations: List<FirDesignationWithFile>) {
for (designation in designations) { for (designation in designations) {
if (checkPCE) checkCanceled() if (checkPCE) checkCanceled()
val applier = DesignatedFirApplySupertypesTransformer(designation) val applier = DesignatedFirApplySupertypesTransformer(designation)
@@ -128,18 +129,18 @@ internal class LLFirDesignatedSupertypeResolverTransformer(
} }
override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { 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) designation.firFile.checkPhase(FirResolvePhase.IMPORTS)
val targetDesignation = if (designation.declaration !is FirClassLikeDeclaration) { val targetDesignation = if (designation.target !is FirClassLikeDeclaration) {
val resolvableTarget = designation.path.lastOrNull() val resolvableTarget = designation.path.lastOrNull()
if (resolvableTarget == null) { if (resolvableTarget == null) {
updatePhaseDeep(designation.declaration, FirResolvePhase.SUPER_TYPES) updatePhaseDeep(designation.target, FirResolvePhase.SUPER_TYPES)
return return
} }
check(resolvableTarget is FirClassLikeDeclaration) check(resolvableTarget is FirClassLikeDeclaration)
val targetPath = designation.path.dropLast(1) val targetPath = designation.path.dropLast(1)
FirDeclarationDesignationWithFile(targetPath, resolvableTarget, designation.firFile) FirDesignationWithFile(targetPath, resolvableTarget, designation.firFile)
} else designation } else designation
phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.SUPER_TYPES) { phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.SUPER_TYPES) {
@@ -148,25 +149,25 @@ internal class LLFirDesignatedSupertypeResolverTransformer(
apply(collected) apply(collected)
} }
updatePhaseDeep(designation.declaration, FirResolvePhase.SUPER_TYPES) updatePhaseDeep(designation.target, FirResolvePhase.SUPER_TYPES)
checkIsResolved(designation.declaration) checkIsResolved(designation.target)
} }
override fun checkIsResolved(declaration: FirDeclaration) { override fun checkIsResolved(resolvable: FirElementWithResolvePhase) {
declaration.checkPhase(FirResolvePhase.SUPER_TYPES) resolvable.checkPhase(FirResolvePhase.SUPER_TYPES)
when (declaration) { when (resolvable) {
is FirClass -> { is FirClass -> {
for (superTypeRef in declaration.superTypeRefs) { for (superTypeRef in resolvable.superTypeRefs) {
checkTypeRefIsResolved(superTypeRef, "class super type", declaration) checkTypeRefIsResolved(superTypeRef, "class super type", resolvable)
} }
} }
is FirTypeAlias -> { is FirTypeAlias -> {
checkTypeRefIsResolved(declaration.expandedTypeRef, typeRefName = "type alias expanded type", declaration) checkTypeRefIsResolved(resolvable.expandedTypeRef, typeRefName = "type alias expanded type", resolvable)
} }
else -> {} else -> {}
} }
checkNestedDeclarationsAreResolved(declaration) checkNestedDeclarationsAreResolved(resolvable)
} }
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirDesignatedTypeResolverTransformer.kt
+17 -16
View File
@@ -6,10 +6,11 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers 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.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.transformers.LLFirLazyTransformer.Companion.updatePhaseDeep
import org.jetbrains.kotlin.analysis.low.level.api.fir.util.* import org.jetbrains.kotlin.analysis.low.level.api.fir.util.*
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.resolve.ScopeSession 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 * Transform designation into TYPES phase. Affects only for designation, target declaration and it's children
*/ */
internal class LLFirDesignatedTypeResolverTransformer( internal class LLFirDesignatedTypeResolverTransformer(
private val designation: FirDeclarationDesignationWithFile, private val designation: FirDesignationWithFile,
session: FirSession, session: FirSession,
scopeSession: ScopeSession, scopeSession: ScopeSession,
) : LLFirLazyTransformer, FirTypeResolveTransformer(session, scopeSession) { ) : LLFirLazyTransformer, FirTypeResolveTransformer(session, scopeSession) {
@@ -38,37 +39,37 @@ internal class LLFirDesignatedTypeResolverTransformer(
} }
override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) { override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) {
if (designation.declaration.resolvePhase >= FirResolvePhase.TYPES) return if (designation.target.resolvePhase >= FirResolvePhase.TYPES) return
designation.declaration.checkPhase(FirResolvePhase.SUPER_TYPES) designation.target.checkPhase(FirResolvePhase.SUPER_TYPES)
phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.TYPES) { phaseRunner.runPhaseWithCustomResolve(FirResolvePhase.TYPES) {
designation.firFile.transform<FirFile, Any?>(this, null) designation.firFile.transform<FirFile, Any?>(this, null)
} }
declarationTransformer.ensureDesignationPassed() declarationTransformer.ensureDesignationPassed()
updatePhaseDeep(designation.declaration, FirResolvePhase.TYPES) updatePhaseDeep(designation.target, FirResolvePhase.TYPES)
checkIsResolved(designation.declaration) checkIsResolved(designation.target)
checkClassMembersAreResolved(designation.declaration) (designation.target as? FirDeclaration)?.let { checkClassMembersAreResolved(it) }
} }
override fun checkIsResolved(declaration: FirDeclaration) { override fun checkIsResolved(resolvable: FirElementWithResolvePhase) {
declaration.checkPhase(FirResolvePhase.TYPES) resolvable.checkPhase(FirResolvePhase.TYPES)
when (declaration) { when (resolvable) {
is FirCallableDeclaration -> { is FirCallableDeclaration -> {
checkReturnTypeRefIsResolved(declaration, acceptImplicitTypeRef = true) checkReturnTypeRefIsResolved(resolvable, acceptImplicitTypeRef = true)
checkReceiverTypeRefIsResolved(declaration) checkReceiverTypeRefIsResolved(resolvable)
} }
is FirTypeParameter -> { is FirTypeParameter -> {
for (bound in declaration.bounds) { for (bound in resolvable.bounds) {
checkTypeRefIsResolved(bound, "type parameter bound", declaration) checkTypeRefIsResolved(bound, "type parameter bound", resolvable)
} }
} }
else -> {} else -> {}
} }
checkNestedDeclarationsAreResolved(declaration) checkNestedDeclarationsAreResolved(resolvable)
checkTypeParametersAreResolved(declaration) (resolvable as? FirDeclaration)?.let { checkTypeParametersAreResolved(it) }
} }
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirFileAnnotationsResolveTransformer.kt
+2 -1
View File
@@ -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.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.LLFirPhaseRunner
import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.LLFirDesignatedImpliciteTypesBodyResolveTransformerForReturnTypeCalculator
import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
internal class LLFirFileAnnotationsResolveTransformer( internal class LLFirFileAnnotationsResolveTransformer(
private val firFile: FirFile, 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")
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyTransformer.kt
+10 -8
View File
@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers
import org.jetbrains.annotations.TestOnly import org.jetbrains.annotations.TestOnly
import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirPhaseRunner
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.fir.visitors.FirVisitor
@@ -15,12 +16,13 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor
internal interface LLFirLazyTransformer { internal interface LLFirLazyTransformer {
fun transformDeclaration(phaseRunner: LLFirPhaseRunner) fun transformDeclaration(phaseRunner: LLFirPhaseRunner)
fun checkIsResolved(declaration: FirDeclaration) fun checkIsResolved(resolvable: FirElementWithResolvePhase)
fun checkNestedDeclarationsAreResolved(declaration: FirDeclaration) { fun checkNestedDeclarationsAreResolved(resolvable: FirElementWithResolvePhase) {
checkFunctionParametersAreResolved(declaration) if (resolvable !is FirDeclaration) return
checkPropertyAccessorsAreResolved(declaration) checkFunctionParametersAreResolved(resolvable)
checkClassMembersAreResolved(declaration) checkPropertyAccessorsAreResolved(resolvable)
checkClassMembersAreResolved(resolvable)
} }
fun checkClassMembersAreResolved(declaration: FirDeclaration) { 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 if (element.resolvePhase >= newPhase) return
element.replaceResolvePhase(newPhase) 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) { if (withNonLocalDeclarations) {
WholeTreePhaseUpdater.visitElement(element, newPhase) WholeTreePhaseUpdater.visitElement(element, newPhase)
} else { } else {
@@ -112,7 +114,7 @@ internal interface LLFirLazyTransformer {
val DUMMY = object : LLFirLazyTransformer { val DUMMY = object : LLFirLazyTransformer {
override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) = Unit override fun transformDeclaration(phaseRunner: LLFirPhaseRunner) = Unit
override fun checkIsResolved(declaration: FirDeclaration) = error("Not implemented") override fun checkIsResolved(resolvable: FirElementWithResolvePhase) = error("Not implemented")
} }
} }
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LLFirLazyTransformerExecutor.kt
+2 -2
View File
@@ -6,7 +6,7 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers 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.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.analysis.low.level.api.fir.file.builder.LLFirLockProvider
import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.ScopeSession
@@ -17,7 +17,7 @@ internal class LLFirLazyTransformerExecutor {
companion object { companion object {
fun execute( fun execute(
phase: FirResolvePhase, phase: FirResolvePhase,
designation: FirDeclarationDesignationWithFile, designation: FirDesignationWithFile,
scopeSession: ScopeSession, scopeSession: ScopeSession,
phaseRunner: LLFirPhaseRunner, phaseRunner: LLFirPhaseRunner,
lockProvider: LLFirLockProvider, lockProvider: LLFirLockProvider,
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/transformers/LazyTransformerFactory.kt
+2 -2
View File
@@ -5,7 +5,7 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.transformers 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.analysis.low.level.api.fir.file.builder.LLFirLockProvider
import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.ScopeSession
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataCo
internal object LazyTransformerFactory { internal object LazyTransformerFactory {
fun createLazyTransformer( fun createLazyTransformer(
phase: FirResolvePhase, phase: FirResolvePhase,
designation: FirDeclarationDesignationWithFile, designation: FirDesignationWithFile,
scopeSession: ScopeSession, scopeSession: ScopeSession,
lockProvider: LLFirLockProvider, lockProvider: LLFirLockProvider,
towerDataContextCollector: FirTowerDataContextCollector?, towerDataContextCollector: FirTowerDataContextCollector?,
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/contrainingFileUtils.kt
+4 -2
View File
@@ -5,16 +5,18 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.util 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.FirCallableDeclaration
import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration 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.declarations.FirFile
import org.jetbrains.kotlin.fir.resolve.providers.firProvider import org.jetbrains.kotlin.fir.resolve.providers.firProvider
fun FirDeclaration.getContainingFile(): FirFile? { fun FirElementWithResolvePhase.getContainingFile(): FirFile? {
val provider = moduleData.session.firProvider val provider = moduleData.session.firProvider
return when (this) { return when (this) {
is FirFile -> this is FirFile -> this
is FirFileAnnotationsContainer -> containingFileSymbol.fir
is FirCallableDeclaration -> provider.getFirCallableContainerFile(symbol) is FirCallableDeclaration -> provider.getFirCallableContainerFile(symbol)
is FirClassLikeDeclaration -> provider.getFirClassifierContainerFile(symbol) is FirClassLikeDeclaration -> provider.getFirClassifierContainerFile(symbol)
else -> errorWithFirSpecificEntries("Unsupported declaration ${this::class.java}", fir = this) else -> errorWithFirSpecificEntries("Unsupported declaration ${this::class.java}", fir = this)
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/firCheckResolvedUtils.kt
+3 -2
View File
@@ -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.ExceptionAttachmentBuilder
import org.jetbrains.kotlin.analysis.utils.errors.checkWithAttachmentBuilder 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.FirResolvedContractDescription
import org.jetbrains.kotlin.fir.contracts.impl.FirEmptyContractDescription import org.jetbrains.kotlin.fir.contracts.impl.FirEmptyContractDescription
import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.*
@@ -73,7 +74,7 @@ internal fun checkDeclarationStatusIsResolved(declaration: FirMemberDeclaration)
internal inline fun checkAnnotationArgumentsMappingIsResolved( internal inline fun checkAnnotationArgumentsMappingIsResolved(
annotation: FirAnnotationCall, annotation: FirAnnotationCall,
owner: FirDeclaration, owner: FirAnnotationContainer,
extraAttachment: ExceptionAttachmentBuilder.() -> Unit = {} extraAttachment: ExceptionAttachmentBuilder.() -> Unit = {}
) { ) {
checkWithAttachmentBuilder( checkWithAttachmentBuilder(
@@ -81,7 +82,7 @@ internal inline fun checkAnnotationArgumentsMappingIsResolved(
message = { message = {
buildString { buildString {
append("Expected ${FirResolvedArgumentList::class.simpleName}") 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") append(" but ${annotation.argumentList::class.simpleName} found")
} }
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/firDeclarationDesignationUtils.kt
+13 -12
View File
@@ -5,14 +5,15 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.util 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.analysis.utils.errors.checkWithAttachmentBuilder
import org.jetbrains.kotlin.fir.FirElementWithResolvePhase
import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
internal fun FirDeclaration.checkPhase(requiredResolvePhase: FirResolvePhase) { internal fun FirElementWithResolvePhase.checkPhase(requiredResolvePhase: FirResolvePhase) {
val declarationResolvePhase = resolvePhase val declarationResolvePhase = resolvePhase
checkWithAttachmentBuilder( checkWithAttachmentBuilder(
declarationResolvePhase >= requiredResolvePhase, 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) } path.forEach { it.checkPhase(firResolvePhase) }
internal fun FirDeclarationDesignation.checkDesignationPhase(firResolvePhase: FirResolvePhase) { internal fun FirDesignation.checkDesignationPhase(firResolvePhase: FirResolvePhase) {
checkPathPhase(firResolvePhase) checkPathPhase(firResolvePhase)
declaration.checkPhase(firResolvePhase) target.checkPhase(firResolvePhase)
} }
internal fun FirDeclarationDesignation.checkDesignationPhaseForClasses(firResolvePhase: FirResolvePhase) { internal fun FirDesignation.checkDesignationPhaseForClasses(firResolvePhase: FirResolvePhase) {
checkPathPhase(firResolvePhase) checkPathPhase(firResolvePhase)
if (declaration is FirClassLikeDeclaration) { if (target is FirClassLikeDeclaration) {
check(declaration.resolvePhase >= firResolvePhase) { check(target.resolvePhase >= firResolvePhase) {
"Expected $firResolvePhase but found ${declaration.resolvePhase}" "Expected $firResolvePhase but found ${target.resolvePhase}"
} }
} }
} }
internal fun FirDeclarationDesignation.isTargetCallableDeclarationAndInPhase(firResolvePhase: FirResolvePhase): Boolean = internal fun FirDesignation.isTargetCallableDeclarationAndInPhase(firResolvePhase: FirResolvePhase): Boolean =
(declaration as? FirCallableDeclaration)?.let { it.resolvePhase >= firResolvePhase } ?: false (target as? FirCallableDeclaration)?.let { it.resolvePhase >= firResolvePhase } ?: false
internal fun FirDeclarationDesignation.targetContainingDeclaration(): FirDeclaration? = path.lastOrNull() internal fun FirDesignation.targetContainingDeclaration(): FirDeclaration? = path.lastOrNull()
analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractPartialRawFirBuilderTestCase.kt
+3 -3
View File
@@ -6,7 +6,7 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir package org.jetbrains.kotlin.analysis.low.level.api.fir
import junit.framework.TestCase 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.lazy.resolve.RawFirNonLocalDeclarationBuilder
import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.AbstractLowLevelApiSingleFileTest import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.AbstractLowLevelApiSingleFileTest
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
@@ -59,7 +59,7 @@ abstract class AbstractPartialRawFirBuilderTestCase : AbstractLowLevelApiSingleF
private class DesignationBuilder(private val elementToBuild: KtDeclaration) : FirVisitorVoid() { private class DesignationBuilder(private val elementToBuild: KtDeclaration) : FirVisitorVoid() {
private val path = mutableListOf<FirDeclaration>() private val path = mutableListOf<FirDeclaration>()
var resultDesignation: FirDeclarationDesignation? = null var resultDesignation: FirDesignation? = null
private set private set
override fun visitElement(element: FirElement) { override fun visitElement(element: FirElement) {
@@ -68,7 +68,7 @@ abstract class AbstractPartialRawFirBuilderTestCase : AbstractLowLevelApiSingleF
is FirSimpleFunction, is FirProperty -> { is FirSimpleFunction, is FirProperty -> {
if (element.psi == elementToBuild) { if (element.psi == elementToBuild) {
val originalDeclaration = element as FirDeclaration val originalDeclaration = element as FirDeclaration
resultDesignation = FirDeclarationDesignation(path, originalDeclaration) resultDesignation = FirDesignation(path, originalDeclaration)
} else { } else {
element.acceptChildren(this) element.acceptChildren(this)
} }