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