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

[fir low level, refactoring] rename LLFirModuleResolveState -> LLFirResolveSession

Browse Source
This commit is contained in:
Ilya Kirillov
2022-05-04 00:24:17 +02:00
parent 7b70cf3ae0
commit 4ff38c9697
81 changed files with 392 additions and 391 deletions
Download Patch File Download Diff File Expand all files Collapse all files
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtFirAnalysisSession.kt
+18 -18
View File
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbolProvider
import org.jetbrains.kotlin.analysis.api.fir.utils.threadLocal import org.jetbrains.kotlin.analysis.api.fir.utils.threadLocal
import org.jetbrains.kotlin.analysis.api.impl.base.components.KtAnalysisScopeProviderImpl import org.jetbrains.kotlin.analysis.api.impl.base.components.KtAnalysisScopeProviderImpl
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir
import org.jetbrains.kotlin.analysis.project.structure.KtModule import org.jetbrains.kotlin.analysis.project.structure.KtModule
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
@@ -30,13 +30,13 @@ import org.jetbrains.kotlin.psi.KtFile
internal class KtFirAnalysisSession internal class KtFirAnalysisSession
private constructor( private constructor(
private val project: Project, private val project: Project,
val firResolveState: LLFirModuleResolveState, val firResolveSession: LLFirResolveSession,
internal val firSymbolBuilder: KtSymbolByFirBuilder, internal val firSymbolBuilder: KtSymbolByFirBuilder,
token: ValidityToken, token: ValidityToken,
private val mode: AnalysisSessionMode, private val mode: AnalysisSessionMode,
) : KtAnalysisSession(token) { ) : KtAnalysisSession(token) {
override val useSiteModule: KtModule get() = firResolveState.useSiteKtModule override val useSiteModule: KtModule get() = firResolveSession.useSiteKtModule
private enum class AnalysisSessionMode { private enum class AnalysisSessionMode {
REGULAR, REGULAR,
@@ -55,19 +55,19 @@ private constructor(
override val samResolverImpl = KtFirSamResolver(this, token) override val samResolverImpl = KtFirSamResolver(this, token)
override val scopeProviderImpl by threadLocal { KtFirScopeProvider(this, firSymbolBuilder, project, firResolveState, token) } override val scopeProviderImpl by threadLocal { KtFirScopeProvider(this, firSymbolBuilder, project, firResolveSession, token) }
override val symbolProviderImpl = override val symbolProviderImpl =
KtFirSymbolProvider(this, firResolveState.useSiteFirSession.symbolProvider, firResolveState, firSymbolBuilder, token) KtFirSymbolProvider(this, firResolveSession.useSiteFirSession.symbolProvider, firResolveSession, firSymbolBuilder, token)
override val completionCandidateCheckerImpl = KtFirCompletionCandidateChecker(this, token) override val completionCandidateCheckerImpl = KtFirCompletionCandidateChecker(this, token)
override val symbolDeclarationOverridesProviderImpl = override val symbolDeclarationOverridesProviderImpl =
KtFirSymbolDeclarationOverridesProvider(this, token) KtFirSymbolDeclarationOverridesProvider(this, token)
override val referenceShortenerImpl = KtFirReferenceShortener(this, token, firResolveState) override val referenceShortenerImpl = KtFirReferenceShortener(this, token, firResolveSession)
override val importOptimizerImpl: KtImportOptimizer = KtFirImportOptimizer(token, firResolveState) override val importOptimizerImpl: KtImportOptimizer = KtFirImportOptimizer(token, firResolveSession)
override val symbolDeclarationRendererProviderImpl: KtSymbolDeclarationRendererProvider = override val symbolDeclarationRendererProviderImpl: KtSymbolDeclarationRendererProvider =
KtFirSymbolDeclarationRendererProvider(this, token) KtFirSymbolDeclarationRendererProvider(this, token)
@@ -104,42 +104,42 @@ private constructor(
} }
require(!elementToReanalyze.isPhysical) { "Depended context should be build only for non-physical elements" } require(!elementToReanalyze.isPhysical) { "Depended context should be build only for non-physical elements" }
val contextResolveState = LowLevelFirApiFacadeForResolveOnAir.getResolveStateForDependentCopy( val contextFirResolveSession = LowLevelFirApiFacadeForResolveOnAir.getFirResolveSessionForDependentCopy(
originalState = firResolveState, originalFirResolveSession = firResolveSession,
originalKtFile = originalKtFile, originalKtFile = originalKtFile,
elementToAnalyze = elementToReanalyze elementToAnalyze = elementToReanalyze
) )
return KtFirAnalysisSession( return KtFirAnalysisSession(
project, project,
contextResolveState, contextFirResolveSession,
firSymbolBuilder.createReadOnlyCopy(contextResolveState), firSymbolBuilder.createReadOnlyCopy(contextFirResolveSession),
token, token,
AnalysisSessionMode.DEPENDENT_COPY AnalysisSessionMode.DEPENDENT_COPY
) )
} }
val useSiteSession: FirSession get() = firResolveState.useSiteFirSession val useSiteSession: FirSession get() = firResolveSession.useSiteFirSession
val firSymbolProvider: FirSymbolProvider get() = useSiteSession.symbolProvider val firSymbolProvider: FirSymbolProvider get() = useSiteSession.symbolProvider
val targetPlatform: TargetPlatform get() = useSiteSession.moduleData.platform val targetPlatform: TargetPlatform get() = useSiteSession.moduleData.platform
fun getScopeSessionFor(session: FirSession): ScopeSession = firResolveState.getScopeSessionFor(session) fun getScopeSessionFor(session: FirSession): ScopeSession = firResolveSession.getScopeSessionFor(session)
companion object { companion object {
@InvalidWayOfUsingAnalysisSession @InvalidWayOfUsingAnalysisSession
internal fun createAnalysisSessionByResolveState( internal fun createAnalysisSessionByFirResolveSession(
firResolveState: LLFirModuleResolveState, firResolveSession: LLFirResolveSession,
token: ValidityToken, token: ValidityToken,
): KtFirAnalysisSession { ): KtFirAnalysisSession {
val project = firResolveState.project val project = firResolveSession.project
val firSymbolBuilder = KtSymbolByFirBuilder( val firSymbolBuilder = KtSymbolByFirBuilder(
firResolveState, firResolveSession,
project, project,
token token
) )
return KtFirAnalysisSession( return KtFirAnalysisSession(
project, project,
firResolveState, firResolveSession,
firSymbolBuilder, firSymbolBuilder,
token, token,
AnalysisSessionMode.REGULAR, AnalysisSessionMode.REGULAR,
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtFirAnalysisSessionProvider.kt
+9 -10
View File
@@ -8,34 +8,33 @@ package org.jetbrains.kotlin.analysis.api.fir
import com.intellij.openapi.project.Project import com.intellij.openapi.project.Project
import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
import org.jetbrains.kotlin.analysis.api.KtAnalysisSession import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirBackingFieldSymbol
import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbol import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbol
import org.jetbrains.kotlin.analysis.api.impl.base.CachingKtAnalysisSessionProvider import org.jetbrains.kotlin.analysis.api.impl.base.CachingKtAnalysisSessionProvider
import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getFirResolveSession
import org.jetbrains.kotlin.psi.KtElement import org.jetbrains.kotlin.psi.KtElement
@OptIn(InvalidWayOfUsingAnalysisSession::class) @OptIn(InvalidWayOfUsingAnalysisSession::class)
class KtFirAnalysisSessionProvider(project: Project) : CachingKtAnalysisSessionProvider<LLFirModuleResolveState>(project) { class KtFirAnalysisSessionProvider(project: Project) : CachingKtAnalysisSessionProvider<LLFirResolveSession>(project) {
override fun getResolveState(contextElement: KtElement): LLFirModuleResolveState { override fun getFirResolveSession(contextElement: KtElement): LLFirResolveSession {
return contextElement.getResolveState() return contextElement.getFirResolveSession()
} }
override fun getResolveState(contextSymbol: KtSymbol): LLFirModuleResolveState { override fun getFirResolveSession(contextSymbol: KtSymbol): LLFirResolveSession {
return when (contextSymbol) { return when (contextSymbol) {
is KtFirSymbol<*> -> contextSymbol.resolveState is KtFirSymbol<*> -> contextSymbol.firResolveSession
else -> error("Invalid symbol ${contextSymbol::class}") else -> error("Invalid symbol ${contextSymbol::class}")
} }
} }
override fun createAnalysisSession( override fun createAnalysisSession(
resolveState: LLFirModuleResolveState, firResolveSession: LLFirResolveSession,
validityToken: ValidityToken, validityToken: ValidityToken,
): KtAnalysisSession { ): KtAnalysisSession {
@Suppress("DEPRECATION") @Suppress("DEPRECATION")
return KtFirAnalysisSession.createAnalysisSessionByResolveState(resolveState, validityToken) return KtFirAnalysisSession.createAnalysisSessionByFirResolveSession(firResolveSession, validityToken)
} }
} }
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtSymbolByFirBuilder.kt
+31 -31
View File
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.*
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtSubstitutor import org.jetbrains.kotlin.analysis.api.types.KtSubstitutor
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.analysis.providers.createPackageProvider import org.jetbrains.kotlin.analysis.providers.createPackageProvider
import org.jetbrains.kotlin.builtins.functions.FunctionClassKind import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.*
@@ -53,7 +53,7 @@ import kotlin.contracts.contract
*/ */
internal class KtSymbolByFirBuilder private constructor( internal class KtSymbolByFirBuilder private constructor(
private val project: Project, private val project: Project,
resolveState: LLFirModuleResolveState, firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
val withReadOnlyCaching: Boolean, val withReadOnlyCaching: Boolean,
private val symbolsCache: BuilderCache<FirBasedSymbol<*>, KtSymbol>, private val symbolsCache: BuilderCache<FirBasedSymbol<*>, KtSymbol>,
@@ -61,10 +61,10 @@ internal class KtSymbolByFirBuilder private constructor(
private val filesCache: BuilderCache<FirFileSymbol, KtFileSymbol>, private val filesCache: BuilderCache<FirFileSymbol, KtFileSymbol>,
private val backingFieldCache: BuilderCache<FirBackingFieldSymbol, KtBackingFieldSymbol>, private val backingFieldCache: BuilderCache<FirBackingFieldSymbol, KtBackingFieldSymbol>,
) : ValidityTokenOwner { ) : ValidityTokenOwner {
private val resolveState by weakRef(resolveState) private val firResolveSession by weakRef(firResolveSession)
private val firProvider get() = resolveState.useSiteFirSession.symbolProvider private val firProvider get() = firResolveSession.useSiteFirSession.symbolProvider
val rootSession: FirSession = resolveState.useSiteFirSession val rootSession: FirSession = firResolveSession.useSiteFirSession
val classifierBuilder = ClassifierSymbolBuilder() val classifierBuilder = ClassifierSymbolBuilder()
val functionLikeBuilder = FunctionLikeSymbolBuilder() val functionLikeBuilder = FunctionLikeSymbolBuilder()
@@ -74,13 +74,13 @@ internal class KtSymbolByFirBuilder private constructor(
val typeBuilder = TypeBuilder() val typeBuilder = TypeBuilder()
constructor( constructor(
resolveState: LLFirModuleResolveState, firResolveSession: LLFirResolveSession,
project: Project, project: Project,
token: ValidityToken token: ValidityToken
) : this( ) : this(
project = project, project = project,
token = token, token = token,
resolveState = resolveState, firResolveSession = firResolveSession,
withReadOnlyCaching = false, withReadOnlyCaching = false,
symbolsCache = BuilderCache(), symbolsCache = BuilderCache(),
extensionReceiverSymbolsCache = BuilderCache(), extensionReceiverSymbolsCache = BuilderCache(),
@@ -88,12 +88,12 @@ internal class KtSymbolByFirBuilder private constructor(
filesCache = BuilderCache(), filesCache = BuilderCache(),
) )
fun createReadOnlyCopy(newResolveState: LLFirModuleResolveState): KtSymbolByFirBuilder { fun createReadOnlyCopy(newFirResolveSession: LLFirResolveSession): KtSymbolByFirBuilder {
check(!withReadOnlyCaching) { "Cannot create readOnly KtSymbolByFirBuilder from a readonly one" } check(!withReadOnlyCaching) { "Cannot create readOnly KtSymbolByFirBuilder from a readonly one" }
return KtSymbolByFirBuilder( return KtSymbolByFirBuilder(
project, project,
token = token, token = token,
resolveState = newResolveState, firResolveSession = newFirResolveSession,
withReadOnlyCaching = true, withReadOnlyCaching = true,
symbolsCache = symbolsCache.createReadOnlyCopy(), symbolsCache = symbolsCache.createReadOnlyCopy(),
extensionReceiverSymbolsCache = extensionReceiverSymbolsCache.createReadOnlyCopy(), extensionReceiverSymbolsCache = extensionReceiverSymbolsCache.createReadOnlyCopy(),
@@ -118,9 +118,9 @@ internal class KtSymbolByFirBuilder private constructor(
} }
fun buildEnumEntrySymbol(firSymbol: FirEnumEntrySymbol) = fun buildEnumEntrySymbol(firSymbol: FirEnumEntrySymbol) =
symbolsCache.cache(firSymbol) { KtFirEnumEntrySymbol(firSymbol, resolveState, token, this) } symbolsCache.cache(firSymbol) { KtFirEnumEntrySymbol(firSymbol, firResolveSession, token, this) }
fun buildFileSymbol(firSymbol: FirFileSymbol) = filesCache.cache(firSymbol) { KtFirFileSymbol(firSymbol, resolveState, token) } fun buildFileSymbol(firSymbol: FirFileSymbol) = filesCache.cache(firSymbol) { KtFirFileSymbol(firSymbol, firResolveSession, token) }
private val packageProvider = project.createPackageProvider(GlobalSearchScope.allScope(project))//todo scope private val packageProvider = project.createPackageProvider(GlobalSearchScope.allScope(project))//todo scope
@@ -165,19 +165,19 @@ internal class KtSymbolByFirBuilder private constructor(
} }
fun buildNamedClassOrObjectSymbol(symbol: FirRegularClassSymbol): KtFirNamedClassOrObjectSymbol { fun buildNamedClassOrObjectSymbol(symbol: FirRegularClassSymbol): KtFirNamedClassOrObjectSymbol {
return symbolsCache.cache(symbol) { KtFirNamedClassOrObjectSymbol(symbol, resolveState, token, this@KtSymbolByFirBuilder) } return symbolsCache.cache(symbol) { KtFirNamedClassOrObjectSymbol(symbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
} }
fun buildAnonymousObjectSymbol(symbol: FirAnonymousObjectSymbol): KtAnonymousObjectSymbol { fun buildAnonymousObjectSymbol(symbol: FirAnonymousObjectSymbol): KtAnonymousObjectSymbol {
return symbolsCache.cache(symbol) { KtFirAnonymousObjectSymbol(symbol, resolveState, token, this@KtSymbolByFirBuilder) } return symbolsCache.cache(symbol) { KtFirAnonymousObjectSymbol(symbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
} }
fun buildTypeAliasSymbol(symbol: FirTypeAliasSymbol): KtFirTypeAliasSymbol { fun buildTypeAliasSymbol(symbol: FirTypeAliasSymbol): KtFirTypeAliasSymbol {
return symbolsCache.cache(symbol) { KtFirTypeAliasSymbol(symbol, resolveState, token, this@KtSymbolByFirBuilder) } return symbolsCache.cache(symbol) { KtFirTypeAliasSymbol(symbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
} }
fun buildTypeParameterSymbol(firSymbol: FirTypeParameterSymbol): KtFirTypeParameterSymbol { fun buildTypeParameterSymbol(firSymbol: FirTypeParameterSymbol): KtFirTypeParameterSymbol {
return symbolsCache.cache(firSymbol) { KtFirTypeParameterSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) } return symbolsCache.cache(firSymbol) { KtFirTypeParameterSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
} }
fun buildTypeParameterSymbolByLookupTag(lookupTag: ConeTypeParameterLookupTag): KtTypeParameterSymbol? { fun buildTypeParameterSymbolByLookupTag(lookupTag: ConeTypeParameterLookupTag): KtTypeParameterSymbol? {
@@ -228,7 +228,7 @@ internal class KtSymbolByFirBuilder private constructor(
} }
check(firSymbol.origin != FirDeclarationOrigin.SamConstructor) check(firSymbol.origin != FirDeclarationOrigin.SamConstructor)
return symbolsCache.cache(firSymbol) { KtFirFunctionSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) } return symbolsCache.cache(firSymbol) { KtFirFunctionSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
} }
fun buildFunctionSignature(firSymbol: FirNamedFunctionSymbol): KtFunctionLikeSignature<KtFirFunctionSymbol> { fun buildFunctionSignature(firSymbol: FirNamedFunctionSymbol): KtFunctionLikeSignature<KtFirFunctionSymbol> {
@@ -249,27 +249,27 @@ internal class KtSymbolByFirBuilder private constructor(
} }
fun buildAnonymousFunctionSymbol(firSymbol: FirAnonymousFunctionSymbol): KtFirAnonymousFunctionSymbol { fun buildAnonymousFunctionSymbol(firSymbol: FirAnonymousFunctionSymbol): KtFirAnonymousFunctionSymbol {
return symbolsCache.cache(firSymbol) { KtFirAnonymousFunctionSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) } return symbolsCache.cache(firSymbol) { KtFirAnonymousFunctionSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
} }
fun buildConstructorSymbol(firSymbol: FirConstructorSymbol): KtFirConstructorSymbol { fun buildConstructorSymbol(firSymbol: FirConstructorSymbol): KtFirConstructorSymbol {
val originalFirSymbol = firSymbol.fir.originalConstructorIfTypeAlias?.symbol ?: firSymbol val originalFirSymbol = firSymbol.fir.originalConstructorIfTypeAlias?.symbol ?: firSymbol
return symbolsCache.cache(originalFirSymbol) { return symbolsCache.cache(originalFirSymbol) {
KtFirConstructorSymbol(originalFirSymbol, resolveState, token, this@KtSymbolByFirBuilder) KtFirConstructorSymbol(originalFirSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
} }
} }
fun buildSamConstructorSymbol(firSymbol: FirNamedFunctionSymbol): KtFirSamConstructorSymbol { fun buildSamConstructorSymbol(firSymbol: FirNamedFunctionSymbol): KtFirSamConstructorSymbol {
check(firSymbol.origin == FirDeclarationOrigin.SamConstructor) check(firSymbol.origin == FirDeclarationOrigin.SamConstructor)
return symbolsCache.cache(firSymbol) { KtFirSamConstructorSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) } return symbolsCache.cache(firSymbol) { KtFirSamConstructorSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
} }
fun buildPropertyAccessorSymbol(firSymbol: FirPropertyAccessorSymbol): KtFunctionLikeSymbol { fun buildPropertyAccessorSymbol(firSymbol: FirPropertyAccessorSymbol): KtFunctionLikeSymbol {
return symbolsCache.cache(firSymbol) { return symbolsCache.cache(firSymbol) {
if (firSymbol.isGetter) { if (firSymbol.isGetter) {
KtFirPropertyGetterSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) KtFirPropertyGetterSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
} else { } else {
KtFirPropertySetterSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) KtFirPropertySetterSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
} }
} }
} }
@@ -314,7 +314,7 @@ internal class KtSymbolByFirBuilder private constructor(
} }
return symbolsCache.cache(firSymbol) { return symbolsCache.cache(firSymbol) {
KtFirKotlinPropertySymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) KtFirKotlinPropertySymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
} }
} }
@@ -330,31 +330,31 @@ internal class KtSymbolByFirBuilder private constructor(
fun buildLocalVariableSymbol(firSymbol: FirPropertySymbol): KtFirLocalVariableSymbol { fun buildLocalVariableSymbol(firSymbol: FirPropertySymbol): KtFirLocalVariableSymbol {
checkRequirementForBuildingSymbol<KtFirLocalVariableSymbol>(firSymbol, firSymbol.isLocal) checkRequirementForBuildingSymbol<KtFirLocalVariableSymbol>(firSymbol, firSymbol.isLocal)
return symbolsCache.cache(firSymbol) { return symbolsCache.cache(firSymbol) {
KtFirLocalVariableSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) KtFirLocalVariableSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
} }
} }
fun buildSyntheticJavaPropertySymbol(firSymbol: FirSyntheticPropertySymbol): KtFirSyntheticJavaPropertySymbol { fun buildSyntheticJavaPropertySymbol(firSymbol: FirSyntheticPropertySymbol): KtFirSyntheticJavaPropertySymbol {
return symbolsCache.cache(firSymbol) { return symbolsCache.cache(firSymbol) {
KtFirSyntheticJavaPropertySymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) KtFirSyntheticJavaPropertySymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
} }
} }
fun buildValueParameterSymbol(firSymbol: FirValueParameterSymbol): KtValueParameterSymbol { fun buildValueParameterSymbol(firSymbol: FirValueParameterSymbol): KtValueParameterSymbol {
return symbolsCache.cache(firSymbol) { return symbolsCache.cache(firSymbol) {
KtFirValueParameterSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) KtFirValueParameterSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
} }
} }
fun buildFieldSymbol(firSymbol: FirFieldSymbol): KtFirJavaFieldSymbol { fun buildFieldSymbol(firSymbol: FirFieldSymbol): KtFirJavaFieldSymbol {
checkRequirementForBuildingSymbol<KtFirJavaFieldSymbol>(firSymbol, firSymbol.fir.isJavaFieldOrSubstitutionOverrideOfJavaField()) checkRequirementForBuildingSymbol<KtFirJavaFieldSymbol>(firSymbol, firSymbol.fir.isJavaFieldOrSubstitutionOverrideOfJavaField())
return symbolsCache.cache(firSymbol) { KtFirJavaFieldSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) } return symbolsCache.cache(firSymbol) { KtFirJavaFieldSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
} }
fun buildBackingFieldSymbol(firSymbol: FirBackingFieldSymbol): KtFirBackingFieldSymbol { fun buildBackingFieldSymbol(firSymbol: FirBackingFieldSymbol): KtFirBackingFieldSymbol {
return backingFieldCache.cache(firSymbol) { return backingFieldCache.cache(firSymbol) {
KtFirBackingFieldSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) KtFirBackingFieldSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
} }
} }
@@ -400,25 +400,25 @@ internal class KtSymbolByFirBuilder private constructor(
fun buildGetterSymbol(firSymbol: FirPropertyAccessorSymbol): KtFirPropertyGetterSymbol { fun buildGetterSymbol(firSymbol: FirPropertyAccessorSymbol): KtFirPropertyGetterSymbol {
checkRequirementForBuildingSymbol<KtFirPropertyGetterSymbol>(firSymbol, firSymbol.isGetter) checkRequirementForBuildingSymbol<KtFirPropertyGetterSymbol>(firSymbol, firSymbol.isGetter)
return symbolsCache.cache(firSymbol) { KtFirPropertyGetterSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) } return symbolsCache.cache(firSymbol) { KtFirPropertyGetterSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
} }
fun buildSetterSymbol(firSymbol: FirPropertyAccessorSymbol): KtFirPropertySetterSymbol { fun buildSetterSymbol(firSymbol: FirPropertyAccessorSymbol): KtFirPropertySetterSymbol {
checkRequirementForBuildingSymbol<KtFirPropertySetterSymbol>(firSymbol, firSymbol.isSetter) checkRequirementForBuildingSymbol<KtFirPropertySetterSymbol>(firSymbol, firSymbol.isSetter)
return symbolsCache.cache(firSymbol) { KtFirPropertySetterSymbol(firSymbol, resolveState, token, this@KtSymbolByFirBuilder) } return symbolsCache.cache(firSymbol) { KtFirPropertySetterSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
} }
fun buildExtensionReceiverSymbol(firCallableSymbol: FirCallableSymbol<*>): KtReceiverParameterSymbol? { fun buildExtensionReceiverSymbol(firCallableSymbol: FirCallableSymbol<*>): KtReceiverParameterSymbol? {
if (firCallableSymbol.fir.receiverTypeRef == null) return null if (firCallableSymbol.fir.receiverTypeRef == null) return null
return extensionReceiverSymbolsCache.cache(firCallableSymbol) { return extensionReceiverSymbolsCache.cache(firCallableSymbol) {
KtFirReceiverParameterSymbol(firCallableSymbol, resolveState, token, this@KtSymbolByFirBuilder) KtFirReceiverParameterSymbol(firCallableSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
} }
} }
} }
inner class AnonymousInitializerBuilder { inner class AnonymousInitializerBuilder {
fun buildClassInitializer(firSymbol: FirAnonymousInitializerSymbol): KtClassInitializerSymbol { fun buildClassInitializer(firSymbol: FirAnonymousInitializerSymbol): KtClassInitializerSymbol {
return symbolsCache.cache(firSymbol) { KtFirClassInitializerSymbol(firSymbol, resolveState, token) } return symbolsCache.cache(firSymbol) { KtFirClassInitializerSymbol(firSymbol, firResolveSession, token) }
} }
} }
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirAnalysisSessionComponent.kt
+3 -3
View File
@@ -39,10 +39,10 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs
internal interface KtFirAnalysisSessionComponent { internal interface KtFirAnalysisSessionComponent {
val analysisSession: KtFirAnalysisSession val analysisSession: KtFirAnalysisSession
val rootModuleSession: FirSession get() = analysisSession.firResolveState.useSiteFirSession val rootModuleSession: FirSession get() = analysisSession.firResolveSession.useSiteFirSession
val typeContext: ConeInferenceContext get() = rootModuleSession.typeContext val typeContext: ConeInferenceContext get() = rootModuleSession.typeContext
val firSymbolBuilder get() = analysisSession.firSymbolBuilder val firSymbolBuilder get() = analysisSession.firSymbolBuilder
val firResolveState get() = analysisSession.firResolveState val firResolveSession get() = analysisSession.firResolveSession
fun ConeKotlinType.asKtType() = analysisSession.firSymbolBuilder.typeBuilder.buildKtType(this) fun ConeKotlinType.asKtType() = analysisSession.firSymbolBuilder.typeBuilder.buildKtType(this)
@@ -76,7 +76,7 @@ internal interface KtFirAnalysisSessionComponent {
fun createTypeCheckerContext(): TypeCheckerState { fun createTypeCheckerContext(): TypeCheckerState {
// TODO use correct session here, // TODO use correct session here,
return analysisSession.firResolveState.useSiteFirSession.typeContext.newTypeCheckerState( return analysisSession.firResolveSession.useSiteFirSession.typeContext.newTypeCheckerState(
errorTypesEqualToAnything = true, errorTypesEqualToAnything = true,
stubTypesEqualToAnything = true stubTypesEqualToAnything = true
) )
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt
+3 -3
View File
@@ -110,7 +110,7 @@ internal class KtFirCallResolver(
?: containingBinaryExpressionForLhs ?: containingBinaryExpressionForLhs
?: containingUnaryExpressionForIncOrDec ?: containingUnaryExpressionForIncOrDec
?: psi ?: psi
val fir = psiToResolve.getOrBuildFir(analysisSession.firResolveState) ?: return emptyList() val fir = psiToResolve.getOrBuildFir(analysisSession.firResolveSession) ?: return emptyList()
return fir.getCallInfo( return fir.getCallInfo(
psiToResolve, psiToResolve,
psiToResolve == containingCallExpressionForCalleeExpression, psiToResolve == containingCallExpressionForCalleeExpression,
@@ -225,7 +225,7 @@ internal class KtFirCallResolver(
val lhs = deparenthesize(this) val lhs = deparenthesize(this)
val binaryExpression = parentOfType<KtBinaryExpression>() ?: return null val binaryExpression = parentOfType<KtBinaryExpression>() ?: return null
if (deparenthesize(binaryExpression.left) != lhs || binaryExpression.operationToken !in KtTokens.ALL_ASSIGNMENTS) return null if (deparenthesize(binaryExpression.left) != lhs || binaryExpression.operationToken !in KtTokens.ALL_ASSIGNMENTS) return null
val firBinaryExpression = binaryExpression.getOrBuildFir(analysisSession.firResolveState) val firBinaryExpression = binaryExpression.getOrBuildFir(analysisSession.firResolveSession)
if (firBinaryExpression is FirFunctionCall) { if (firBinaryExpression is FirFunctionCall) {
if (firBinaryExpression.origin == FirFunctionCallOrigin.Operator && if (firBinaryExpression.origin == FirFunctionCallOrigin.Operator &&
firBinaryExpression.calleeReference.name in OperatorNameConventions.ASSIGNMENT_OPERATIONS firBinaryExpression.calleeReference.name in OperatorNameConventions.ASSIGNMENT_OPERATIONS
@@ -772,7 +772,7 @@ internal class KtFirCallResolver(
val calleeName = originalFunctionCall.calleeOrCandidateName ?: return emptyList() val calleeName = originalFunctionCall.calleeOrCandidateName ?: return emptyList()
val candidates = AllCandidatesResolver(analysisSession.useSiteSession).getAllCandidates( val candidates = AllCandidatesResolver(analysisSession.useSiteSession).getAllCandidates(
analysisSession.firResolveState, analysisSession.firResolveSession,
originalFunctionCall, originalFunctionCall,
calleeName, calleeName,
psi psi
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompileTimeConstantProvider.kt
+1 -1
View File
@@ -30,7 +30,7 @@ internal class KtFirCompileTimeConstantProvider(
expression: KtExpression, expression: KtExpression,
mode: KtConstantEvaluationMode, mode: KtConstantEvaluationMode,
): KtConstantValue? = withValidityAssertion { ): KtConstantValue? = withValidityAssertion {
evaluateFir(expression.getOrBuildFir(firResolveState), expression, mode) evaluateFir(expression.getOrBuildFir(firResolveSession), expression, mode)
} }
private fun evaluateFir( private fun evaluateFir(
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompletionCandidateChecker.kt
+5 -5
View File
@@ -60,9 +60,9 @@ internal class KtFirCompletionCandidateChecker(
nameExpression: KtSimpleNameExpression, nameExpression: KtSimpleNameExpression,
possibleExplicitReceiver: KtExpression?, possibleExplicitReceiver: KtExpression?,
): KtExtensionApplicabilityResult { ): KtExtensionApplicabilityResult {
val file = originalFile.getOrBuildFirFile(firResolveState) val file = originalFile.getOrBuildFirFile(firResolveSession)
val explicitReceiverExpression = possibleExplicitReceiver?.getMatchingFirExpressionForCallReceiver() val explicitReceiverExpression = possibleExplicitReceiver?.getMatchingFirExpressionForCallReceiver()
val resolver = SingleCandidateResolver(firResolveState.useSiteFirSession, file) val resolver = SingleCandidateResolver(firResolveSession.useSiteFirSession, file)
val implicitReceivers = getImplicitReceivers(originalFile, nameExpression) val implicitReceivers = getImplicitReceivers(originalFile, nameExpression)
for (implicitReceiverValue in implicitReceivers) { for (implicitReceiverValue in implicitReceivers) {
val resolutionParameters = ResolutionParameters( val resolutionParameters = ResolutionParameters(
@@ -90,7 +90,7 @@ internal class KtFirCompletionCandidateChecker(
originalFile: KtFile, originalFile: KtFile,
fakeNameExpression: KtSimpleNameExpression fakeNameExpression: KtSimpleNameExpression
): Sequence<ImplicitReceiverValue<*>?> { ): Sequence<ImplicitReceiverValue<*>?> {
val towerDataContext = analysisSession.firResolveState.getTowerContextProvider(originalFile) val towerDataContext = analysisSession.firResolveSession.getTowerContextProvider(originalFile)
.getClosestAvailableParentContext(fakeNameExpression) .getClosestAvailableParentContext(fakeNameExpression)
?: error("Cannot find enclosing declaration for ${fakeNameExpression.getElementTextInContext()}") ?: error("Cannot find enclosing declaration for ${fakeNameExpression.getElementTextInContext()}")
@@ -110,9 +110,9 @@ internal class KtFirCompletionCandidateChecker(
*/ */
private fun KtExpression.getMatchingFirExpressionForCallReceiver(): FirExpression { private fun KtExpression.getMatchingFirExpressionForCallReceiver(): FirExpression {
val psiWholeCall = this.getQualifiedExpressionForReceiver() val psiWholeCall = this.getQualifiedExpressionForReceiver()
if (psiWholeCall !is KtSafeQualifiedExpression) return this.getOrBuildFirOfType<FirExpression>(firResolveState) if (psiWholeCall !is KtSafeQualifiedExpression) return this.getOrBuildFirOfType<FirExpression>(firResolveSession)
val firSafeCall = psiWholeCall.getOrBuildFirOfType<FirSafeCallExpression>(firResolveState) val firSafeCall = psiWholeCall.getOrBuildFirOfType<FirSafeCallExpression>(firResolveSession)
return firSafeCall.checkedSubjectRef.value return firSafeCall.checkedSubjectRef.value
} }
} }
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirDiagnosticProvider.kt
+2 -2
View File
@@ -26,11 +26,11 @@ internal class KtFirDiagnosticProvider(
element: KtElement, element: KtElement,
filter: KtDiagnosticCheckerFilter filter: KtDiagnosticCheckerFilter
): Collection<KtDiagnosticWithPsi<*>> = withValidityAssertion { ): Collection<KtDiagnosticWithPsi<*>> = withValidityAssertion {
element.getDiagnostics(firResolveState, filter.asLLFilter()).map { it.asKtDiagnostic() } element.getDiagnostics(firResolveSession, filter.asLLFilter()).map { it.asKtDiagnostic() }
} }
override fun collectDiagnosticsForFile(ktFile: KtFile, filter: KtDiagnosticCheckerFilter): Collection<KtDiagnosticWithPsi<*>> = override fun collectDiagnosticsForFile(ktFile: KtFile, filter: KtDiagnosticCheckerFilter): Collection<KtDiagnosticWithPsi<*>> =
ktFile.collectDiagnosticsForFile(firResolveState, filter.asLLFilter()).map { it.asKtDiagnostic() } ktFile.collectDiagnosticsForFile(firResolveSession, filter.asLLFilter()).map { it.asKtDiagnostic() }
private fun KtDiagnosticCheckerFilter.asLLFilter() = when (this) { private fun KtDiagnosticCheckerFilter.asLLFilter() = when (this) {
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirExpressionInfoProvider.kt
+3 -3
View File
@@ -23,14 +23,14 @@ internal class KtFirExpressionInfoProvider(
override val token: ValidityToken, override val token: ValidityToken,
) : KtExpressionInfoProvider(), KtFirAnalysisSessionComponent { ) : KtExpressionInfoProvider(), KtFirAnalysisSessionComponent {
override fun getReturnExpressionTargetSymbol(returnExpression: KtReturnExpression): KtCallableSymbol? { override fun getReturnExpressionTargetSymbol(returnExpression: KtReturnExpression): KtCallableSymbol? {
val fir = returnExpression.getOrBuildFirSafe<FirReturnExpression>(firResolveState) ?: return null val fir = returnExpression.getOrBuildFirSafe<FirReturnExpression>(firResolveSession) ?: return null
val firTargetSymbol = fir.target.labeledElement val firTargetSymbol = fir.target.labeledElement
if (firTargetSymbol is FirErrorFunction) return null if (firTargetSymbol is FirErrorFunction) return null
return firSymbolBuilder.callableBuilder.buildCallableSymbol(firTargetSymbol.symbol) return firSymbolBuilder.callableBuilder.buildCallableSymbol(firTargetSymbol.symbol)
} }
override fun getWhenMissingCases(whenExpression: KtWhenExpression): List<WhenMissingCase> { override fun getWhenMissingCases(whenExpression: KtWhenExpression): List<WhenMissingCase> {
val firWhenExpression = whenExpression.getOrBuildFirSafe<FirWhenExpression>(analysisSession.firResolveState) ?: return emptyList() val firWhenExpression = whenExpression.getOrBuildFirSafe<FirWhenExpression>(analysisSession.firResolveSession) ?: return emptyList()
return FirWhenExhaustivenessTransformer.computeAllMissingCases(analysisSession.firResolveState.useSiteFirSession, firWhenExpression) return FirWhenExhaustivenessTransformer.computeAllMissingCases(analysisSession.firResolveSession.useSiteFirSession, firWhenExpression)
} }
} }
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirExpressionTypeProvider.kt
+6 -6
View File
@@ -38,7 +38,7 @@ internal class KtFirExpressionTypeProvider(
) : KtExpressionTypeProvider(), KtFirAnalysisSessionComponent { ) : KtExpressionTypeProvider(), KtFirAnalysisSessionComponent {
override fun getKtExpressionType(expression: KtExpression): KtType? = withValidityAssertion { override fun getKtExpressionType(expression: KtExpression): KtType? = withValidityAssertion {
when (val fir = expression.unwrap().getOrBuildFir(firResolveState)) { when (val fir = expression.unwrap().getOrBuildFir(firResolveSession)) {
is FirFunctionCall -> { is FirFunctionCall -> {
getReturnTypeForArrayStyleAssignmentTarget(expression, fir) getReturnTypeForArrayStyleAssignmentTarget(expression, fir)
?: fir.typeRef.coneType.asKtType() ?: fir.typeRef.coneType.asKtType()
@@ -95,12 +95,12 @@ internal class KtFirExpressionTypeProvider(
} }
override fun getReturnTypeForKtDeclaration(declaration: KtDeclaration): KtType = withValidityAssertion { override fun getReturnTypeForKtDeclaration(declaration: KtDeclaration): KtType = withValidityAssertion {
val firDeclaration = declaration.getOrBuildFirOfType<FirCallableDeclaration>(firResolveState) val firDeclaration = declaration.getOrBuildFirOfType<FirCallableDeclaration>(firResolveSession)
firDeclaration.returnTypeRef.coneType.asKtType() firDeclaration.returnTypeRef.coneType.asKtType()
} }
override fun getFunctionalTypeForKtFunction(declaration: KtFunction): KtType = withValidityAssertion { override fun getFunctionalTypeForKtFunction(declaration: KtFunction): KtType = withValidityAssertion {
val firFunction = declaration.getOrBuildFirOfType<FirFunction>(firResolveState) val firFunction = declaration.getOrBuildFirOfType<FirFunction>(firResolveSession)
firFunction.constructFunctionalType(firFunction.isSuspend).asKtType() firFunction.constructFunctionalType(firFunction.isSuspend).asKtType()
} }
@@ -127,7 +127,7 @@ internal class KtFirExpressionTypeProvider(
private fun getExpectedTypeOfFunctionParameter(expression: PsiElement): KtType? { private fun getExpectedTypeOfFunctionParameter(expression: PsiElement): KtType? {
val (ktCallExpression, argumentExpression) = expression.getFunctionCallAsWithThisAsParameter() ?: return null val (ktCallExpression, argumentExpression) = expression.getFunctionCallAsWithThisAsParameter() ?: return null
val firCall = ktCallExpression.getOrBuildFirSafe<FirFunctionCall>(firResolveState) ?: return null val firCall = ktCallExpression.getOrBuildFirSafe<FirFunctionCall>(firResolveSession) ?: return null
val callee = (firCall.calleeReference as? FirResolvedNamedReference)?.resolvedSymbol val callee = (firCall.calleeReference as? FirResolvedNamedReference)?.resolvedSymbol
if (callee?.fir?.origin == FirDeclarationOrigin.SamConstructor) { if (callee?.fir?.origin == FirDeclarationOrigin.SamConstructor) {
@@ -161,7 +161,7 @@ internal class KtFirExpressionTypeProvider(
private fun getExpectedTypeOfInfixFunctionParameter(expression: PsiElement): KtType? { private fun getExpectedTypeOfInfixFunctionParameter(expression: PsiElement): KtType? {
val infixCallExpression = val infixCallExpression =
expression.unwrapQualified<KtBinaryExpression> { binaryExpr, expr -> binaryExpr.right == expr } ?: return null expression.unwrapQualified<KtBinaryExpression> { binaryExpr, expr -> binaryExpr.right == expr } ?: return null
val firCall = infixCallExpression.getOrBuildFirSafe<FirFunctionCall>(firResolveState) ?: return null val firCall = infixCallExpression.getOrBuildFirSafe<FirFunctionCall>(firResolveSession) ?: return null
// There is only one parameter for infix functions; get its type // There is only one parameter for infix functions; get its type
val arguments = firCall.argumentMapping ?: return null val arguments = firCall.argumentMapping ?: return null
@@ -229,7 +229,7 @@ internal class KtFirExpressionTypeProvider(
!typeRef.coneType.isNullableType() !typeRef.coneType.isNullableType()
} }
when (val fir = expression.getOrBuildFir(analysisSession.firResolveState)) { when (val fir = expression.getOrBuildFir(analysisSession.firResolveSession)) {
is FirExpressionWithSmartcastToNull -> if (fir.isStable) { is FirExpressionWithSmartcastToNull -> if (fir.isStable) {
return DefiniteNullability.DEFINITELY_NULL return DefiniteNullability.DEFINITELY_NULL
} }
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirImportOptimizer.kt
+4 -4
View File
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.analysis.api.components.KtImportOptimizerResult
import org.jetbrains.kotlin.analysis.api.fir.getCandidateSymbols import org.jetbrains.kotlin.analysis.api.fir.getCandidateSymbols
import org.jetbrains.kotlin.analysis.api.fir.utils.computeImportableName import org.jetbrains.kotlin.analysis.api.fir.utils.computeImportableName
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
@@ -41,15 +41,15 @@ import org.jetbrains.kotlin.util.OperatorNameConventions
internal class KtFirImportOptimizer( internal class KtFirImportOptimizer(
override val token: ValidityToken, override val token: ValidityToken,
private val firResolveState: LLFirModuleResolveState private val firResolveSession: LLFirResolveSession
) : KtImportOptimizer() { ) : KtImportOptimizer() {
private val firSession: FirSession private val firSession: FirSession
get() = firResolveState.useSiteFirSession get() = firResolveSession.useSiteFirSession
override fun analyseImports(file: KtFile): KtImportOptimizerResult { override fun analyseImports(file: KtFile): KtImportOptimizerResult {
assertIsValidAndAccessible() assertIsValidAndAccessible()
val firFile = file.getOrBuildFirFile(firResolveState).apply { ensureResolved(FirResolvePhase.BODY_RESOLVE) } val firFile = file.getOrBuildFirFile(firResolveSession).apply { ensureResolved(FirResolvePhase.BODY_RESOLVE) }
val existingImports = file.importDirectives val existingImports = file.importDirectives
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirReferenceShortener.kt
+9 -9
View File
@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.analysis.api.impl.barebone.parentsOfType
import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFir import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFir
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirOfType import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirOfType
@@ -64,7 +64,7 @@ import org.jetbrains.kotlin.utils.addIfNotNull
internal class KtFirReferenceShortener( internal class KtFirReferenceShortener(
override val analysisSession: KtFirAnalysisSession, override val analysisSession: KtFirAnalysisSession,
override val token: ValidityToken, override val token: ValidityToken,
override val firResolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
) : KtReferenceShortener(), KtFirAnalysisSessionComponent { ) : KtReferenceShortener(), KtFirAnalysisSessionComponent {
private val context = FirShorteningContext(analysisSession) private val context = FirShorteningContext(analysisSession)
@@ -77,10 +77,10 @@ internal class KtFirReferenceShortener(
val declarationToVisit = file.findSmallestDeclarationContainingSelection(selection) val declarationToVisit = file.findSmallestDeclarationContainingSelection(selection)
?: file.withDeclarationsResolvedToBodyResolve() ?: file.withDeclarationsResolvedToBodyResolve()
val firDeclaration = declarationToVisit.getOrBuildFirOfType<FirDeclaration>(firResolveState) val firDeclaration = declarationToVisit.getOrBuildFirOfType<FirDeclaration>(firResolveSession)
val towerContext = val towerContext =
LowLevelFirApiFacadeForResolveOnAir.onAirGetTowerContextProvider(firResolveState, declarationToVisit) LowLevelFirApiFacadeForResolveOnAir.onAirGetTowerContextProvider(firResolveSession, declarationToVisit)
//TODO: collect all usages of available symbols in the file and prevent importing symbols that could introduce name clashes, which //TODO: collect all usages of available symbols in the file and prevent importing symbols that could introduce name clashes, which
// may alter the meaning of existing code. // may alter the meaning of existing code.
@@ -90,7 +90,7 @@ internal class KtFirReferenceShortener(
selection, selection,
classShortenOption = { classShortenOption(analysisSession.firSymbolBuilder.buildSymbol(it) as KtClassLikeSymbol) }, classShortenOption = { classShortenOption(analysisSession.firSymbolBuilder.buildSymbol(it) as KtClassLikeSymbol) },
callableShortenOption = { callableShortenOption(analysisSession.firSymbolBuilder.buildSymbol(it) as KtCallableSymbol) }, callableShortenOption = { callableShortenOption(analysisSession.firSymbolBuilder.buildSymbol(it) as KtCallableSymbol) },
firResolveState, firResolveSession,
) )
firDeclaration.accept(collector) firDeclaration.accept(collector)
@@ -105,7 +105,7 @@ internal class KtFirReferenceShortener(
private fun KtFile.withDeclarationsResolvedToBodyResolve(): KtFile { private fun KtFile.withDeclarationsResolvedToBodyResolve(): KtFile {
for (declaration in declarations) { for (declaration in declarations) {
declaration.getOrBuildFir(firResolveState) // temporary hack, resolves declaration to BODY_RESOLVE stage declaration.getOrBuildFir(firResolveSession) // temporary hack, resolves declaration to BODY_RESOLVE stage
} }
return this return this
@@ -164,10 +164,10 @@ private data class AvailableSymbol<out T>(
) )
private class FirShorteningContext(val analysisSession: KtFirAnalysisSession) { private class FirShorteningContext(val analysisSession: KtFirAnalysisSession) {
private val firResolveState = analysisSession.firResolveState private val firResolveSession = analysisSession.firResolveSession
private val firSession: FirSession private val firSession: FirSession
get() = firResolveState.useSiteFirSession get() = firResolveSession.useSiteFirSession
fun findFirstClassifierInScopesByName(positionScopes: List<FirScope>, targetClassName: Name): AvailableSymbol<ClassId>? { fun findFirstClassifierInScopesByName(positionScopes: List<FirScope>, targetClassName: Name): AvailableSymbol<ClassId>? {
for (scope in positionScopes) { for (scope in positionScopes) {
@@ -286,7 +286,7 @@ private class ElementsToShortenCollector(
private val selection: TextRange, private val selection: TextRange,
private val classShortenOption: (FirClassLikeSymbol<*>) -> ShortenOption, private val classShortenOption: (FirClassLikeSymbol<*>) -> ShortenOption,
private val callableShortenOption: (FirCallableSymbol<*>) -> ShortenOption, private val callableShortenOption: (FirCallableSymbol<*>) -> ShortenOption,
private val firResolveState: LLFirModuleResolveState, private val firResolveSession: LLFirResolveSession,
) : ) :
FirVisitorVoid() { FirVisitorVoid() {
val namesToImport: MutableList<FqName> = mutableListOf() val namesToImport: MutableList<FqName> = mutableListOf()
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirScopeProvider.kt
+5 -5
View File
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithMembers
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getElementTextInContext import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getElementTextInContext
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.FirClass
@@ -49,7 +49,7 @@ internal class KtFirScopeProvider(
analysisSession: KtFirAnalysisSession, analysisSession: KtFirAnalysisSession,
builder: KtSymbolByFirBuilder, builder: KtSymbolByFirBuilder,
private val project: Project, private val project: Project,
firResolveState: LLFirModuleResolveState, firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
) : KtScopeProvider(), ValidityTokenOwner { ) : KtScopeProvider(), ValidityTokenOwner {
// KtFirScopeProvider is thread local, so it's okay to use the same session here // KtFirScopeProvider is thread local, so it's okay to use the same session here
@@ -58,7 +58,7 @@ internal class KtFirScopeProvider(
override val analysisSession: KtFirAnalysisSession by weakRef(analysisSession) override val analysisSession: KtFirAnalysisSession by weakRef(analysisSession)
private val builder by weakRef(builder) private val builder by weakRef(builder)
private val firResolveState by weakRef(firResolveState) private val firResolveSession by weakRef(firResolveSession)
private val memberScopeCache = IdentityHashMap<KtSymbolWithMembers, KtScope>() private val memberScopeCache = IdentityHashMap<KtSymbolWithMembers, KtScope>()
private val declaredMemberScopeCache = IdentityHashMap<KtSymbolWithMembers, KtScope>() private val declaredMemberScopeCache = IdentityHashMap<KtSymbolWithMembers, KtScope>()
@@ -176,7 +176,7 @@ internal class KtFirScopeProvider(
override fun getTypeScope(type: KtType): KtScope? { override fun getTypeScope(type: KtType): KtScope? {
check(type is KtFirType) { "KtFirScopeProvider can only work with KtFirType, but ${type::class} was provided" } check(type is KtFirType) { "KtFirScopeProvider can only work with KtFirType, but ${type::class} was provided" }
val firSession = firResolveState.useSiteFirSession val firSession = firResolveSession.useSiteFirSession
val firTypeScope = type.coneType.scope( val firTypeScope = type.coneType.scope(
firSession, firSession,
scopeSession, scopeSession,
@@ -198,7 +198,7 @@ internal class KtFirScopeProvider(
positionInFakeFile: KtElement positionInFakeFile: KtElement
): KtScopeContext = withValidityAssertion { ): KtScopeContext = withValidityAssertion {
val towerDataContext = val towerDataContext =
analysisSession.firResolveState.getTowerContextProvider(originalFile).getClosestAvailableParentContext(positionInFakeFile) analysisSession.firResolveSession.getTowerContextProvider(originalFile).getClosestAvailableParentContext(positionInFakeFile)
?: error("Cannot find enclosing declaration for ${positionInFakeFile.getElementTextInContext()}") ?: error("Cannot find enclosing declaration for ${positionInFakeFile.getElementTextInContext()}")
val implicitReceivers = towerDataContext.nonLocalTowerDataElements.mapNotNull { it.implicitReceiver }.distinct() val implicitReceivers = towerDataContext.nonLocalTowerDataElements.mapNotNull { it.implicitReceiver }.distinct()
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSmartcastProvider.kt
+2 -2
View File
@@ -51,7 +51,7 @@ internal class KtFirSmartcastProvider(
val possibleFunctionCall = expression.getPossiblyQualifiedCallExpressionForCallee() ?: expression val possibleFunctionCall = expression.getPossiblyQualifiedCallExpressionForCallee() ?: expression
return when (val firExpression = possibleFunctionCall.getOrBuildFir(analysisSession.firResolveState)) { return when (val firExpression = possibleFunctionCall.getOrBuildFir(analysisSession.firResolveSession)) {
is FirExpressionWithSmartcast -> firExpression is FirExpressionWithSmartcast -> firExpression
is FirSafeCallExpression -> firExpression.selector as? FirExpressionWithSmartcast is FirSafeCallExpression -> firExpression.selector as? FirExpressionWithSmartcast
is FirImplicitInvokeCall -> firExpression.explicitReceiver as? FirExpressionWithSmartcast is FirImplicitInvokeCall -> firExpression.explicitReceiver as? FirExpressionWithSmartcast
@@ -80,7 +80,7 @@ internal class KtFirSmartcastProvider(
?: expression.getQualifiedExpressionForSelector() ?: expression.getQualifiedExpressionForSelector()
?: expression ?: expression
return when (val firExpression = wholeExpression.getOrBuildFir(analysisSession.firResolveState)) { return when (val firExpression = wholeExpression.getOrBuildFir(analysisSession.firResolveSession)) {
is FirQualifiedAccessExpression -> firExpression is FirQualifiedAccessExpression -> firExpression
is FirSafeCallExpression -> firExpression.selector as? FirQualifiedAccessExpression is FirSafeCallExpression -> firExpression.selector as? FirQualifiedAccessExpression
else -> null else -> null
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolContainingDeclarationProvider.kt
+1 -1
View File
@@ -65,7 +65,7 @@ internal class KtFirSymbolContainingDeclarationProvider(
} }
override fun getContainingModule(symbol: KtSymbol): KtModule { override fun getContainingModule(symbol: KtSymbol): KtModule {
return symbol.getContainingKtModule(analysisSession.firResolveState) return symbol.getContainingKtModule(analysisSession.firResolveSession)
} }
private fun getContainingDeclarationForBackingFieldSymbol(symbol: KtSymbolWithKind): KtSymbolWithKind { private fun getContainingDeclarationForBackingFieldSymbol(symbol: KtSymbolWithKind): KtSymbolWithKind {
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirSymbolDeclarationRendererProvider.kt
+1 -1
View File
@@ -26,7 +26,7 @@ internal class KtFirSymbolDeclarationRendererProvider(
override fun render(type: KtType, options: KtTypeRendererOptions): String { override fun render(type: KtType, options: KtTypeRendererOptions): String {
require(type is KtFirType) require(type is KtFirType)
return ConeTypeIdeRenderer(analysisSession.firResolveState.useSiteFirSession, options).renderType(type.coneType) return ConeTypeIdeRenderer(analysisSession.firResolveSession.useSiteFirSession, options).renderType(type.coneType)
} }
override fun renderDeclaration(symbol: KtDeclarationSymbol, options: KtDeclarationRendererOptions): String { override fun renderDeclaration(symbol: KtDeclarationSymbol, options: KtDeclarationRendererOptions): String {
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirTypeProvider.kt
+4 -4
View File
@@ -86,7 +86,7 @@ internal class KtFirTypeProvider(
} }
override fun getKtType(ktTypeReference: KtTypeReference): KtType = withValidityAssertion { override fun getKtType(ktTypeReference: KtTypeReference): KtType = withValidityAssertion {
when (val fir = ktTypeReference.getOrBuildFir(firResolveState)) { when (val fir = ktTypeReference.getOrBuildFir(firResolveSession)) {
is FirResolvedTypeRef -> fir.coneType.asKtType() is FirResolvedTypeRef -> fir.coneType.asKtType()
is FirDelegatedConstructorCall -> fir.constructedTypeRef.coneType.asKtType() is FirDelegatedConstructorCall -> fir.constructedTypeRef.coneType.asKtType()
else -> throwUnexpectedFirElementError(fir, ktTypeReference) else -> throwUnexpectedFirElementError(fir, ktTypeReference)
@@ -94,7 +94,7 @@ internal class KtFirTypeProvider(
} }
override fun getReceiverTypeForDoubleColonExpression(expression: KtDoubleColonExpression): KtType? = withValidityAssertion { override fun getReceiverTypeForDoubleColonExpression(expression: KtDoubleColonExpression): KtType? = withValidityAssertion {
when (val fir = expression.getOrBuildFir(firResolveState)) { when (val fir = expression.getOrBuildFir(firResolveSession)) {
is FirGetClassCall -> is FirGetClassCall ->
fir.typeRef.coneType.getReceiverOfReflectionType()?.asKtType() fir.typeRef.coneType.getReceiverOfReflectionType()?.asKtType()
is FirCallableReferenceAccess -> is FirCallableReferenceAccess ->
@@ -122,7 +122,7 @@ internal class KtFirTypeProvider(
} }
override fun getImplicitReceiverTypesAtPosition(position: KtElement): List<KtType> { override fun getImplicitReceiverTypesAtPosition(position: KtElement): List<KtType> {
return analysisSession.firResolveState.getTowerContextProvider(position.containingKtFile) return analysisSession.firResolveSession.getTowerContextProvider(position.containingKtFile)
.getClosestAvailableParentContext(position)?.implicitReceiverStack?.map { it.type.asKtType() } ?: emptyList() .getClosestAvailableParentContext(position)?.implicitReceiverStack?.map { it.type.asKtType() } ?: emptyList()
} }
@@ -146,7 +146,7 @@ internal class KtFirTypeProvider(
} }
private fun ConeLookupTagBasedType.getSubstitutedSuperTypes(shouldApproximate: Boolean): Sequence<ConeKotlinType> { private fun ConeLookupTagBasedType.getSubstitutedSuperTypes(shouldApproximate: Boolean): Sequence<ConeKotlinType> {
val session = analysisSession.firResolveState.useSiteFirSession val session = analysisSession.firResolveSession.useSiteFirSession
val symbol = lookupTag.toSymbol(session) val symbol = lookupTag.toSymbol(session)
val superTypes = when (symbol) { val superTypes = when (symbol) {
is FirAnonymousObjectSymbol -> symbol.superConeTypes is FirAnonymousObjectSymbol -> symbol.superConeTypes
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirVisibilityChecker.kt
+2 -2
View File
@@ -44,13 +44,13 @@ internal class KtFirVisibilityChecker(
val nonLocalContainingDeclaration = findContainingNonLocalDeclaration(position) val nonLocalContainingDeclaration = findContainingNonLocalDeclaration(position)
val useSiteFirFile = useSiteFile.firSymbol.fir val useSiteFirFile = useSiteFile.firSymbol.fir
val containers = nonLocalContainingDeclaration val containers = nonLocalContainingDeclaration
?.getOrBuildFirSafe<FirCallableDeclaration>(analysisSession.firResolveState) ?.getOrBuildFirSafe<FirCallableDeclaration>(analysisSession.firResolveSession)
?.collectDesignation() ?.collectDesignation()
?.path ?.path
.orEmpty() .orEmpty()
val explicitDispatchReceiver = receiverExpression val explicitDispatchReceiver = receiverExpression
?.getOrBuildFirSafe<FirExpression>(analysisSession.firResolveState) ?.getOrBuildFirSafe<FirExpression>(analysisSession.firResolveSession)
?.let { ExpressionReceiverValue(it) } ?.let { ExpressionReceiverValue(it) }
val candidateFirSymbol = candidateSymbol.firSymbol.fir as FirMemberDeclaration val candidateFirSymbol = candidateSymbol.firSymbol.fir as FirMemberDeclaration
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/FirReferenceResolveHelper.kt
+5 -5
View File
@@ -188,8 +188,8 @@ internal object FirReferenceResolveHelper {
if (expression.isSyntheticOperatorReference()) return emptyList() if (expression.isSyntheticOperatorReference()) return emptyList()
val symbolBuilder = analysisSession.firSymbolBuilder val symbolBuilder = analysisSession.firSymbolBuilder
val adjustedResolutionExpression = adjustResolutionExpression(expression) val adjustedResolutionExpression = adjustResolutionExpression(expression)
val fir = adjustedResolutionExpression.getOrBuildFir(analysisSession.firResolveState) val fir = adjustedResolutionExpression.getOrBuildFir(analysisSession.firResolveSession)
val session = analysisSession.firResolveState.useSiteFirSession val session = analysisSession.firResolveSession.useSiteFirSession
return when (fir) { return when (fir) {
is FirResolvedTypeRef -> getSymbolsForResolvedTypeRef(fir, expression, session, symbolBuilder) is FirResolvedTypeRef -> getSymbolsForResolvedTypeRef(fir, expression, session, symbolBuilder)
is FirResolvedQualifier -> is FirResolvedQualifier ->
@@ -258,7 +258,7 @@ internal object FirReferenceResolveHelper {
): Collection<KtSymbol> { ): Collection<KtSymbol> {
val parentAsCall = expression.parent as? KtCallExpression val parentAsCall = expression.parent as? KtCallExpression
if (parentAsCall != null) { if (parentAsCall != null) {
val firResolvable = parentAsCall.getOrBuildFirSafe<FirResolvable>(analysisSession.firResolveState) val firResolvable = parentAsCall.getOrBuildFirSafe<FirResolvable>(analysisSession.firResolveSession)
if (firResolvable != null) { if (firResolvable != null) {
return getSymbolsByResolvable(firResolvable, expression, session, symbolBuilder) return getSymbolsByResolvable(firResolvable, expression, session, symbolBuilder)
} }
@@ -305,7 +305,7 @@ internal object FirReferenceResolveHelper {
val ktValueArgumentList = ktValueArgument.parent as? KtValueArgumentList ?: return emptyList() val ktValueArgumentList = ktValueArgument.parent as? KtValueArgumentList ?: return emptyList()
val ktCallExpression = ktValueArgumentList.parent as? KtCallElement ?: return emptyList() val ktCallExpression = ktValueArgumentList.parent as? KtCallElement ?: return emptyList()
val firCall = ktCallExpression.getOrBuildFirSafe<FirCall>(analysisSession.firResolveState) ?: return emptyList() val firCall = ktCallExpression.getOrBuildFirSafe<FirCall>(analysisSession.firResolveSession) ?: return emptyList()
val parameter = firCall.findCorrespondingParameter(ktValueArgument) ?: return emptyList() val parameter = firCall.findCorrespondingParameter(ktValueArgument) ?: return emptyList()
return listOfNotNull(parameter.buildSymbol(symbolBuilder)) return listOfNotNull(parameter.buildSymbol(symbolBuilder))
} }
@@ -333,7 +333,7 @@ internal object FirReferenceResolveHelper {
parent = parent.parent as? KtDotQualifiedExpression parent = parent.parent as? KtDotQualifiedExpression
continue continue
} }
val parentFir = selectorExpression.getOrBuildFir(analysisSession.firResolveState) val parentFir = selectorExpression.getOrBuildFir(analysisSession.firResolveSession)
if (parentFir is FirResolvedQualifier) { if (parentFir is FirResolvedQualifier) {
var classId = parentFir.classId var classId = parentFir.classId
while (unresolvedCounter > 0) { while (unresolvedCounter > 0) {
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirArrayAccessReference.kt
+1 -1
View File
@@ -20,7 +20,7 @@ class KtFirArrayAccessReference(
) : KtArrayAccessReference(expression), KtFirReference { ) : KtArrayAccessReference(expression), KtFirReference {
override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> { override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
check(this is KtFirAnalysisSession) check(this is KtFirAnalysisSession)
val fir = element.getOrBuildFirSafe<FirFunctionCall>(firResolveState) ?: return emptyList() val fir = element.getOrBuildFirSafe<FirFunctionCall>(firResolveSession) ?: return emptyList()
return fir.getCandidateSymbols().map { it.fir.buildSymbol(firSymbolBuilder) } return fir.getCandidateSymbols().map { it.fir.buildSymbol(firSymbolBuilder) }
} }
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirCollectionLiteralReference.kt
+1 -1
View File
@@ -23,7 +23,7 @@ class KtFirCollectionLiteralReference(
) : KtCollectionLiteralReference(expression), KtFirReference { ) : KtCollectionLiteralReference(expression), KtFirReference {
override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> { override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
check(this is KtFirAnalysisSession) check(this is KtFirAnalysisSession)
val fir = element.getOrBuildFirSafe<FirArrayOfCall>(firResolveState) ?: return emptyList() val fir = element.getOrBuildFirSafe<FirArrayOfCall>(firResolveSession) ?: return emptyList()
val type = fir.typeRef.coneTypeSafe<ConeClassLikeType>() ?: return listOfNotNull(arrayOfSymbol(arrayOf)) val type = fir.typeRef.coneTypeSafe<ConeClassLikeType>() ?: return listOfNotNull(arrayOfSymbol(arrayOf))
val call = arrayTypeToArrayOfCall[type.lookupTag.classId] ?: arrayOf val call = arrayTypeToArrayOfCall[type.lookupTag.classId] ?: arrayOf
return listOfNotNull(arrayOfSymbol(call)) return listOfNotNull(arrayOfSymbol(call))
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirConstructorDelegationReference.kt
+1 -1
View File
@@ -19,7 +19,7 @@ class KtFirConstructorDelegationReference(
override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> { override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
check(this is KtFirAnalysisSession) check(this is KtFirAnalysisSession)
val fir = expression.getOrBuildFirSafe<FirDelegatedConstructorCall>(firResolveState) ?: return emptyList() val fir = expression.getOrBuildFirSafe<FirDelegatedConstructorCall>(firResolveSession) ?: return emptyList()
return listOfNotNull(fir.calleeReference.getResolvedKtSymbolOfNameReference(firSymbolBuilder)) return listOfNotNull(fir.calleeReference.getResolvedKtSymbolOfNameReference(firSymbolBuilder))
} }
} }
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirDestructuringDeclarationReference.kt
+1 -1
View File
@@ -22,7 +22,7 @@ class KtFirDestructuringDeclarationReference(
override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> { override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
check(this is KtFirAnalysisSession) check(this is KtFirAnalysisSession)
val fir = expression.getOrBuildFirSafe<FirProperty>(firResolveState) ?: return emptyList() val fir = expression.getOrBuildFirSafe<FirProperty>(firResolveSession) ?: return emptyList()
return listOfNotNull( return listOfNotNull(
fir.buildSymbol(firSymbolBuilder), fir.buildSymbol(firSymbolBuilder),
getComponentNSymbol(fir) getComponentNSymbol(fir)
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirForLoopInReference.kt
+1 -1
View File
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.psi.KtForExpression
open class KtFirForLoopInReference(expression: KtForExpression) : KtForLoopInReference(expression), KtFirReference { open class KtFirForLoopInReference(expression: KtForExpression) : KtForLoopInReference(expression), KtFirReference {
override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> { override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
check(this is KtFirAnalysisSession) check(this is KtFirAnalysisSession)
val firLoop = expression.getOrBuildFirSafe<FirWhileLoop>(firResolveState) ?: return emptyList() val firLoop = expression.getOrBuildFirSafe<FirWhileLoop>(firResolveSession) ?: return emptyList()
val condition = firLoop.condition as? FirFunctionCall val condition = firLoop.condition as? FirFunctionCall
val iterator = this@KtFirForLoopInReference.run { val iterator = this@KtFirForLoopInReference.run {
val callee = (condition?.explicitReceiver as? FirQualifiedAccessExpression)?.calleeReference val callee = (condition?.explicitReceiver as? FirQualifiedAccessExpression)?.calleeReference
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/references/KtFirPropertyDelegationMethodsReference.kt
+1 -1
View File
@@ -24,7 +24,7 @@ class KtFirPropertyDelegationMethodsReference(
) : KtPropertyDelegationMethodsReference(element), KtFirReference { ) : KtPropertyDelegationMethodsReference(element), KtFirReference {
override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> { override fun KtAnalysisSession.resolveToSymbols(): Collection<KtSymbol> {
check(this is KtFirAnalysisSession) check(this is KtFirAnalysisSession)
val property = (expression.parent as? KtElement)?.getOrBuildFirSafe<FirProperty>(firResolveState) ?: return emptyList() val property = (expression.parent as? KtElement)?.getOrBuildFirSafe<FirProperty>(firResolveSession) ?: return emptyList()
if (property.delegate == null) return emptyList() if (property.delegate == null) return emptyList()
val getValueSymbol = (property.getter?.singleStatementOfType<FirReturnExpression>()?.result as? FirFunctionCall)?.getCalleeSymbol() val getValueSymbol = (property.getter?.singleStatementOfType<FirReturnExpression>()?.result as? FirFunctionCall)?.getCalleeSymbol()
val setValueSymbol = property.setter?.singleStatementOfType<FirFunctionCall>()?.getCalleeSymbol() val setValueSymbol = property.setter?.singleStatementOfType<FirFunctionCall>()?.getCalleeSymbol()
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirAnonymousFunctionSymbol.kt
+2 -2
View File
@@ -16,14 +16,14 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames
import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousFunctionSymbol
import org.jetbrains.kotlin.fir.symbols.impl.isExtension import org.jetbrains.kotlin.fir.symbols.impl.isExtension
internal class KtFirAnonymousFunctionSymbol( internal class KtFirAnonymousFunctionSymbol(
override val firSymbol: FirAnonymousFunctionSymbol, override val firSymbol: FirAnonymousFunctionSymbol,
override val resolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
private val builder: KtSymbolByFirBuilder, private val builder: KtSymbolByFirBuilder,
) : KtAnonymousFunctionSymbol(), KtFirSymbol<FirAnonymousFunctionSymbol> { ) : KtAnonymousFunctionSymbol(), KtFirSymbol<FirAnonymousFunctionSymbol> {
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirAnonymousObjectSymbol.kt
+3 -3
View File
@@ -16,18 +16,18 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointe
import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol
internal class KtFirAnonymousObjectSymbol( internal class KtFirAnonymousObjectSymbol(
override val firSymbol: FirAnonymousObjectSymbol, override val firSymbol: FirAnonymousObjectSymbol,
override val resolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
private val builder: KtSymbolByFirBuilder, private val builder: KtSymbolByFirBuilder,
) : KtAnonymousObjectSymbol(), KtFirSymbol<FirAnonymousObjectSymbol> { ) : KtAnonymousObjectSymbol(), KtFirSymbol<FirAnonymousObjectSymbol> {
override val psi: PsiElement? by cached { firSymbol.findPsi() } override val psi: PsiElement? by cached { firSymbol.findPsi() }
override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) } override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
override val superTypes: List<KtType> by cached { firSymbol.superTypesList(builder) } override val superTypes: List<KtType> by cached { firSymbol.superTypesList(builder) }
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirArrayOfSymbolProvider.kt
+1 -1
View File
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.name.StandardClassIds
object KtFirArrayOfSymbolProvider { object KtFirArrayOfSymbolProvider {
internal fun KtFirAnalysisSession.arrayOfSymbol(identifier: Name): KtFirFunctionSymbol? { internal fun KtFirAnalysisSession.arrayOfSymbol(identifier: Name): KtFirFunctionSymbol? {
val firSymbol = firResolveState.useSiteFirSession.symbolProvider.getTopLevelCallableSymbols(kotlinPackage, identifier).firstOrNull { val firSymbol = firResolveSession.useSiteFirSession.symbolProvider.getTopLevelCallableSymbols(kotlinPackage, identifier).firstOrNull {
/* choose (for byte array) /* choose (for byte array)
* public fun byteArrayOf(vararg elements: kotlin.Byte): kotlin.ByteArray * public fun byteArrayOf(vararg elements: kotlin.Byte): kotlin.ByteArray
*/ */
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirBackingFieldSymbol.kt
+2 -2
View File
@@ -14,12 +14,12 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol
internal class KtFirBackingFieldSymbol( internal class KtFirBackingFieldSymbol(
override val firSymbol: FirBackingFieldSymbol, override val firSymbol: FirBackingFieldSymbol,
override val resolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
private val builder: KtSymbolByFirBuilder private val builder: KtSymbolByFirBuilder
) : KtBackingFieldSymbol(), KtFirSymbol<FirBackingFieldSymbol> { ) : KtBackingFieldSymbol(), KtFirSymbol<FirBackingFieldSymbol> {
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirClassInitializerSymbol.kt
+2 -2
View File
@@ -13,12 +13,12 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolKind
import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousInitializerSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousInitializerSymbol
internal class KtFirClassInitializerSymbol( internal class KtFirClassInitializerSymbol(
override val firSymbol: FirAnonymousInitializerSymbol, override val firSymbol: FirAnonymousInitializerSymbol,
override val resolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
) : KtClassInitializerSymbol(), KtFirSymbol<FirAnonymousInitializerSymbol> { ) : KtClassInitializerSymbol(), KtFirSymbol<FirAnonymousInitializerSymbol> {
override val psi: PsiElement? by cached { firSymbol.findPsi() } override val psi: PsiElement? by cached { firSymbol.findPsi() }
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirConstructorSymbol.kt
+3 -3
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.fir.containingClass import org.jetbrains.kotlin.fir.containingClass
import org.jetbrains.kotlin.fir.declarations.utils.visibility import org.jetbrains.kotlin.fir.declarations.utils.visibility
@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.name.ClassId
internal class KtFirConstructorSymbol( internal class KtFirConstructorSymbol(
override val firSymbol: FirConstructorSymbol, override val firSymbol: FirConstructorSymbol,
override val resolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
private val builder: KtSymbolByFirBuilder private val builder: KtSymbolByFirBuilder
) : KtConstructorSymbol(), KtFirSymbol<FirConstructorSymbol> { ) : KtConstructorSymbol(), KtFirSymbol<FirConstructorSymbol> {
@@ -48,7 +48,7 @@ internal class KtFirConstructorSymbol(
override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility } override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility }
override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) } override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
override val containingClassIdIfNonLocal: ClassId? override val containingClassIdIfNonLocal: ClassId?
get() = withValidityAssertion { firSymbol.containingClass()?.classId?.takeUnless { it.isLocal } } get() = withValidityAssertion { firSymbol.containingClass()?.classId?.takeUnless { it.isLocal } }
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirEnumEntrySymbol.kt
+2 -2
View File
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.fir.containingClass import org.jetbrains.kotlin.fir.containingClass
import org.jetbrains.kotlin.fir.symbols.impl.FirEnumEntrySymbol import org.jetbrains.kotlin.fir.symbols.impl.FirEnumEntrySymbol
import org.jetbrains.kotlin.name.CallableId import org.jetbrains.kotlin.name.CallableId
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.name.Name
internal class KtFirEnumEntrySymbol( internal class KtFirEnumEntrySymbol(
override val firSymbol: FirEnumEntrySymbol, override val firSymbol: FirEnumEntrySymbol,
override val resolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
private val builder: KtSymbolByFirBuilder private val builder: KtSymbolByFirBuilder
) : KtEnumEntrySymbol(), KtFirSymbol<FirEnumEntrySymbol> { ) : KtEnumEntrySymbol(), KtFirSymbol<FirEnumEntrySymbol> {
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirFileSymbol.kt
+3 -3
View File
@@ -14,12 +14,12 @@ import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithDeclaration
import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointer
import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.fir.symbols.impl.FirFileSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirFileSymbol
internal class KtFirFileSymbol( internal class KtFirFileSymbol(
override val firSymbol: FirFileSymbol, override val firSymbol: FirFileSymbol,
override val resolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
) : KtFileSymbol(), KtSymbolWithDeclarations, KtFirSymbol<FirFileSymbol> { ) : KtFileSymbol(), KtSymbolWithDeclarations, KtFirSymbol<FirFileSymbol> {
override val psi: PsiElement? by cached { firSymbol.findPsi() } override val psi: PsiElement? by cached { firSymbol.findPsi() }
@@ -29,7 +29,7 @@ internal class KtFirFileSymbol(
TODO("Creating pointers for files from library is not supported yet") TODO("Creating pointers for files from library is not supported yet")
} }
override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) } override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
override fun equals(other: Any?): Boolean = symbolEquals(other) override fun equals(other: Any?): Boolean = symbolEquals(other)
override fun hashCode(): Int = symbolHashCode() override fun hashCode(): Int = symbolHashCode()
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirFunctionSymbol.kt
+3 -3
View File
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.WrongSymbolForSamConst
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.fir.containingClass import org.jetbrains.kotlin.fir.containingClass
@@ -38,7 +38,7 @@ import org.jetbrains.kotlin.name.Name
internal class KtFirFunctionSymbol( internal class KtFirFunctionSymbol(
override val firSymbol: FirNamedFunctionSymbol, override val firSymbol: FirNamedFunctionSymbol,
override val resolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
private val builder: KtSymbolByFirBuilder private val builder: KtSymbolByFirBuilder
) : KtFunctionSymbol(), KtFirSymbol<FirNamedFunctionSymbol> { ) : KtFunctionSymbol(), KtFirSymbol<FirNamedFunctionSymbol> {
@@ -57,7 +57,7 @@ internal class KtFirFunctionSymbol(
override val hasStableParameterNames: Boolean override val hasStableParameterNames: Boolean
get() = withValidityAssertion { firSymbol.fir.getHasStableParameterNames(firSymbol.moduleData.session) } get() = withValidityAssertion { firSymbol.fir.getHasStableParameterNames(firSymbol.moduleData.session) }
override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) } override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
override val isSuspend: Boolean get() = withValidityAssertion { firSymbol.isSuspend } override val isSuspend: Boolean get() = withValidityAssertion { firSymbol.isSuspend }
override val isOverride: Boolean get() = withValidityAssertion { firSymbol.isOverride } override val isOverride: Boolean get() = withValidityAssertion { firSymbol.isOverride }
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirJavaFieldSymbol.kt
+2 -2
View File
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.fir.containingClass import org.jetbrains.kotlin.fir.containingClass
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.name.Name
internal class KtFirJavaFieldSymbol( internal class KtFirJavaFieldSymbol(
override val firSymbol: FirFieldSymbol, override val firSymbol: FirFieldSymbol,
override val resolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
private val builder: KtSymbolByFirBuilder private val builder: KtSymbolByFirBuilder
) : KtJavaFieldSymbol(), KtFirSymbol<FirFieldSymbol> { ) : KtJavaFieldSymbol(), KtFirSymbol<FirFieldSymbol> {
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirKotlinPropertySymbol.kt
+3 -3
View File
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.WrongSymbolForSamConst
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.fir.containingClass import org.jetbrains.kotlin.fir.containingClass
@@ -43,7 +43,7 @@ import org.jetbrains.kotlin.name.Name
internal class KtFirKotlinPropertySymbol( internal class KtFirKotlinPropertySymbol(
override val firSymbol: FirPropertySymbol, override val firSymbol: FirPropertySymbol,
override val resolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
private val builder: KtSymbolByFirBuilder private val builder: KtSymbolByFirBuilder
) : KtKotlinPropertySymbol(), KtFirSymbol<FirPropertySymbol> { ) : KtKotlinPropertySymbol(), KtFirSymbol<FirPropertySymbol> {
@@ -78,7 +78,7 @@ internal class KtFirKotlinPropertySymbol(
override val modality: Modality get() = withValidityAssertion { firSymbol.modalityOrFinal } override val modality: Modality get() = withValidityAssertion { firSymbol.modalityOrFinal }
override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility } override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility }
override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) } override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
override val callableIdIfNonLocal: CallableId? get() = withValidityAssertion { firSymbol.getCallableIdIfNonLocal() } override val callableIdIfNonLocal: CallableId? get() = withValidityAssertion { firSymbol.getCallableIdIfNonLocal() }
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirLocalVariableSymbol.kt
+2 -2
View File
@@ -17,13 +17,13 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.Name
internal class KtFirLocalVariableSymbol( internal class KtFirLocalVariableSymbol(
override val firSymbol: FirPropertySymbol, override val firSymbol: FirPropertySymbol,
override val resolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
private val builder: KtSymbolByFirBuilder private val builder: KtSymbolByFirBuilder
) : KtLocalVariableSymbol(), ) : KtLocalVariableSymbol(),
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirNamedClassOrObjectSymbol.kt
+3 -3
View File
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.Visibilities
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.name.Name
internal class KtFirNamedClassOrObjectSymbol( internal class KtFirNamedClassOrObjectSymbol(
override val firSymbol: FirRegularClassSymbol, override val firSymbol: FirRegularClassSymbol,
override val resolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
private val builder: KtSymbolByFirBuilder private val builder: KtSymbolByFirBuilder
) : KtNamedClassOrObjectSymbol(), KtFirSymbol<FirRegularClassSymbol> { ) : KtNamedClassOrObjectSymbol(), KtFirSymbol<FirRegularClassSymbol> {
@@ -65,7 +65,7 @@ internal class KtFirNamedClassOrObjectSymbol(
else -> possiblyRawVisibility else -> possiblyRawVisibility
} }
override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) } override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
override val isInner: Boolean get() = withValidityAssertion { firSymbol.isInner } override val isInner: Boolean get() = withValidityAssertion { firSymbol.isInner }
override val isData: Boolean get() = withValidityAssertion { firSymbol.isData } override val isData: Boolean get() = withValidityAssertion { firSymbol.isData }
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirPropertyGetterSymbol.kt
+3 -3
View File
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.name.CallableId
internal class KtFirPropertyGetterSymbol( internal class KtFirPropertyGetterSymbol(
override val firSymbol: FirPropertyAccessorSymbol, override val firSymbol: FirPropertyAccessorSymbol,
override val resolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
private val builder: KtSymbolByFirBuilder, private val builder: KtSymbolByFirBuilder,
) : KtPropertyGetterSymbol(), KtFirSymbol<FirPropertyAccessorSymbol> { ) : KtPropertyGetterSymbol(), KtFirSymbol<FirPropertyAccessorSymbol> {
@@ -54,7 +54,7 @@ internal class KtFirPropertyGetterSymbol(
override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(builder) } override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(builder) }
override val receiverType: KtType? get() = withValidityAssertion { firSymbol.receiverType(builder) } override val receiverType: KtType? get() = withValidityAssertion { firSymbol.receiverType(builder) }
override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) } override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
/** /**
* Returns [CallableId] of the delegated Java method if the corresponding property of this setter is a synthetic Java property. * Returns [CallableId] of the delegated Java method if the corresponding property of this setter is a synthetic Java property.
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirPropertySetterSymbol.kt
+3 -3
View File
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.name.CallableId
internal class KtFirPropertySetterSymbol( internal class KtFirPropertySetterSymbol(
override val firSymbol: FirPropertyAccessorSymbol, override val firSymbol: FirPropertyAccessorSymbol,
override val resolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
private val builder: KtSymbolByFirBuilder, private val builder: KtSymbolByFirBuilder,
) : KtPropertySetterSymbol(), KtFirSymbol<FirPropertyAccessorSymbol> { ) : KtPropertySetterSymbol(), KtFirSymbol<FirPropertyAccessorSymbol> {
@@ -51,7 +51,7 @@ internal class KtFirPropertySetterSymbol(
override val modality: Modality get() = withValidityAssertion { firSymbol.modalityOrFinal } override val modality: Modality get() = withValidityAssertion { firSymbol.modalityOrFinal }
override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility } override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility }
override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) } override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
/** /**
* Returns [CallableId] of the delegated Java method if the corresponding property of this setter is a synthetic Java property. * Returns [CallableId] of the delegated Java method if the corresponding property of this setter is a synthetic Java property.
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirReceiverParameterSymbol.kt
+2 -2
View File
@@ -17,12 +17,12 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
internal class KtFirReceiverParameterSymbol( internal class KtFirReceiverParameterSymbol(
val firSymbol: FirCallableSymbol<*>, val firSymbol: FirCallableSymbol<*>,
val resolveState: LLFirModuleResolveState, val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
_builder: KtSymbolByFirBuilder _builder: KtSymbolByFirBuilder
) : KtReceiverParameterSymbol(), ValidityTokenOwner { ) : KtReceiverParameterSymbol(), ValidityTokenOwner {
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirSamConstructorSymbol.kt
+2 -2
View File
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames import org.jetbrains.kotlin.fir.resolve.getHasStableParameterNames
import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
import org.jetbrains.kotlin.fir.symbols.impl.isExtension import org.jetbrains.kotlin.fir.symbols.impl.isExtension
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.name.Name
internal class KtFirSamConstructorSymbol( internal class KtFirSamConstructorSymbol(
override val firSymbol: FirNamedFunctionSymbol, override val firSymbol: FirNamedFunctionSymbol,
override val resolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
private val builder: KtSymbolByFirBuilder private val builder: KtSymbolByFirBuilder
) : KtSamConstructorSymbol(), KtFirSymbol<FirNamedFunctionSymbol> { ) : KtSamConstructorSymbol(), KtFirSymbol<FirNamedFunctionSymbol> {
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirSymbol.kt
+2 -2
View File
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.KtFakeSourceElementKind
import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclaration
import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
internal interface KtFirSymbol<out S : FirBasedSymbol<*>> : KtSymbol, ValidityTokenOwner { internal interface KtFirSymbol<out S : FirBasedSymbol<*>> : KtSymbol, ValidityTokenOwner {
val firSymbol: S val firSymbol: S
abstract val resolveState: LLFirModuleResolveState val firResolveSession: LLFirResolveSession
override val origin: KtSymbolOrigin get() = firSymbol.fir.ktSymbolOrigin() override val origin: KtSymbolOrigin get() = firSymbol.fir.ktSymbolOrigin()
} }
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirSymbolProvider.kt
+19 -19
View File
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.analysis.api.fir.utils.weakRef
import org.jetbrains.kotlin.analysis.api.symbols.* import org.jetbrains.kotlin.analysis.api.symbols.*
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirOfType import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirOfType
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.resolveToFirSymbolOfType import org.jetbrains.kotlin.analysis.low.level.api.fir.api.resolveToFirSymbolOfType
@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.psi.*
internal class KtFirSymbolProvider( internal class KtFirSymbolProvider(
override val analysisSession: KtAnalysisSession, override val analysisSession: KtAnalysisSession,
firSymbolProvider: FirSymbolProvider, firSymbolProvider: FirSymbolProvider,
private val resolveState: LLFirModuleResolveState, private val firResolveSession: LLFirResolveSession,
private val firSymbolBuilder: KtSymbolByFirBuilder, private val firSymbolBuilder: KtSymbolByFirBuilder,
override val token: ValidityToken, override val token: ValidityToken,
) : KtSymbolProvider(), ValidityTokenOwner { ) : KtSymbolProvider(), ValidityTokenOwner {
@@ -41,23 +41,23 @@ internal class KtFirSymbolProvider(
) )
psi.isLoopParameter -> { psi.isLoopParameter -> {
firSymbolBuilder.variableLikeBuilder.buildLocalVariableSymbol(psi.resolveToFirSymbolOfType<FirPropertySymbol>(resolveState)) firSymbolBuilder.variableLikeBuilder.buildLocalVariableSymbol(psi.resolveToFirSymbolOfType<FirPropertySymbol>(firResolveSession))
} }
else -> { else -> {
firSymbolBuilder.variableLikeBuilder.buildValueParameterSymbol( firSymbolBuilder.variableLikeBuilder.buildValueParameterSymbol(
psi.resolveToFirSymbolOfType<FirValueParameterSymbol>(resolveState) psi.resolveToFirSymbolOfType<FirValueParameterSymbol>(firResolveSession)
) )
} }
} }
} }
override fun getFileSymbol(psi: KtFile): KtFileSymbol = withValidityAssertion { override fun getFileSymbol(psi: KtFile): KtFileSymbol = withValidityAssertion {
firSymbolBuilder.buildFileSymbol(psi.getOrBuildFirFile(resolveState).symbol) firSymbolBuilder.buildFileSymbol(psi.getOrBuildFirFile(firResolveSession).symbol)
} }
override fun getFunctionLikeSymbol(psi: KtNamedFunction): KtFunctionLikeSymbol = withValidityAssertion { override fun getFunctionLikeSymbol(psi: KtNamedFunction): KtFunctionLikeSymbol = withValidityAssertion {
when (val firSymbol = psi.resolveToFirSymbolOfType<FirFunctionSymbol<*>>(resolveState)) { when (val firSymbol = psi.resolveToFirSymbolOfType<FirFunctionSymbol<*>>(firResolveSession)) {
is FirNamedFunctionSymbol -> { is FirNamedFunctionSymbol -> {
if (firSymbol.origin == FirDeclarationOrigin.SamConstructor) { if (firSymbol.origin == FirDeclarationOrigin.SamConstructor) {
firSymbolBuilder.functionLikeBuilder.buildSamConstructorSymbol(firSymbol) firSymbolBuilder.functionLikeBuilder.buildSamConstructorSymbol(firSymbol)
@@ -72,60 +72,60 @@ internal class KtFirSymbolProvider(
override fun getConstructorSymbol(psi: KtConstructor<*>): KtConstructorSymbol = withValidityAssertion { override fun getConstructorSymbol(psi: KtConstructor<*>): KtConstructorSymbol = withValidityAssertion {
firSymbolBuilder.functionLikeBuilder.buildConstructorSymbol(psi.resolveToFirSymbolOfType<FirConstructorSymbol>(resolveState)) firSymbolBuilder.functionLikeBuilder.buildConstructorSymbol(psi.resolveToFirSymbolOfType<FirConstructorSymbol>(firResolveSession))
} }
override fun getTypeParameterSymbol(psi: KtTypeParameter): KtTypeParameterSymbol = withValidityAssertion { override fun getTypeParameterSymbol(psi: KtTypeParameter): KtTypeParameterSymbol = withValidityAssertion {
firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol(psi.resolveToFirSymbolOfType<FirTypeParameterSymbol>(resolveState)) firSymbolBuilder.classifierBuilder.buildTypeParameterSymbol(psi.resolveToFirSymbolOfType<FirTypeParameterSymbol>(firResolveSession))
} }
override fun getTypeAliasSymbol(psi: KtTypeAlias): KtTypeAliasSymbol = withValidityAssertion { override fun getTypeAliasSymbol(psi: KtTypeAlias): KtTypeAliasSymbol = withValidityAssertion {
firSymbolBuilder.classifierBuilder.buildTypeAliasSymbol(psi.resolveToFirSymbolOfType<FirTypeAliasSymbol>(resolveState)) firSymbolBuilder.classifierBuilder.buildTypeAliasSymbol(psi.resolveToFirSymbolOfType<FirTypeAliasSymbol>(firResolveSession))
} }
override fun getEnumEntrySymbol(psi: KtEnumEntry): KtEnumEntrySymbol = withValidityAssertion { override fun getEnumEntrySymbol(psi: KtEnumEntry): KtEnumEntrySymbol = withValidityAssertion {
firSymbolBuilder.buildEnumEntrySymbol(psi.resolveToFirSymbolOfType<FirEnumEntrySymbol>(resolveState)) firSymbolBuilder.buildEnumEntrySymbol(psi.resolveToFirSymbolOfType<FirEnumEntrySymbol>(firResolveSession))
} }
override fun getAnonymousFunctionSymbol(psi: KtNamedFunction): KtAnonymousFunctionSymbol = withValidityAssertion { override fun getAnonymousFunctionSymbol(psi: KtNamedFunction): KtAnonymousFunctionSymbol = withValidityAssertion {
firSymbolBuilder.functionLikeBuilder.buildAnonymousFunctionSymbol(psi.getOrBuildFirOfType(resolveState)) firSymbolBuilder.functionLikeBuilder.buildAnonymousFunctionSymbol(psi.getOrBuildFirOfType(firResolveSession))
} }
override fun getAnonymousFunctionSymbol(psi: KtFunctionLiteral): KtAnonymousFunctionSymbol = withValidityAssertion { override fun getAnonymousFunctionSymbol(psi: KtFunctionLiteral): KtAnonymousFunctionSymbol = withValidityAssertion {
firSymbolBuilder.functionLikeBuilder.buildAnonymousFunctionSymbol( firSymbolBuilder.functionLikeBuilder.buildAnonymousFunctionSymbol(
psi.resolveToFirSymbolOfType<FirAnonymousFunctionSymbol>(resolveState) psi.resolveToFirSymbolOfType<FirAnonymousFunctionSymbol>(firResolveSession)
) )
} }
override fun getVariableSymbol(psi: KtProperty): KtVariableSymbol = withValidityAssertion { override fun getVariableSymbol(psi: KtProperty): KtVariableSymbol = withValidityAssertion {
firSymbolBuilder.variableLikeBuilder.buildVariableSymbol(psi.resolveToFirSymbolOfType<FirPropertySymbol>(resolveState)) firSymbolBuilder.variableLikeBuilder.buildVariableSymbol(psi.resolveToFirSymbolOfType<FirPropertySymbol>(firResolveSession))
} }
override fun getAnonymousObjectSymbol(psi: KtObjectLiteralExpression): KtAnonymousObjectSymbol = withValidityAssertion { override fun getAnonymousObjectSymbol(psi: KtObjectLiteralExpression): KtAnonymousObjectSymbol = withValidityAssertion {
firSymbolBuilder.classifierBuilder.buildAnonymousObjectSymbol( firSymbolBuilder.classifierBuilder.buildAnonymousObjectSymbol(
psi.objectDeclaration.resolveToFirSymbolOfType<FirAnonymousObjectSymbol>(resolveState) psi.objectDeclaration.resolveToFirSymbolOfType<FirAnonymousObjectSymbol>(firResolveSession)
) )
} }
override fun getClassOrObjectSymbol(psi: KtClassOrObject): KtClassOrObjectSymbol = withValidityAssertion { override fun getClassOrObjectSymbol(psi: KtClassOrObject): KtClassOrObjectSymbol = withValidityAssertion {
firSymbolBuilder.classifierBuilder.buildClassOrObjectSymbol(psi.resolveToFirSymbolOfType<FirClassSymbol<*>>(resolveState)) firSymbolBuilder.classifierBuilder.buildClassOrObjectSymbol(psi.resolveToFirSymbolOfType<FirClassSymbol<*>>(firResolveSession))
} }
override fun getNamedClassOrObjectSymbol(psi: KtClassOrObject): KtNamedClassOrObjectSymbol? = withValidityAssertion { override fun getNamedClassOrObjectSymbol(psi: KtClassOrObject): KtNamedClassOrObjectSymbol? = withValidityAssertion {
require(psi !is KtObjectDeclaration || psi.parent !is KtObjectLiteralExpression) require(psi !is KtObjectDeclaration || psi.parent !is KtObjectLiteralExpression)
// A KtClassOrObject may also map to an FirEnumEntry. Hence, we need to return null in this case. // A KtClassOrObject may also map to an FirEnumEntry. Hence, we need to return null in this case.
if (psi is KtEnumEntry) return null if (psi is KtEnumEntry) return null
firSymbolBuilder.classifierBuilder.buildNamedClassOrObjectSymbol(psi.resolveToFirSymbolOfType<FirRegularClassSymbol>(resolveState)) firSymbolBuilder.classifierBuilder.buildNamedClassOrObjectSymbol(psi.resolveToFirSymbolOfType<FirRegularClassSymbol>(firResolveSession))
} }
override fun getPropertyAccessorSymbol(psi: KtPropertyAccessor): KtPropertyAccessorSymbol = withValidityAssertion { override fun getPropertyAccessorSymbol(psi: KtPropertyAccessor): KtPropertyAccessorSymbol = withValidityAssertion {
firSymbolBuilder.callableBuilder.buildPropertyAccessorSymbol(psi.resolveToFirSymbolOfType<FirPropertyAccessorSymbol>(resolveState)) firSymbolBuilder.callableBuilder.buildPropertyAccessorSymbol(psi.resolveToFirSymbolOfType<FirPropertyAccessorSymbol>(firResolveSession))
} }
override fun getClassInitializerSymbol(psi: KtClassInitializer): KtClassInitializerSymbol = withValidityAssertion { override fun getClassInitializerSymbol(psi: KtClassInitializer): KtClassInitializerSymbol = withValidityAssertion {
firSymbolBuilder.anonymousInitializerBuilder.buildClassInitializer( firSymbolBuilder.anonymousInitializerBuilder.buildClassInitializer(
psi.resolveToFirSymbolOfType<FirAnonymousInitializerSymbol>(resolveState) psi.resolveToFirSymbolOfType<FirAnonymousInitializerSymbol>(firResolveSession)
) )
} }
@@ -139,5 +139,5 @@ internal class KtFirSymbolProvider(
return firs.asSequence().map { firSymbol -> firSymbolBuilder.buildSymbol(firSymbol) } return firs.asSequence().map { firSymbol -> firSymbolBuilder.buildSymbol(firSymbol) }
} }
override val ROOT_PACKAGE_SYMBOL: KtPackageSymbol = KtFirPackageSymbol(FqName.ROOT, resolveState.project, token) override val ROOT_PACKAGE_SYMBOL: KtPackageSymbol = KtFirPackageSymbol(FqName.ROOT, firResolveSession.project, token)
} }
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirSyntheticJavaPropertySymbol.kt
+3 -3
View File
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Modality
import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.fir.containingClass import org.jetbrains.kotlin.fir.containingClass
@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.name.Name
internal class KtFirSyntheticJavaPropertySymbol( internal class KtFirSyntheticJavaPropertySymbol(
override val firSymbol: FirSyntheticPropertySymbol, override val firSymbol: FirSyntheticPropertySymbol,
override val resolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
private val builder: KtSymbolByFirBuilder private val builder: KtSymbolByFirBuilder
) : KtSyntheticJavaPropertySymbol(), KtFirSymbol<FirSyntheticPropertySymbol> { ) : KtSyntheticJavaPropertySymbol(), KtFirSymbol<FirSyntheticPropertySymbol> {
@@ -56,7 +56,7 @@ internal class KtFirSyntheticJavaPropertySymbol(
override val modality: Modality get() = withValidityAssertion { firSymbol.modality ?: firSymbol.invalidModalityError() } override val modality: Modality get() = withValidityAssertion { firSymbol.modality ?: firSymbol.invalidModalityError() }
override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility } override val visibility: Visibility get() = withValidityAssertion { firSymbol.visibility }
override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) } override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
override val callableIdIfNonLocal: CallableId? get() = withValidityAssertion { firSymbol.getCallableIdIfNonLocal() } override val callableIdIfNonLocal: CallableId? get() = withValidityAssertion { firSymbol.getCallableIdIfNonLocal() }
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirTypeAliasSymbol.kt
+3 -3
View File
@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.Visibilities
import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.descriptors.Visibility
import org.jetbrains.kotlin.fir.declarations.utils.visibility import org.jetbrains.kotlin.fir.declarations.utils.visibility
@@ -27,7 +27,7 @@ import org.jetbrains.kotlin.name.Name
internal class KtFirTypeAliasSymbol( internal class KtFirTypeAliasSymbol(
override val firSymbol: FirTypeAliasSymbol, override val firSymbol: FirTypeAliasSymbol,
override val resolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
private val builder: KtSymbolByFirBuilder, private val builder: KtSymbolByFirBuilder,
) : KtTypeAliasSymbol(), KtFirSymbol<FirTypeAliasSymbol> { ) : KtTypeAliasSymbol(), KtFirSymbol<FirTypeAliasSymbol> {
@@ -49,7 +49,7 @@ internal class KtFirTypeAliasSymbol(
override val expandedType: KtType by cached { builder.typeBuilder.buildKtType(firSymbol.resolvedExpandedTypeRef) } override val expandedType: KtType by cached { builder.typeBuilder.buildKtType(firSymbol.resolvedExpandedTypeRef) }
override val annotationsList: KtAnnotationsList by cached { override val annotationsList: KtAnnotationsList by cached {
KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token)
} }
override fun createPointer(): KtSymbolPointer<KtTypeAliasSymbol> { override fun createPointer(): KtSymbolPointer<KtTypeAliasSymbol> {
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirTypeParameterSymbol.kt
+2 -2
View File
@@ -15,14 +15,14 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.types.Variance import org.jetbrains.kotlin.types.Variance
internal class KtFirTypeParameterSymbol( internal class KtFirTypeParameterSymbol(
override val firSymbol: FirTypeParameterSymbol, override val firSymbol: FirTypeParameterSymbol,
override val resolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
private val builder: KtSymbolByFirBuilder private val builder: KtSymbolByFirBuilder
) : KtTypeParameterSymbol(), KtFirSymbol<FirTypeParameterSymbol> { ) : KtTypeParameterSymbol(), KtFirSymbol<FirTypeParameterSymbol> {
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/KtFirValueParameterSymbol.kt
+3 -3
View File
@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtPsiBasedSymbolPointe
import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.withValidityAssertion import org.jetbrains.kotlin.analysis.api.withValidityAssertion
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.fir.renderWithType import org.jetbrains.kotlin.fir.renderWithType
import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol
import org.jetbrains.kotlin.fir.types.arrayElementType import org.jetbrains.kotlin.fir.types.arrayElementType
@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.name.Name
internal class KtFirValueParameterSymbol( internal class KtFirValueParameterSymbol(
override val firSymbol: FirValueParameterSymbol, override val firSymbol: FirValueParameterSymbol,
override val resolveState: LLFirModuleResolveState, override val firResolveSession: LLFirResolveSession,
override val token: ValidityToken, override val token: ValidityToken,
private val builder: KtSymbolByFirBuilder private val builder: KtSymbolByFirBuilder
) : KtValueParameterSymbol(), KtFirSymbol<FirValueParameterSymbol> { ) : KtValueParameterSymbol(), KtFirSymbol<FirValueParameterSymbol> {
@@ -53,7 +53,7 @@ internal class KtFirValueParameterSymbol(
override val hasDefaultValue: Boolean get() = withValidityAssertion { firSymbol.hasDefaultValue } override val hasDefaultValue: Boolean get() = withValidityAssertion { firSymbol.hasDefaultValue }
override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, resolveState.useSiteFirSession, token) } override val annotationsList by cached { KtFirAnnotationListForDeclaration.create(firSymbol, firResolveSession.useSiteFirSession, token) }
override fun createPointer(): KtSymbolPointer<KtValueParameterSymbol> { override fun createPointer(): KtSymbolPointer<KtValueParameterSymbol> {
KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it } KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it }
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/KtFirTopLevelCallableSymbolPointer.kt
+1 -1
View File
@@ -33,5 +33,5 @@ internal abstract class KtTopLevelCallableSymbolPointer<S : KtCallableSymbol>(
} }
private fun KtFirAnalysisSession.getCallableSymbols(callableId: CallableId) = private fun KtFirAnalysisSession.getCallableSymbols(callableId: CallableId) =
firResolveState.useSiteFirSession.symbolProvider.getTopLevelCallableSymbols(callableId.packageName, callableId.callableName) firResolveSession.useSiteFirSession.symbolProvider.getTopLevelCallableSymbols(callableId.packageName, callableId.callableName)
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/symbols/pointers/pointerUtils.kt
+1 -1
View File
@@ -58,4 +58,4 @@ internal fun FirDeclaration.createSignature(): IdSignature {
} }
internal fun KtFirAnalysisSession.getClassLikeSymbol(classId: ClassId) = internal fun KtFirAnalysisSession.getClassLikeSymbol(classId: ClassId) =
firResolveState.useSiteFirSession.symbolProvider.getClassLikeSymbolByClassId(classId)?.fir firResolveSession.useSiteFirSession.symbolProvider.getClassLikeSymbolByClassId(classId)?.fir
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/utils/KtAnalysisSessionFe10BindingHolder.kt
+4 -4
View File
@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.analysis.api.symbols.KtClassLikeSymbol
import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken import org.jetbrains.kotlin.analysis.api.tokens.ValidityToken
import org.jetbrains.kotlin.analysis.api.types.KtType import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
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
@@ -29,7 +29,7 @@ class KtAnalysisSessionFe10BindingHolder private constructor(
) { ) {
val analysisSession: KtAnalysisSession get() = firAnalysisSession val analysisSession: KtAnalysisSession get() = firAnalysisSession
val firResolveState: LLFirModuleResolveState get() = firAnalysisSession.firResolveState val firResolveSession: LLFirResolveSession get() = firAnalysisSession.firResolveSession
fun buildClassLikeSymbol(fir: FirClassLikeDeclaration): KtClassLikeSymbol = fun buildClassLikeSymbol(fir: FirClassLikeDeclaration): KtClassLikeSymbol =
firAnalysisSession.firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(fir.symbol) firAnalysisSession.firSymbolBuilder.classifierBuilder.buildClassLikeSymbol(fir.symbol)
@@ -47,9 +47,9 @@ class KtAnalysisSessionFe10BindingHolder private constructor(
companion object { companion object {
@InvalidWayOfUsingAnalysisSession @InvalidWayOfUsingAnalysisSession
fun create(firResolveState: LLFirModuleResolveState, token: ValidityToken, @Suppress("UNUSED_PARAMETER") ktElement: KtElement): KtAnalysisSessionFe10BindingHolder { fun create(firResolveSession: LLFirResolveSession, token: ValidityToken, @Suppress("UNUSED_PARAMETER") ktElement: KtElement): KtAnalysisSessionFe10BindingHolder {
@Suppress("DEPRECATION") @Suppress("DEPRECATION")
val firAnalysisSession = KtFirAnalysisSession.createAnalysisSessionByResolveState(firResolveState, token) val firAnalysisSession = KtFirAnalysisSession.createAnalysisSessionByFirResolveSession(firResolveSession, token)
return KtAnalysisSessionFe10BindingHolder(firAnalysisSession) return KtAnalysisSessionFe10BindingHolder(firAnalysisSession)
} }
} }
analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/utils/ktSymbolUtils.kt
+6 -6
View File
@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.analysis.api.fir.utils
import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbol import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirSymbol
import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.LLFirBuiltinsModuleData import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.LLFirBuiltinsModuleData
import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.LLFirKtModuleBasedModuleData import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.LLFirKtModuleBasedModuleData
import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.firModuleData import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.firModuleData
@@ -25,20 +25,20 @@ val KtSymbol.firSymbol: FirBasedSymbol<*>
} }
fun FirBasedSymbol<*>.getContainingKtModule(resolveState: LLFirModuleResolveState): KtModule { fun FirBasedSymbol<*>.getContainingKtModule(firResolveSession: LLFirResolveSession): KtModule {
val target = when (this) { val target = when (this) {
is FirCallableSymbol -> { is FirCallableSymbol -> {
// callable fake overrides have use-site FirModuleData // callable fake overrides have use-site FirModuleData
dispatchReceiverClassOrNull()?.toFirRegularClassSymbol(resolveState.useSiteFirSession) ?: this dispatchReceiverClassOrNull()?.toFirRegularClassSymbol(firResolveSession.useSiteFirSession) ?: this
} }
else -> this else -> this
} }
return when (val moduleData = target.firModuleData) { return when (val moduleData = target.firModuleData) {
is LLFirKtModuleBasedModuleData -> moduleData.ktModule is LLFirKtModuleBasedModuleData -> moduleData.ktModule
is LLFirBuiltinsModuleData -> resolveState.project.getService(ProjectStructureProvider::class.java).getStdlibWithBuiltinsModule(moduleData.useSiteKtModule) is LLFirBuiltinsModuleData -> firResolveSession.project.getService(ProjectStructureProvider::class.java).getStdlibWithBuiltinsModule(moduleData.useSiteKtModule)
?: error("Builtins not found for the ${moduleData.useSiteKtModule.moduleDescription}") ?: error("Builtins not found for the ${moduleData.useSiteKtModule.moduleDescription}")
} }
} }
fun KtSymbol.getContainingKtModule(resolveState: LLFirModuleResolveState): KtModule = fun KtSymbol.getContainingKtModule(firResolveSession: LLFirResolveSession): KtModule =
firSymbol.getContainingKtModule(resolveState) firSymbol.getContainingKtModule(firResolveSession)
analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/CachingKtAnalysisSessionProvider.kt
+11 -11
View File
@@ -27,32 +27,32 @@ import kotlin.reflect.KClass
abstract class CachingKtAnalysisSessionProvider<State : Any>(private val project: Project) : KtAnalysisSessionProvider() { abstract class CachingKtAnalysisSessionProvider<State : Any>(private val project: Project) : KtAnalysisSessionProvider() {
private val cache = KtAnalysisSessionCache<Pair<State, KClass<out ValidityToken>>>(project) private val cache = KtAnalysisSessionCache<Pair<State, KClass<out ValidityToken>>>(project)
protected abstract fun getResolveState(contextElement: KtElement): State protected abstract fun getFirResolveSession(contextElement: KtElement): State
protected abstract fun getResolveState(contextSymbol: KtSymbol): State protected abstract fun getFirResolveSession(contextSymbol: KtSymbol): State
protected abstract fun createAnalysisSession( protected abstract fun createAnalysisSession(
resolveState: State, firResolveSession: State,
validityToken: ValidityToken, validityToken: ValidityToken,
): KtAnalysisSession ): KtAnalysisSession
@InvalidWayOfUsingAnalysisSession @InvalidWayOfUsingAnalysisSession
final override fun getAnalysisSession(contextElement: KtElement, factory: ValidityTokenFactory): KtAnalysisSession { final override fun getAnalysisSession(contextElement: KtElement, factory: ValidityTokenFactory): KtAnalysisSession {
val resolveState = getResolveState(contextElement) val firResolveSession = getFirResolveSession(contextElement)
return cache.getAnalysisSession(resolveState to factory.identifier) { return cache.getAnalysisSession(firResolveSession to factory.identifier) {
val validityToken = factory.create(project) val validityToken = factory.create(project)
createAnalysisSession(resolveState, validityToken) createAnalysisSession(firResolveSession, validityToken)
} }
} }
final override fun getAnalysisSessionBySymbol(contextSymbol: KtSymbol): KtAnalysisSession { final override fun getAnalysisSessionBySymbol(contextSymbol: KtSymbol): KtAnalysisSession {
val resolveState = getResolveState(contextSymbol) val firResolveSession = getFirResolveSession(contextSymbol)
val token = contextSymbol.token val token = contextSymbol.token
return getCachedAnalysisSession(resolveState, token) return getCachedAnalysisSession(firResolveSession, token)
?: createAnalysisSession(resolveState, contextSymbol.token) ?: createAnalysisSession(firResolveSession, contextSymbol.token)
} }
private fun getCachedAnalysisSession(resolveState: State, token: ValidityToken): KtAnalysisSession? { private fun getCachedAnalysisSession(firResolveSession: State, token: ValidityToken): KtAnalysisSession? {
return cache.getCachedAnalysisSession(resolveState to token::class) return cache.getCachedAnalysisSession(firResolveSession to token::class)
} }
@TestOnly @TestOnly
analysis/analysis-api-standalone/src/org/jetbrains/kotlin/analysis/api/standalone/RegisterComponentService.java
+4 -4
View File
@@ -6,13 +6,13 @@
package org.jetbrains.kotlin.analysis.api.standalone; package org.jetbrains.kotlin.analysis.api.standalone;
import com.intellij.mock.MockProject; import com.intellij.mock.MockProject;
import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveStateService; import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveSessionService;
class RegisterComponentService { class RegisterComponentService {
static void registerLLFirResolveStateService(MockProject project) { static void registerLLFirResolveSessionService(MockProject project) {
project.registerService( project.registerService(
LLFirResolveStateService.class, LLFirResolveSessionService.class,
new LLFirResolveStateService(project) new LLFirResolveSessionService(project)
); );
} }
} }
analysis/analysis-api-standalone/src/org/jetbrains/kotlin/analysis/api/standalone/StandaloneModeUtils.kt
+2 -2
View File
@@ -74,7 +74,7 @@ public fun configureApplicationEnvironment(app: MockApplication) {
* * [ClsJavaStubByVirtualFileCache] * * [ClsJavaStubByVirtualFileCache]
* * [KotlinModificationTrackerFactory] * * [KotlinModificationTrackerFactory]
* * [KotlinAnnotationsResolverFactory] * * [KotlinAnnotationsResolverFactory]
* * [LLFirResolveStateService] * * [LLfirResolveSessionService]
* * [FirSealedClassInheritorsProcessorFactory] * * [FirSealedClassInheritorsProcessorFactory]
* * [KtModuleScopeProvider] * * [KtModuleScopeProvider]
* * [ProjectStructureProvider] * * [ProjectStructureProvider]
@@ -161,7 +161,7 @@ internal fun configureProjectEnvironment(
KotlinStaticAnnotationsResolverFactory(ktFiles) KotlinStaticAnnotationsResolverFactory(ktFiles)
) )
RegisterComponentService.registerLLFirResolveStateService(project) RegisterComponentService.registerLLFirResolveSessionService(project)
project.picoContainer.registerComponentInstance( project.picoContainer.registerComponentInstance(
FirSealedClassInheritorsProcessorFactory::class.qualifiedName, FirSealedClassInheritorsProcessorFactory::class.qualifiedName,
object : FirSealedClassInheritorsProcessorFactory() { object : FirSealedClassInheritorsProcessorFactory() {
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/FirModuleResolveStateDepended.kt → analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirResolveSessionDepended.kt
+13 -13
View File
@@ -9,11 +9,11 @@ import com.intellij.openapi.project.Project
import com.intellij.openapi.roots.ProjectRootModificationTracker import com.intellij.openapi.roots.ProjectRootModificationTracker
import com.intellij.psi.util.PsiModificationTracker import com.intellij.psi.util.PsiModificationTracker
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirElementBuilder import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirElementBuilder
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.file.structure.KtToFirMapping import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.KtToFirMapping
import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirResolvableModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirResolvableResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.state.TowerProviderForElementForState import org.jetbrains.kotlin.analysis.low.level.api.fir.state.TowerProviderForElementForState
import org.jetbrains.kotlin.analysis.low.level.api.fir.util.LLFirScopeSessionProvider import org.jetbrains.kotlin.analysis.low.level.api.fir.util.LLFirScopeSessionProvider
import org.jetbrains.kotlin.analysis.project.structure.KtModule import org.jetbrains.kotlin.analysis.project.structure.KtModule
@@ -31,14 +31,14 @@ import org.jetbrains.kotlin.psi.KtElement
import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi.KtFile
import java.util.concurrent.ConcurrentHashMap import java.util.concurrent.ConcurrentHashMap
internal class FirModuleResolveStateDepended( internal class LLFirResolveSessionDepended(
val originalState: LLFirResolvableModuleResolveState, val originalFirResolveSession: LLFirResolvableResolveSession,
val towerProviderBuiltUponElement: FirTowerContextProvider, val towerProviderBuiltUponElement: FirTowerContextProvider,
private val ktToFirMapping: KtToFirMapping?, private val ktToFirMapping: KtToFirMapping?,
) : LLFirModuleResolveState() { ) : LLFirResolveSession() {
override val project: Project get() = originalState.project override val project: Project get() = originalFirResolveSession.project
override val useSiteKtModule: KtModule get() = originalState.useSiteKtModule override val useSiteKtModule: KtModule get() = originalFirResolveSession.useSiteKtModule
override val useSiteFirSession get() = originalState.useSiteFirSession override val useSiteFirSession get() = originalFirResolveSession.useSiteFirSession
private val scopeSessionProviderCache by softCachedValue( private val scopeSessionProviderCache by softCachedValue(
project, project,
@@ -55,19 +55,19 @@ internal class FirModuleResolveStateDepended(
} }
override fun getSessionFor(module: KtModule): FirSession = override fun getSessionFor(module: KtModule): FirSession =
originalState.getSessionFor(module) originalFirResolveSession.getSessionFor(module)
override fun getOrBuildFirFor(element: KtElement): FirElement? { override fun getOrBuildFirFor(element: KtElement): FirElement? {
val psi = FirElementBuilder.getPsiAsFirElementSource(element) ?: return null val psi = FirElementBuilder.getPsiAsFirElementSource(element) ?: return null
ktToFirMapping?.getFirOfClosestParent(psi, this)?.let { return it } ktToFirMapping?.getFirOfClosestParent(psi, this)?.let { return it }
return originalState.getOrBuildFirFor(element = element) return originalFirResolveSession.getOrBuildFirFor(element = element)
} }
override fun getOrBuildFirFile(ktFile: KtFile): FirFile = override fun getOrBuildFirFile(ktFile: KtFile): FirFile =
originalState.getOrBuildFirFile(ktFile) originalFirResolveSession.getOrBuildFirFile(ktFile)
override fun resolveFirToPhase(declaration: FirDeclaration, toPhase: FirResolvePhase) { override fun resolveFirToPhase(declaration: FirDeclaration, toPhase: FirResolvePhase) {
originalState.resolveFirToPhase(declaration, toPhase) originalFirResolveSession.resolveFirToPhase(declaration, toPhase)
} }
override fun getDiagnostics(element: KtElement, filter: DiagnosticCheckerFilter): List<KtPsiDiagnostic> = override fun getDiagnostics(element: KtElement, filter: DiagnosticCheckerFilter): List<KtPsiDiagnostic> =
@@ -77,7 +77,7 @@ internal class FirModuleResolveStateDepended(
TODO("Diagnostics are not implemented for depended state") TODO("Diagnostics are not implemented for depended state")
override fun resolveToFirSymbol(ktDeclaration: KtDeclaration, phase: FirResolvePhase): FirBasedSymbol<*> { override fun resolveToFirSymbol(ktDeclaration: KtDeclaration, phase: FirResolvePhase): FirBasedSymbol<*> {
return originalState.resolveToFirSymbol(ktDeclaration, phase) return originalFirResolveSession.resolveToFirSymbol(ktDeclaration, phase)
} }
override fun getTowerContextProvider(ktFile: KtFile): FirTowerContextProvider = override fun getTowerContextProvider(ktFile: KtFile): FirTowerContextProvider =
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirResolveStateService.kt
+17 -17
View File
@@ -9,12 +9,12 @@ import com.intellij.openapi.components.ServiceManager
import com.intellij.openapi.project.Project import com.intellij.openapi.project.Project
import com.intellij.openapi.roots.ProjectRootModificationTracker import com.intellij.openapi.roots.ProjectRootModificationTracker
import org.jetbrains.annotations.TestOnly import org.jetbrains.annotations.TestOnly
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.* import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.*
import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSessionProviderStorage import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSessionProviderStorage
import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirLibraryOrLibrarySourceResolvableModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirLibraryOrLibrarySourceResolvableResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirResolvableModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirResolvableResolveSession
import org.jetbrains.kotlin.analysis.project.structure.KtLibraryModule import org.jetbrains.kotlin.analysis.project.structure.KtLibraryModule
import org.jetbrains.kotlin.analysis.project.structure.KtLibrarySourceModule import org.jetbrains.kotlin.analysis.project.structure.KtLibrarySourceModule
import org.jetbrains.kotlin.analysis.project.structure.KtModule import org.jetbrains.kotlin.analysis.project.structure.KtModule
@@ -23,33 +23,33 @@ import org.jetbrains.kotlin.analysis.providers.createProjectWideOutOfBlockModifi
import org.jetbrains.kotlin.analysis.utils.caches.strongCachedValue import org.jetbrains.kotlin.analysis.utils.caches.strongCachedValue
import java.util.concurrent.ConcurrentHashMap import java.util.concurrent.ConcurrentHashMap
internal class LLFirResolveStateService(project: Project) { internal class LLFirResolveSessionService(project: Project) {
private val sessionProviderStorage = LLFirSessionProviderStorage(project) private val sessionProviderStorage = LLFirSessionProviderStorage(project)
private val stateCache by strongCachedValue( private val stateCache by strongCachedValue(
project.createProjectWideOutOfBlockModificationTracker(), project.createProjectWideOutOfBlockModificationTracker(),
ProjectRootModificationTracker.getInstance(project), ProjectRootModificationTracker.getInstance(project),
) { ) {
ConcurrentHashMap<KtModule, LLFirResolvableModuleResolveState>() ConcurrentHashMap<KtModule, LLFirResolvableResolveSession>()
} }
fun getResolveState(module: KtModule): LLFirResolvableModuleResolveState = fun getFirResolveSession(module: KtModule): LLFirResolvableResolveSession =
stateCache.computeIfAbsent(module) { createResolveStateFor(module, sessionProviderStorage) } stateCache.computeIfAbsent(module) { createFirResolveSessionFor(module, sessionProviderStorage) }
companion object { companion object {
fun getInstance(project: Project): LLFirResolveStateService = fun getInstance(project: Project): LLFirResolveSessionService =
ServiceManager.getService(project, LLFirResolveStateService::class.java) ServiceManager.getService(project, LLFirResolveSessionService::class.java)
internal fun createResolveStateFor( internal fun createFirResolveSessionFor(
useSiteKtModule: KtModule, useSiteKtModule: KtModule,
sessionProviderStorage: LLFirSessionProviderStorage, sessionProviderStorage: LLFirSessionProviderStorage,
configureSession: (LLFirSession.() -> Unit)? = null, configureSession: (LLFirSession.() -> Unit)? = null,
): LLFirResolvableModuleResolveState { ): LLFirResolvableResolveSession {
val sessionProvider = sessionProviderStorage.getSessionProvider(useSiteKtModule, configureSession) val sessionProvider = sessionProviderStorage.getSessionProvider(useSiteKtModule, configureSession)
val useSiteSession = sessionProvider.rootModuleSession val useSiteSession = sessionProvider.rootModuleSession
return when (useSiteKtModule) { return when (useSiteKtModule) {
is KtSourceModule -> { is KtSourceModule -> {
LLFirSourceModuleResolveState( LLFirSourceResolveSession(
useSiteSession.moduleComponents.globalResolveComponents, useSiteSession.moduleComponents.globalResolveComponents,
sessionProviderStorage.project, sessionProviderStorage.project,
useSiteKtModule, useSiteKtModule,
@@ -57,7 +57,7 @@ internal class LLFirResolveStateService(project: Project) {
) )
} }
is KtLibraryModule, is KtLibrarySourceModule -> { is KtLibraryModule, is KtLibrarySourceModule -> {
LLFirLibraryOrLibrarySourceResolvableModuleResolveState( LLFirLibraryOrLibrarySourceResolvableResolveSession(
useSiteSession.moduleComponents.globalResolveComponents, useSiteSession.moduleComponents.globalResolveComponents,
sessionProviderStorage.project, sessionProviderStorage.project,
useSiteKtModule, useSiteKtModule,
@@ -74,12 +74,12 @@ internal class LLFirResolveStateService(project: Project) {
} }
@TestOnly @TestOnly
fun createResolveStateForNoCaching( fun createFirResolveSessionForNoCaching(
useSiteKtModule: KtModule, useSiteKtModule: KtModule,
project: Project, project: Project,
configureSession: (LLFirSession.() -> Unit)? = null, configureSession: (LLFirSession.() -> Unit)? = null,
): LLFirModuleResolveState = ): LLFirResolveSession =
LLFirResolveStateService.createResolveStateFor( LLFirResolveSessionService.createFirResolveSessionFor(
useSiteKtModule = useSiteKtModule, useSiteKtModule = useSiteKtModule,
sessionProviderStorage = LLFirSessionProviderStorage(project), sessionProviderStorage = LLFirSessionProviderStorage(project),
configureSession = configureSession configureSession = configureSession
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/LLFirModuleResolveState.kt → analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/LLFirResolveSession.kt
+4 -1
View File
@@ -20,7 +20,10 @@ import org.jetbrains.kotlin.psi.KtDeclaration
import org.jetbrains.kotlin.psi.KtElement import org.jetbrains.kotlin.psi.KtElement
import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi.KtFile
abstract class LLFirModuleResolveState { /**
* An entry point for a FIR Low Level API resolution. Represents a project view from a use-site [KtModule].
*/
abstract class LLFirResolveSession {
abstract val project: Project abstract val project: Project
abstract val useSiteFirSession: FirSession abstract val useSiteFirSession: FirSession
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/LowLevelFirApiFacade.kt
+25 -25
View File
@@ -6,7 +6,7 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.api package org.jetbrains.kotlin.analysis.low.level.api.fir.api
import com.intellij.openapi.project.Project import com.intellij.openapi.project.Project
import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveStateService import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveSessionService
import org.jetbrains.kotlin.analysis.project.structure.KtModule import org.jetbrains.kotlin.analysis.project.structure.KtModule
import org.jetbrains.kotlin.analysis.project.structure.getKtModule import org.jetbrains.kotlin.analysis.project.structure.getKtModule
import org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic import org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic
@@ -20,18 +20,18 @@ import org.jetbrains.kotlin.psi.KtElement
import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi.KtFile
/** /**
* Returns [LLFirModuleResolveState] which corresponds to containing module * Returns [LLFirResolveSession] which corresponds to containing module
*/ */
fun KtElement.getResolveState(): LLFirModuleResolveState { fun KtElement.getFirResolveSession(): LLFirResolveSession {
val project = project val project = project
return getKtModule(project).getResolveState(project) return getKtModule(project).getFirResolveSession(project)
} }
/** /**
* Returns [LLFirModuleResolveState] which corresponds to containing module * Returns [LLFirResolveSession] which corresponds to containing module
*/ */
fun KtModule.getResolveState(project: Project): LLFirModuleResolveState = fun KtModule.getFirResolveSession(project: Project): LLFirResolveSession =
LLFirResolveStateService.getInstance(project).getResolveState(this) LLFirResolveSessionService.getInstance(project).getFirResolveSession(this)
/** /**
@@ -40,10 +40,10 @@ fun KtModule.getResolveState(project: Project): LLFirModuleResolveState =
* *
*/ */
fun KtDeclaration.resolveToFirSymbol( fun KtDeclaration.resolveToFirSymbol(
resolveState: LLFirModuleResolveState, firResolveSession: LLFirResolveSession,
phase: FirResolvePhase = FirResolvePhase.RAW_FIR, phase: FirResolvePhase = FirResolvePhase.RAW_FIR,
): FirBasedSymbol<*> { ): FirBasedSymbol<*> {
return resolveState.resolveToFirSymbol(this, phase) return firResolveSession.resolveToFirSymbol(this, phase)
} }
/** /**
@@ -54,10 +54,10 @@ fun KtDeclaration.resolveToFirSymbol(
*/ */
@Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER") @Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER")
inline fun <reified S : FirBasedSymbol<*>> KtDeclaration.resolveToFirSymbolOfType( inline fun <reified S : FirBasedSymbol<*>> KtDeclaration.resolveToFirSymbolOfType(
resolveState: LLFirModuleResolveState, firResolveSession: LLFirResolveSession,
phase: FirResolvePhase = FirResolvePhase.RAW_FIR, phase: FirResolvePhase = FirResolvePhase.RAW_FIR,
): @kotlin.internal.NoInfer S { ): @kotlin.internal.NoInfer S {
val symbol = resolveToFirSymbol(resolveState, phase) val symbol = resolveToFirSymbol(firResolveSession, phase)
if (symbol !is S) { if (symbol !is S) {
throwUnexpectedFirElementError(symbol, this, S::class) throwUnexpectedFirElementError(symbol, this, S::class)
} }
@@ -72,10 +72,10 @@ inline fun <reified S : FirBasedSymbol<*>> KtDeclaration.resolveToFirSymbolOfTyp
*/ */
@Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER") @Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER")
inline fun <reified S : FirBasedSymbol<*>> KtDeclaration.resolveToFirSymbolOfTypeSafe( inline fun <reified S : FirBasedSymbol<*>> KtDeclaration.resolveToFirSymbolOfTypeSafe(
resolveState: LLFirModuleResolveState, firResolveSession: LLFirResolveSession,
phase: FirResolvePhase = FirResolvePhase.RAW_FIR, phase: FirResolvePhase = FirResolvePhase.RAW_FIR,
): @kotlin.internal.NoInfer S? { ): @kotlin.internal.NoInfer S? {
return resolveToFirSymbol(resolveState, phase) as? S return resolveToFirSymbol(firResolveSession, phase) as? S
} }
@@ -83,18 +83,18 @@ inline fun <reified S : FirBasedSymbol<*>> KtDeclaration.resolveToFirSymbolOfTyp
* Returns a list of Diagnostics compiler finds for given [KtElement] * Returns a list of Diagnostics compiler finds for given [KtElement]
* This operation could be performance affective because it create FIleStructureElement and resolve non-local declaration into BODY phase * This operation could be performance affective because it create FIleStructureElement and resolve non-local declaration into BODY phase
*/ */
fun KtElement.getDiagnostics(resolveState: LLFirModuleResolveState, filter: DiagnosticCheckerFilter): Collection<KtPsiDiagnostic> = fun KtElement.getDiagnostics(firResolveSession: LLFirResolveSession, filter: DiagnosticCheckerFilter): Collection<KtPsiDiagnostic> =
resolveState.getDiagnostics(this, filter) firResolveSession.getDiagnostics(this, filter)
/** /**
* Returns a list of Diagnostics compiler finds for given [KtFile] * Returns a list of Diagnostics compiler finds for given [KtFile]
* This operation could be performance affective because it create FIleStructureElement and resolve non-local declaration into BODY phase * This operation could be performance affective because it create FIleStructureElement and resolve non-local declaration into BODY phase
*/ */
fun KtFile.collectDiagnosticsForFile( fun KtFile.collectDiagnosticsForFile(
resolveState: LLFirModuleResolveState, firResolveSession: LLFirResolveSession,
filter: DiagnosticCheckerFilter filter: DiagnosticCheckerFilter
): Collection<KtPsiDiagnostic> = ): Collection<KtPsiDiagnostic> =
resolveState.collectDiagnosticsForFile(this, filter) firResolveSession.collectDiagnosticsForFile(this, filter)
/** /**
* Get a [FirElement] which was created by [KtElement] * Get a [FirElement] which was created by [KtElement]
@@ -104,8 +104,8 @@ fun KtFile.collectDiagnosticsForFile(
* The `null` value is returned iff FIR tree does not have corresponding element * The `null` value is returned iff FIR tree does not have corresponding element
*/ */
fun KtElement.getOrBuildFir( fun KtElement.getOrBuildFir(
resolveState: LLFirModuleResolveState, firResolveSession: LLFirResolveSession,
): FirElement? = resolveState.getOrBuildFirFor(this) ): FirElement? = firResolveSession.getOrBuildFirFor(this)
/** /**
* Get a [FirElement] which was created by [KtElement], but only if it is subtype of [E], `null` otherwise * Get a [FirElement] which was created by [KtElement], but only if it is subtype of [E], `null` otherwise
@@ -113,8 +113,8 @@ fun KtElement.getOrBuildFir(
* This operation could be performance affective because it create FIleStructureElement and resolve non-local declaration into BODY phase * This operation could be performance affective because it create FIleStructureElement and resolve non-local declaration into BODY phase
*/ */
inline fun <reified E : FirElement> KtElement.getOrBuildFirSafe( inline fun <reified E : FirElement> KtElement.getOrBuildFirSafe(
resolveState: LLFirModuleResolveState, firResolveSession: LLFirResolveSession,
) = getOrBuildFir(resolveState) as? E ) = getOrBuildFir(firResolveSession) as? E
/** /**
* Get a [FirElement] which was created by [KtElement], but only if it is subtype of [E], throws [InvalidFirElementTypeException] otherwise * Get a [FirElement] which was created by [KtElement], but only if it is subtype of [E], throws [InvalidFirElementTypeException] otherwise
@@ -122,9 +122,9 @@ inline fun <reified E : FirElement> KtElement.getOrBuildFirSafe(
* This operation could be performance affective because it create FIleStructureElement and resolve non-local declaration into BODY phase * This operation could be performance affective because it create FIleStructureElement and resolve non-local declaration into BODY phase
*/ */
inline fun <reified E : FirElement> KtElement.getOrBuildFirOfType( inline fun <reified E : FirElement> KtElement.getOrBuildFirOfType(
resolveState: LLFirModuleResolveState, firResolveSession: LLFirResolveSession,
): E { ): E {
val fir = this.getOrBuildFir(resolveState) val fir = getOrBuildFir(firResolveSession)
if (fir is E) return fir if (fir is E) return fir
throwUnexpectedFirElementError(fir, this, E::class) throwUnexpectedFirElementError(fir, this, E::class)
} }
@@ -133,5 +133,5 @@ inline fun <reified E : FirElement> KtElement.getOrBuildFirOfType(
* Get a [FirFile] which was created by [KtElement] * Get a [FirFile] which was created by [KtElement]
* Returned [FirFile] can be resolved to any phase from [FirResolvePhase.RAW_FIR] to [FirResolvePhase.BODY_RESOLVE] * Returned [FirFile] can be resolved to any phase from [FirResolvePhase.RAW_FIR] to [FirResolvePhase.BODY_RESOLVE]
*/ */
fun KtFile.getOrBuildFirFile(resolveState: LLFirModuleResolveState): FirFile = fun KtFile.getOrBuildFirFile(firResolveSession: LLFirResolveSession): FirFile =
resolveState.getOrBuildFirFile(this) firResolveSession.getOrBuildFirFile(this)
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/LowLevelFirApiFacadeForResolveOnAir.kt
+29 -29
View File
@@ -9,7 +9,8 @@ import com.intellij.psi.util.PsiTreeUtil
import org.jetbrains.kotlin.analysis.api.impl.barebone.parentOfType import org.jetbrains.kotlin.analysis.api.impl.barebone.parentOfType
import org.jetbrains.kotlin.analysis.api.impl.barebone.parentsOfType import org.jetbrains.kotlin.analysis.api.impl.barebone.parentsOfType
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.FirModuleResolveStateDepended 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
@@ -19,7 +20,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.KtToFirMap
import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.* import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.*
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.state.LLFirResolvableModuleResolveState
import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getElementTextInContext import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getElementTextInContext
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
@@ -64,15 +64,15 @@ object LowLevelFirApiFacadeForResolveOnAir {
} }
fun <T : KtElement> onAirResolveElement( fun <T : KtElement> onAirResolveElement(
state: LLFirModuleResolveState, firResolveSession: LLFirResolveSession,
place: T, place: T,
elementToResolve: T, elementToResolve: T,
): FirElement { ): FirElement {
require(state is LLFirResolvableModuleResolveState) require(firResolveSession is LLFirResolvableResolveSession)
require(place.isPhysical) require(place.isPhysical)
val declaration = runBodyResolveOnAir( val declaration = runBodyResolveOnAir(
state = state, firResolveSession = firResolveSession,
replacement = RawFirReplacement(place, elementToResolve), replacement = RawFirReplacement(place, elementToResolve),
onAirCreatedDeclaration = true onAirCreatedDeclaration = true
) )
@@ -93,13 +93,13 @@ object LowLevelFirApiFacadeForResolveOnAir {
} }
fun onAirGetTowerContextProvider( fun onAirGetTowerContextProvider(
state: LLFirModuleResolveState, firResolveSession: LLFirResolveSession,
place: KtElement, place: KtElement,
): FirTowerContextProvider { ): FirTowerContextProvider {
require(state is LLFirResolvableModuleResolveState) require(firResolveSession is LLFirResolvableResolveSession)
return if (place is KtFile) { return if (place is KtFile) {
FileTowerProvider(place, onAirGetTowerContextForFile(state, place)) FileTowerProvider(place, onAirGetTowerContextForFile(firResolveSession, place))
} else { } else {
val validPlace = PsiTreeUtil.findFirstParent(place, false) { val validPlace = PsiTreeUtil.findFirstParent(place, false) {
RawFirReplacement.isApplicableForReplacement(it as KtElement) RawFirReplacement.isApplicableForReplacement(it as KtElement)
@@ -107,7 +107,7 @@ object LowLevelFirApiFacadeForResolveOnAir {
FirTowerDataContextAllElementsCollector().also { FirTowerDataContextAllElementsCollector().also {
runBodyResolveOnAir( runBodyResolveOnAir(
state = state, firResolveSession = firResolveSession,
collector = it, collector = it,
onAirCreatedDeclaration = false, onAirCreatedDeclaration = false,
replacement = RawFirReplacement(validPlace, validPlace), replacement = RawFirReplacement(validPlace, validPlace),
@@ -117,16 +117,16 @@ object LowLevelFirApiFacadeForResolveOnAir {
} }
private fun onAirGetTowerContextForFile( private fun onAirGetTowerContextForFile(
state: LLFirResolvableModuleResolveState, firResolveSession: LLFirResolvableResolveSession,
file: KtFile, file: KtFile,
): FirTowerDataContext { ): FirTowerDataContext {
require(file.isPhysical) require(file.isPhysical)
val session = state.getSessionFor(file.getKtModule(state.project)) as LLFirResolvableModuleSession val session = firResolveSession.getSessionFor(file.getKtModule(firResolveSession.project)) as LLFirResolvableModuleSession
val moduleComponents = session.moduleComponents val moduleComponents = session.moduleComponents
val firFile = moduleComponents.firFileBuilder.buildRawFirFileWithCaching(file) val firFile = moduleComponents.firFileBuilder.buildRawFirFileWithCaching(file)
val scopeSession = state.getScopeSessionFor(session) val scopeSession = firResolveSession.getScopeSessionFor(session)
moduleComponents.lazyFirDeclarationsResolver.lazyResolveFileDeclaration( moduleComponents.lazyFirDeclarationsResolver.lazyResolveFileDeclaration(
firFile = firFile, firFile = firFile,
scopeSession = scopeSession, scopeSession = scopeSession,
@@ -138,19 +138,19 @@ object LowLevelFirApiFacadeForResolveOnAir {
return FirTowerDataContext().addNonLocalTowerDataElements(fileScopeElements) return FirTowerDataContext().addNonLocalTowerDataElements(fileScopeElements)
} }
fun getResolveStateForDependentCopy( fun getFirResolveSessionForDependentCopy(
originalState: LLFirModuleResolveState, originalFirResolveSession: LLFirResolveSession,
originalKtFile: KtFile, originalKtFile: KtFile,
elementToAnalyze: KtElement elementToAnalyze: KtElement
): LLFirModuleResolveState { ): LLFirResolveSession {
require(originalState is LLFirResolvableModuleResolveState) require(originalFirResolveSession is LLFirResolvableResolveSession)
require(elementToAnalyze !is KtFile) { "KtFile for dependency element not supported" } require(elementToAnalyze !is KtFile) { "KtFile for dependency element not supported" }
require(!elementToAnalyze.isPhysical) { "Depended state should be build only for non-physical elements" } require(!elementToAnalyze.isPhysical) { "Depended session should be build only for non-physical elements" }
val dependencyNonLocalDeclaration = findEnclosingNonLocalDeclaration(elementToAnalyze) val dependencyNonLocalDeclaration = findEnclosingNonLocalDeclaration(elementToAnalyze)
?: return FirModuleResolveStateDepended( ?: return LLFirResolveSessionDepended(
originalState, originalFirResolveSession,
FileTowerProvider(elementToAnalyze.containingKtFile, onAirGetTowerContextForFile(originalState, originalKtFile)), FileTowerProvider(elementToAnalyze.containingKtFile, onAirGetTowerContextForFile(originalFirResolveSession, originalKtFile)),
ktToFirMapping = null ktToFirMapping = null
) )
@@ -165,14 +165,14 @@ object LowLevelFirApiFacadeForResolveOnAir {
val collector = FirTowerDataContextAllElementsCollector() val collector = FirTowerDataContextAllElementsCollector()
val copiedFirDeclaration = runBodyResolveOnAir( val copiedFirDeclaration = runBodyResolveOnAir(
originalState, originalFirResolveSession,
replacement = RawFirReplacement(sameDeclarationInOriginalFile, dependencyNonLocalDeclaration), replacement = RawFirReplacement(sameDeclarationInOriginalFile, dependencyNonLocalDeclaration),
onAirCreatedDeclaration = true, onAirCreatedDeclaration = true,
collector = collector, collector = collector,
) )
val mapping = KtToFirMapping(copiedFirDeclaration, FirElementsRecorder()) val mapping = KtToFirMapping(copiedFirDeclaration, FirElementsRecorder())
return FirModuleResolveStateDepended(originalState, collector, mapping) return LLFirResolveSessionDepended(originalFirResolveSession, collector, mapping)
} }
private fun tryResolveAsFileAnnotation( private fun tryResolveAsFileAnnotation(
@@ -202,13 +202,13 @@ object LowLevelFirApiFacadeForResolveOnAir {
} }
private fun runBodyResolveOnAir( private fun runBodyResolveOnAir(
state: LLFirResolvableModuleResolveState, firResolveSession: LLFirResolvableResolveSession,
replacement: RawFirReplacement, replacement: RawFirReplacement,
onAirCreatedDeclaration: Boolean, onAirCreatedDeclaration: Boolean,
collector: FirTowerDataContextCollector? = null, collector: FirTowerDataContextCollector? = null,
): FirElement { ): FirElement {
val nonLocalDeclaration = findEnclosingNonLocalDeclaration(replacement.from) val nonLocalDeclaration = findEnclosingNonLocalDeclaration(replacement.from)
val originalFirFile = state.getOrBuildFirFile(replacement.from.containingKtFile) val originalFirFile = firResolveSession.getOrBuildFirFile(replacement.from.containingKtFile)
if (nonLocalDeclaration == null) { if (nonLocalDeclaration == null) {
//It is possible that it is file annotation is going to resolve //It is possible that it is file annotation is going to resolve
@@ -225,7 +225,7 @@ object LowLevelFirApiFacadeForResolveOnAir {
} }
} }
val originalDeclaration = nonLocalDeclaration.getOrBuildFirOfType<FirDeclaration>(state) val originalDeclaration = nonLocalDeclaration.getOrBuildFirOfType<FirDeclaration>(firResolveSession)
val originalDesignation = originalDeclaration.collectDesignation() val originalDesignation = originalDeclaration.collectDesignation()
@@ -239,7 +239,7 @@ object LowLevelFirApiFacadeForResolveOnAir {
val isInBodyReplacement = isInBodyReplacement(nonLocalDeclaration, replacement) val isInBodyReplacement = isInBodyReplacement(nonLocalDeclaration, replacement)
return state.globalComponents.lockProvider.runCustomResolveUnderLock(originalFirFile, true) { return firResolveSession.globalComponents.lockProvider.runCustomResolveUnderLock(originalFirFile, true) {
val copiedFirDeclaration = if (isInBodyReplacement) { val copiedFirDeclaration = if (isInBodyReplacement) {
when (originalDeclaration) { when (originalDeclaration) {
is FirSimpleFunction -> is FirSimpleFunction ->
@@ -299,12 +299,12 @@ object LowLevelFirApiFacadeForResolveOnAir {
fun onAirResolveTypeInPlace( fun onAirResolveTypeInPlace(
place: KtElement, place: KtElement,
typeReference: KtTypeReference, typeReference: KtTypeReference,
state: LLFirModuleResolveState, firResolveSession: LLFirResolveSession,
): FirResolvedTypeRef { ): FirResolvedTypeRef {
val context = state.getTowerContextProvider(place.containingKtFile).getClosestAvailableParentContext(place) val context = firResolveSession.getTowerContextProvider(place.containingKtFile).getClosestAvailableParentContext(place)
?: error("TowerContext not found for ${place.getElementTextInContext()}") ?: error("TowerContext not found for ${place.getElementTextInContext()}")
val session = state.useSiteFirSession val session = firResolveSession.useSiteFirSession
val firTypeReference = buildFirUserTypeRef( val firTypeReference = buildFirUserTypeRef(
typeReference = typeReference, typeReference = typeReference,
session = session, session = session,
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/element/builder/FirElementBuilder.kt
+6 -6
View File
@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirModuleResolveCompone
import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.declarations.FirFile
import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.FileStructureElement import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.FileStructureElement
import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.declarationCanBeLazilyResolved import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.declarationCanBeLazilyResolved
import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getElementTextInContext import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getElementTextInContext
@@ -60,10 +60,10 @@ internal class FirElementBuilder(
fun getOrBuildFirFor( fun getOrBuildFirFor(
element: KtElement, element: KtElement,
state: LLFirModuleResolveState, firResolveSession: LLFirResolveSession,
): FirElement? = when (element) { ): FirElement? = when (element) {
is KtFile -> getOrBuildFirForKtFile(element) is KtFile -> getOrBuildFirForKtFile(element)
else -> getOrBuildFirForNonKtFileElement(element, state) else -> getOrBuildFirForNonKtFileElement(element, firResolveSession)
} }
private fun getOrBuildFirForKtFile(ktFile: KtFile): FirFile { private fun getOrBuildFirForKtFile(ktFile: KtFile): FirFile {
@@ -79,7 +79,7 @@ internal class FirElementBuilder(
private fun getOrBuildFirForNonKtFileElement( private fun getOrBuildFirForNonKtFileElement(
element: KtElement, element: KtElement,
state: LLFirModuleResolveState, firResolveSession: LLFirResolveSession,
): FirElement? { ): FirElement? {
require(element !is KtFile) require(element !is KtFile)
@@ -92,8 +92,8 @@ internal class FirElementBuilder(
val mappings = fileStructure.getStructureElementFor(element).mappings val mappings = fileStructure.getStructureElementFor(element).mappings
val psi = getPsiAsFirElementSource(element) ?: return null val psi = getPsiAsFirElementSource(element) ?: return null
return mappings.getFirOfClosestParent(psi, state) return mappings.getFirOfClosestParent(psi, firResolveSession)
?: state.getOrBuildFirFile(firFile) ?: firResolveSession.getOrBuildFirFile(firFile)
} }
@TestOnly @TestOnly
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/file/structure/FileStructureCache.kt
+1 -1
View File
@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.psi.KtFile
import java.util.concurrent.ConcurrentHashMap import java.util.concurrent.ConcurrentHashMap
/** /**
* Belongs to a [org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState] * Belongs to a [org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession]
*/ */
internal class FileStructureCache(private val moduleResolveComponents: LLFirModuleResolveComponents) { internal class FileStructureCache(private val moduleResolveComponents: LLFirModuleResolveComponents) {
private val cache = ConcurrentHashMap<KtFile, FileStructure>() private val cache = ConcurrentHashMap<KtFile, FileStructure>()
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/file/structure/FileStructureElement.kt
+5 -5
View File
@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
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.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir
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.diagnostics.FileDiagnosticRetriever import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.FileDiagnosticRetriever
@@ -35,7 +35,7 @@ internal class KtToFirMapping(firElement: FirElement, recorder: FirElementsRecor
private val mapping = FirElementsRecorder.recordElementsFrom(firElement, recorder) private val mapping = FirElementsRecorder.recordElementsFrom(firElement, recorder)
private val userTypeMapping = ConcurrentHashMap<KtUserType, FirElement>() private val userTypeMapping = ConcurrentHashMap<KtUserType, FirElement>()
fun getElement(ktElement: KtElement, state: LLFirModuleResolveState): FirElement? { fun getElement(ktElement: KtElement, firResolveSession: LLFirResolveSession): FirElement? {
mapping[ktElement]?.let { return it } mapping[ktElement]?.let { return it }
val userType = when (ktElement) { val userType = when (ktElement) {
@@ -49,15 +49,15 @@ internal class KtToFirMapping(firElement: FirElement, recorder: FirElementsRecor
return userTypeMapping.getOrPut(userType) { return userTypeMapping.getOrPut(userType) {
val typeReference = KtPsiFactory(ktElement.project).createType(userType.text) val typeReference = KtPsiFactory(ktElement.project).createType(userType.text)
LowLevelFirApiFacadeForResolveOnAir.onAirResolveTypeInPlace(ktElement, typeReference, state) LowLevelFirApiFacadeForResolveOnAir.onAirResolveTypeInPlace(ktElement, typeReference, firResolveSession)
} }
} }
fun getFirOfClosestParent(element: KtElement, state: LLFirModuleResolveState): FirElement? { fun getFirOfClosestParent(element: KtElement, firResolveSession: LLFirResolveSession): FirElement? {
var current: PsiElement? = element var current: PsiElement? = element
while (current != null && current !is KtFile) { while (current != null && current !is KtFile) {
if (current is KtElement) { if (current is KtElement) {
getElement(current, state)?.let { return it } getElement(current, firResolveSession)?.let { return it }
} }
current = current.parent current = current.parent
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/LLFirIdePredicateBasedProvider.kt
+3 -3
View File
@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.providers
import kotlinx.collections.immutable.PersistentList import kotlinx.collections.immutable.PersistentList
import kotlinx.collections.immutable.persistentListOf import kotlinx.collections.immutable.persistentListOf
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getFirResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.resolveToFirSymbol import org.jetbrains.kotlin.analysis.low.level.api.fir.api.resolveToFirSymbol
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.providers.KotlinAnnotationsResolver import org.jetbrains.kotlin.analysis.providers.KotlinAnnotationsResolver
@@ -72,8 +72,8 @@ internal class LLFirIdePredicateBasedProvider(
this !is KtProperty this !is KtProperty
) return null ) return null
val resolveState = this.getResolveState() val firResolveSession = this.getFirResolveSession()
return this.resolveToFirSymbol(resolveState).fir return this.resolveToFirSymbol(firResolveSession).fir
} }
override fun getOwnersOfDeclaration(declaration: FirDeclaration): List<FirBasedSymbol<*>>? { override fun getOwnersOfDeclaration(declaration: FirDeclaration): List<FirBasedSymbol<*>>? {
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/resolver/AllCandidatesResolver.kt
+7 -7
View File
@@ -6,7 +6,7 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.resolver package org.jetbrains.kotlin.analysis.low.level.api.fir.resolver
import org.jetbrains.kotlin.analysis.api.impl.barebone.parentsOfType import org.jetbrains.kotlin.analysis.api.impl.barebone.parentsOfType
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.resolveToFirSymbol import org.jetbrains.kotlin.analysis.low.level.api.fir.api.resolveToFirSymbol
import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSession
@@ -24,14 +24,14 @@ class AllCandidatesResolver(firSession: FirSession) {
private val resolutionContext = ResolutionContext(firSession, bodyResolveComponents, bodyResolveComponents.transformer.context) private val resolutionContext = ResolutionContext(firSession, bodyResolveComponents, bodyResolveComponents.transformer.context)
fun getAllCandidates( fun getAllCandidates(
resolveState: LLFirModuleResolveState, firResolveSession: LLFirResolveSession,
functionCall: FirFunctionCall, functionCall: FirFunctionCall,
calleeName: Name, calleeName: Name,
element: KtElement element: KtElement
): List<OverloadCandidate> { ): List<OverloadCandidate> {
initializeBodyResolveContext(resolveState, element) initializeBodyResolveContext(firResolveSession, element)
val firFile = element.containingKtFile.getOrBuildFirFile(resolveState) val firFile = element.containingKtFile.getOrBuildFirFile(firResolveSession)
return bodyResolveComponents.context.withFile(firFile, bodyResolveComponents) { return bodyResolveComponents.context.withFile(firFile, bodyResolveComponents) {
bodyResolveComponents.callResolver.collectAllCandidates( bodyResolveComponents.callResolver.collectAllCandidates(
functionCall, functionCall,
@@ -43,12 +43,12 @@ class AllCandidatesResolver(firSession: FirSession) {
} }
@OptIn(PrivateForInline::class, SymbolInternals::class) @OptIn(PrivateForInline::class, SymbolInternals::class)
private fun initializeBodyResolveContext(resolveState: LLFirModuleResolveState, element: KtElement) { private fun initializeBodyResolveContext(firResolveSession: LLFirResolveSession, element: KtElement) {
// Set up needed context to get all candidates. // Set up needed context to get all candidates.
val towerContext = resolveState.getTowerContextProvider(element.containingKtFile).getClosestAvailableParentContext(element) val towerContext = firResolveSession.getTowerContextProvider(element.containingKtFile).getClosestAvailableParentContext(element)
towerContext?.let { bodyResolveComponents.context.replaceTowerDataContext(it) } towerContext?.let { bodyResolveComponents.context.replaceTowerDataContext(it) }
val containingDeclarations = val containingDeclarations =
element.parentsOfType<KtDeclaration>().map { it.resolveToFirSymbol(resolveState).fir }.toList().asReversed() element.parentsOfType<KtDeclaration>().map { it.resolveToFirSymbol(firResolveSession).fir }.toList().asReversed()
bodyResolveComponents.context.containers.addAll(containingDeclarations) bodyResolveComponents.context.containers.addAll(containingDeclarations)
} }
} }
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLFirLibraryOrLibrarySourceResolvableModuleResolveState.kt → analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLFirLibraryOrLibrarySourceResolvableResolveSession.kt
+2 -2
View File
@@ -16,12 +16,12 @@ import org.jetbrains.kotlin.psi.KtElement
import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi.KtFile
internal class LLFirLibraryOrLibrarySourceResolvableModuleResolveState( internal class LLFirLibraryOrLibrarySourceResolvableResolveSession(
override val globalComponents: LLFirGlobalResolveComponents, override val globalComponents: LLFirGlobalResolveComponents,
override val project: Project, override val project: Project,
override val useSiteKtModule: KtModule, override val useSiteKtModule: KtModule,
sessionProvider: LLFirSessionProvider, sessionProvider: LLFirSessionProvider,
) : LLFirResolvableModuleResolveState(sessionProvider) { ) : LLFirResolvableResolveSession(sessionProvider) {
override fun getDiagnostics(element: KtElement, filter: DiagnosticCheckerFilter): List<KtPsiDiagnostic> = override fun getDiagnostics(element: KtElement, filter: DiagnosticCheckerFilter): List<KtPsiDiagnostic> =
emptyList() emptyList()
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLFirResolvableModuleResolveState.kt → analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLFirResolvableResolveSession.kt
+3 -3
View File
@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.state
import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirGlobalResolveComponents import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirGlobalResolveComponents
import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirModuleResolveComponents import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirModuleResolveComponents
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
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.getNonLocalContainingOrThisDeclaration import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.getNonLocalContainingOrThisDeclaration
import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.firModuleData import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.firModuleData
@@ -34,9 +34,9 @@ import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.*
internal abstract class LLFirResolvableModuleResolveState( internal abstract class LLFirResolvableResolveSession(
private val sessionProvider: LLFirSessionProvider, private val sessionProvider: LLFirSessionProvider,
) : LLFirModuleResolveState() { ) : LLFirResolveSession() {
abstract val globalComponents: LLFirGlobalResolveComponents abstract val globalComponents: LLFirGlobalResolveComponents
final override val useSiteFirSession = sessionProvider.rootModuleSession final override val useSiteFirSession = sessionProvider.rootModuleSession
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLFirSourceModuleResolveState.kt → analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLFirSourceResolveSession.kt
+2 -2
View File
@@ -20,12 +20,12 @@ import org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic
import org.jetbrains.kotlin.psi.KtElement import org.jetbrains.kotlin.psi.KtElement
import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi.KtFile
internal class LLFirSourceModuleResolveState( internal class LLFirSourceResolveSession(
override val globalComponents: LLFirGlobalResolveComponents, override val globalComponents: LLFirGlobalResolveComponents,
override val project: Project, override val project: Project,
override val useSiteKtModule: KtModule, override val useSiteKtModule: KtModule,
sessionProvider: LLFirSessionProvider, sessionProvider: LLFirSessionProvider,
) : LLFirResolvableModuleResolveState(sessionProvider) { ) : LLFirResolvableResolveSession(sessionProvider) {
override fun getDiagnostics(element: KtElement, filter: DiagnosticCheckerFilter): List<KtPsiDiagnostic> { override fun getDiagnostics(element: KtElement, filter: DiagnosticCheckerFilter): List<KtPsiDiagnostic> {
val moduleComponents = getModuleComponentsForElement(element) val moduleComponents = getModuleComponentsForElement(element)
return moduleComponents.diagnosticsCollector.getDiagnosticsFor(element, filter) return moduleComponents.diagnosticsCollector.getDiagnosticsFor(element, filter)
analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/TowerProviderForElementForState.kt
+7 -7
View File
@@ -5,26 +5,26 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.state package org.jetbrains.kotlin.analysis.low.level.api.fir.state
import org.jetbrains.kotlin.analysis.low.level.api.fir.FirModuleResolveStateDepended import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveSessionDepended
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir
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.fir.declarations.FirTowerDataContext import org.jetbrains.kotlin.fir.declarations.FirTowerDataContext
import org.jetbrains.kotlin.psi.KtElement import org.jetbrains.kotlin.psi.KtElement
internal class TowerProviderForElementForState(private val state: LLFirModuleResolveState) : FirTowerContextProvider { internal class TowerProviderForElementForState(private val firResolveSession: LLFirResolveSession) : FirTowerContextProvider {
override fun getClosestAvailableParentContext(ktElement: KtElement): FirTowerDataContext? { override fun getClosestAvailableParentContext(ktElement: KtElement): FirTowerDataContext? {
if (state is FirModuleResolveStateDepended) { if (firResolveSession is LLFirResolveSessionDepended) {
state.towerProviderBuiltUponElement firResolveSession.towerProviderBuiltUponElement
.getClosestAvailableParentContext(ktElement) .getClosestAvailableParentContext(ktElement)
?.let { return it } ?.let { return it }
return LowLevelFirApiFacadeForResolveOnAir return LowLevelFirApiFacadeForResolveOnAir
.onAirGetTowerContextProvider(state.originalState, ktElement) .onAirGetTowerContextProvider(firResolveSession.originalFirResolveSession, ktElement)
.getClosestAvailableParentContext(ktElement) .getClosestAvailableParentContext(ktElement)
} }
return LowLevelFirApiFacadeForResolveOnAir return LowLevelFirApiFacadeForResolveOnAir
.onAirGetTowerContextProvider(state, ktElement) .onAirGetTowerContextProvider(firResolveSession, ktElement)
.getClosestAvailableParentContext(ktElement) .getClosestAvailableParentContext(ktElement)
} }
} }
analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractFirLazyBodiesCalculatorTest.kt
+2 -2
View File
@@ -31,8 +31,8 @@ abstract class AbstractFirLazyBodiesCalculatorTest : AbstractLowLevelApiSingleFi
} }
override fun doTestByFileStructure(ktFile: KtFile, moduleStructure: TestModuleStructure, testServices: TestServices) { override fun doTestByFileStructure(ktFile: KtFile, moduleStructure: TestModuleStructure, testServices: TestServices) {
resolveWithClearCaches(ktFile) { resolveState -> resolveWithClearCaches(ktFile) { firResolveSession ->
val session = resolveState.useSiteFirSession val session = firResolveSession.useSiteFirSession
val provider = session.kotlinScopeProvider val provider = session.kotlinScopeProvider
val laziedFirFile = RawFirBuilder( val laziedFirFile = RawFirBuilder(
analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractFirLazyDeclarationResolveTest.kt
+8 -8
View File
@@ -5,7 +5,7 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir package org.jetbrains.kotlin.analysis.low.level.api.fir
import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceResolveSession
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
import org.jetbrains.kotlin.fir.FirRenderer import org.jetbrains.kotlin.fir.FirRenderer
@@ -53,23 +53,23 @@ abstract class AbstractFirLazyDeclarationResolveTest : AbstractLowLevelApiSingle
override fun doTestByFileStructure(ktFile: KtFile, moduleStructure: TestModuleStructure, testServices: TestServices) { override fun doTestByFileStructure(ktFile: KtFile, moduleStructure: TestModuleStructure, testServices: TestServices) {
val rendererOption = FirRenderer.RenderMode.WithDeclarationAttributes.copy(renderDeclarationResolvePhase = true) val rendererOption = FirRenderer.RenderMode.WithDeclarationAttributes.copy(renderDeclarationResolvePhase = true)
val resultBuilder = StringBuilder() val resultBuilder = StringBuilder()
resolveWithClearCaches(ktFile) { firModuleResolveState -> resolveWithClearCaches(ktFile) { firResolveSession ->
check(firModuleResolveState is LLFirSourceModuleResolveState) check(firResolveSession is LLFirSourceResolveSession)
val declarationToResolve = firModuleResolveState val declarationToResolve = firResolveSession
.getOrBuildFirFile(ktFile) .getOrBuildFirFile(ktFile)
.findResolveMe() .findResolveMe()
for (currentPhase in FirResolvePhase.values()) { for (currentPhase in FirResolvePhase.values()) {
if (currentPhase == FirResolvePhase.SEALED_CLASS_INHERITORS) continue if (currentPhase == FirResolvePhase.SEALED_CLASS_INHERITORS) continue
declarationToResolve.ensureResolved(currentPhase) declarationToResolve.ensureResolved(currentPhase)
val firFile = firModuleResolveState.getOrBuildFirFile(ktFile) val firFile = firResolveSession.getOrBuildFirFile(ktFile)
resultBuilder.append("\n${currentPhase.name}:\n") resultBuilder.append("\n${currentPhase.name}:\n")
resultBuilder.append(firFile.render(rendererOption)) resultBuilder.append(firFile.render(rendererOption))
} }
} }
resolveWithClearCaches(ktFile) { firModuleResolveState -> resolveWithClearCaches(ktFile) { firResolveSession ->
check(firModuleResolveState is LLFirSourceModuleResolveState) check(firResolveSession is LLFirSourceResolveSession)
val firFile = firModuleResolveState.getOrBuildFirFile(ktFile) val firFile = firResolveSession.getOrBuildFirFile(ktFile)
firFile.ensureResolved(FirResolvePhase.BODY_RESOLVE) firFile.ensureResolved(FirResolvePhase.BODY_RESOLVE)
resultBuilder.append("\nFILE RAW TO BODY:\n") resultBuilder.append("\nFILE RAW TO BODY:\n")
resultBuilder.append(firFile.render(rendererOption)) resultBuilder.append(firFile.render(rendererOption))
analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/AbstractFirOnAirResolveTest.kt
+4 -4
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 org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LowLevelFirApiFacadeForResolveOnAir
import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceResolveSession
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.FirRenderer import org.jetbrains.kotlin.fir.FirRenderer
import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.render
@@ -32,9 +32,9 @@ abstract class AbstractFirOnAirResolveTest : AbstractLowLevelApiSingleFileTest()
check(place::class == onAir::class) check(place::class == onAir::class)
resolveWithClearCaches(ktFile) { resolveState -> resolveWithClearCaches(ktFile) { firResolveSession ->
check(resolveState is LLFirSourceModuleResolveState) check(firResolveSession is LLFirSourceResolveSession)
val firElement = LowLevelFirApiFacadeForResolveOnAir.onAirResolveElement(resolveState, place, onAir) val firElement = LowLevelFirApiFacadeForResolveOnAir.onAirResolveElement(firResolveSession, place, onAir)
val rendered = firElement.render(FirRenderer.RenderMode.WithResolvePhases) val rendered = firElement.render(FirRenderer.RenderMode.WithResolvePhases)
testServices.assertions.assertEqualsToTestDataFileSibling(rendered) testServices.assertions.assertEqualsToTestDataFileSibling(rendered)
} }
analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/AbstractCompilerBasedTestForFir.kt
+5 -5
View File
@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile
import org.jetbrains.kotlin.analysis.low.level.api.fir.createResolveStateForNoCaching import org.jetbrains.kotlin.analysis.low.level.api.fir.createFirResolveSessionForNoCaching
import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirLazyTransformer
import org.jetbrains.kotlin.analysis.test.framework.AbstractCompilerBasedTest import org.jetbrains.kotlin.analysis.test.framework.AbstractCompilerBasedTest
import org.jetbrains.kotlin.analysis.test.framework.base.registerAnalysisApiBaseTestServices import org.jetbrains.kotlin.analysis.test.framework.base.registerAnalysisApiBaseTestServices
@@ -67,21 +67,21 @@ abstract class AbstractCompilerBasedTestForFir : AbstractCompilerBasedTest() {
val ktModule = moduleInfoProvider.getModule(module.name) as KtSourceModuleByCompilerConfiguration val ktModule = moduleInfoProvider.getModule(module.name) as KtSourceModuleByCompilerConfiguration
val project = testServices.compilerConfigurationProvider.getProject(module) val project = testServices.compilerConfigurationProvider.getProject(module)
val resolveState = createResolveStateForNoCaching(ktModule, project) val firResolveSession = createFirResolveSessionForNoCaching(ktModule, project)
val allFirFiles = val allFirFiles =
module.files.filter { it.isKtFile }.zip( module.files.filter { it.isKtFile }.zip(
ktModule.psiFiles ktModule.psiFiles
.filterIsInstance<KtFile>() .filterIsInstance<KtFile>()
.map { psiFile -> psiFile.getOrBuildFirFile(resolveState) } .map { psiFile -> psiFile.getOrBuildFirFile(firResolveSession) }
) )
val diagnosticCheckerFilter = if (FirDiagnosticsDirectives.WITH_EXTENDED_CHECKERS in module.directives) { val diagnosticCheckerFilter = if (FirDiagnosticsDirectives.WITH_EXTENDED_CHECKERS in module.directives) {
DiagnosticCheckerFilter.EXTENDED_AND_COMMON_CHECKERS DiagnosticCheckerFilter.EXTENDED_AND_COMMON_CHECKERS
} else DiagnosticCheckerFilter.ONLY_COMMON_CHECKERS } else DiagnosticCheckerFilter.ONLY_COMMON_CHECKERS
val analyzerFacade = LowLevelFirAnalyzerFacade(resolveState, allFirFiles.toMap(), diagnosticCheckerFilter) val analyzerFacade = LowLevelFirAnalyzerFacade(firResolveSession, allFirFiles.toMap(), diagnosticCheckerFilter)
return LowLevelFirOutputArtifact(resolveState.useSiteFirSession, analyzerFacade) return LowLevelFirOutputArtifact(firResolveSession.useSiteFirSession, analyzerFacade)
} }
} }
analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/LowLevelFirAnalyzerFacade.kt
+3 -3
View File
@@ -6,7 +6,7 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based package org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDiagnosticsForFile import org.jetbrains.kotlin.analysis.low.level.api.fir.api.collectDiagnosticsForFile
import org.jetbrains.kotlin.diagnostics.KtDiagnostic import org.jetbrains.kotlin.diagnostics.KtDiagnostic
import org.jetbrains.kotlin.fir.AbstractFirAnalyzerFacade import org.jetbrains.kotlin.fir.AbstractFirAnalyzerFacade
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.psi2ir.generators.GeneratorExtensions
import org.jetbrains.kotlin.test.model.TestFile import org.jetbrains.kotlin.test.model.TestFile
class LowLevelFirAnalyzerFacade( class LowLevelFirAnalyzerFacade(
val resolveState: LLFirModuleResolveState, val firResolveSession: LLFirResolveSession,
val allFirFiles: Map<TestFile, FirFile>, val allFirFiles: Map<TestFile, FirFile>,
private val diagnosticCheckerFilter: DiagnosticCheckerFilter, private val diagnosticCheckerFilter: DiagnosticCheckerFilter,
) : AbstractFirAnalyzerFacade() { ) : AbstractFirAnalyzerFacade() {
@@ -33,7 +33,7 @@ class LowLevelFirAnalyzerFacade(
findSealedInheritors() findSealedInheritors()
return allFirFiles.values.associateWith { firFile -> return allFirFiles.values.associateWith { firFile ->
val ktFile = firFile.psi as KtFile val ktFile = firFile.psi as KtFile
val diagnostics = ktFile.collectDiagnosticsForFile(resolveState, diagnosticCheckerFilter) val diagnostics = ktFile.collectDiagnosticsForFile(firResolveSession, diagnosticCheckerFilter)
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
diagnostics.toList() as List<KtDiagnostic> diagnostics.toList() as List<KtDiagnostic>
} }
analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/compiler/based/SealedClassesInheritorsCaclulatorPreAnalysisHandler.kt
+3 -3
View File
@@ -6,7 +6,7 @@
package org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based package org.jetbrains.kotlin.analysis.low.level.api.fir.compiler.based
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getFirResolveSession
import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider
import org.jetbrains.kotlin.analysis.test.framework.project.structure.ktModuleProvider import org.jetbrains.kotlin.analysis.test.framework.project.structure.ktModuleProvider
import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.declarations.FirFile
@@ -41,8 +41,8 @@ class SealedClassesInheritorsCaclulatorPreAnalysisHandler(
val allFirFiles = mutableListOf<FirFile>() val allFirFiles = mutableListOf<FirFile>()
ktFiles.forEach { ktFile -> ktFiles.forEach { ktFile ->
val ktModule = ktModuleProvider.getKtModuleForKtElement(ktFile) val ktModule = ktModuleProvider.getKtModuleForKtElement(ktFile)
val resolveState = ktModule.getResolveState(project) val firResolveSession = ktModule.getFirResolveSession(project)
allFirFiles.add(ktFile.getOrBuildFirFile(resolveState)) allFirFiles.add(ktFile.getOrBuildFirFile(firResolveSession))
} }
allFirFiles.groupBy { it.moduleData.session }.forEach { (session, firFiles) -> allFirFiles.groupBy { it.moduleData.session }.forEach { (session, firFiles) ->
for (firFile in firFiles) { for (firFile in firFiles) {
analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/AbstractDiagnosticTraversalCounterTest.kt
+3 -3
View File
@@ -41,11 +41,11 @@ abstract class AbstractDiagnosticTraversalCounterTest : AbstractLowLevelApiSing
@OptIn(SessionConfiguration::class) @OptIn(SessionConfiguration::class)
register(BeforeElementDiagnosticCollectionHandler::class, handler) register(BeforeElementDiagnosticCollectionHandler::class, handler)
} }
) { resolveState -> ) { firResolveSession ->
// we should get diagnostics before we resolve the whole file by ktFile.getOrBuildFir // we should get diagnostics before we resolve the whole file by ktFile.getOrBuildFir
ktFile.collectDiagnosticsForFile(resolveState, DiagnosticCheckerFilter.ONLY_COMMON_CHECKERS) ktFile.collectDiagnosticsForFile(firResolveSession, DiagnosticCheckerFilter.ONLY_COMMON_CHECKERS)
val firFile = ktFile.getOrBuildFirOfType<FirFile>(resolveState) val firFile = ktFile.getOrBuildFirOfType<FirFile>(firResolveSession)
val errorElements = collectErrorElements(firFile, handler) val errorElements = collectErrorElements(firFile, handler)
analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/AbstractFirContextCollectionTest.kt
+6 -7
View File
@@ -11,11 +11,10 @@ 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.ImplicitReceiverStack import org.jetbrains.kotlin.fir.resolve.ImplicitReceiverStack
import org.jetbrains.kotlin.fir.resolve.SessionHolderImpl import org.jetbrains.kotlin.fir.resolve.SessionHolderImpl
import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter import org.jetbrains.kotlin.analysis.low.level.api.fir.api.DiagnosticCheckerFilter
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getDiagnostics import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getDiagnostics
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getResolveState
import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.BeforeElementDiagnosticCollectionHandler import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.BeforeElementDiagnosticCollectionHandler
import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.fir.PersistenceContextCollector import org.jetbrains.kotlin.analysis.low.level.api.fir.diagnostics.fir.PersistenceContextCollector
import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.FileStructureElement import org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.FileStructureElement
@@ -43,19 +42,19 @@ abstract class AbstractFirContextCollectionTest : AbstractLowLevelApiSingleFileT
@OptIn(SessionConfiguration::class) @OptIn(SessionConfiguration::class)
register(BeforeElementDiagnosticCollectionHandler::class, handler) register(BeforeElementDiagnosticCollectionHandler::class, handler)
} }
) { resolveState -> ) { firResolveSession ->
check(resolveState is LLFirSourceModuleResolveState) check(firResolveSession is LLFirSourceResolveSession)
val session = resolveState.getSessionFor(ktFile.getKtModule()) as LLFirResolvableModuleSession val session = firResolveSession.getSessionFor(ktFile.getKtModule()) as LLFirResolvableModuleSession
val fileStructureCache = session.moduleComponents.fileStructureCache val fileStructureCache = session.moduleComponents.fileStructureCache
val fileStructure = fileStructureCache.getFileStructure(ktFile) val fileStructure = fileStructureCache.getFileStructure(ktFile)
val allStructureElements = fileStructure.getAllStructureElements() val allStructureElements = fileStructure.getAllStructureElements()
handler.elementsToCheckContext = allStructureElements.map { it.getFirDeclaration() } handler.elementsToCheckContext = allStructureElements.map { it.getFirDeclaration() }
handler.firFile = ktFile.getOrBuildFirFile(resolveState) handler.firFile = ktFile.getOrBuildFirFile(firResolveSession)
ktFile.getDiagnostics(resolveState, DiagnosticCheckerFilter.ONLY_COMMON_CHECKERS) ktFile.getDiagnostics(firResolveSession, DiagnosticCheckerFilter.ONLY_COMMON_CHECKERS)
} }
} }
analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/file/structure/AbstractFileStructureTest.kt
+4 -4
View File
@@ -9,8 +9,8 @@ import com.intellij.psi.PsiComment
import com.intellij.psi.PsiElement import com.intellij.psi.PsiElement
import com.intellij.psi.PsiElementVisitor import com.intellij.psi.PsiElementVisitor
import com.intellij.psi.impl.source.tree.LeafPsiElement import com.intellij.psi.impl.source.tree.LeafPsiElement
import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceResolveSession
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getFirResolveSession
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.test.base.AbstractLowLevelApiSingleFileTest import org.jetbrains.kotlin.analysis.low.level.api.fir.test.base.AbstractLowLevelApiSingleFileTest
import org.jetbrains.kotlin.analysis.project.structure.getKtModule import org.jetbrains.kotlin.analysis.project.structure.getKtModule
@@ -87,8 +87,8 @@ abstract class AbstractFileStructureTest : AbstractLowLevelApiSingleFileTest() {
} }
private fun KtFile.getFileStructure(): FileStructure { private fun KtFile.getFileStructure(): FileStructure {
val moduleResolveState = getResolveState() as LLFirSourceModuleResolveState val moduleFirResolveSession = getFirResolveSession() as LLFirSourceResolveSession
val session = moduleResolveState.getSessionFor(getKtModule()) as LLFirResolvableModuleSession val session = moduleFirResolveSession.getSessionFor(getKtModule()) as LLFirResolvableModuleSession
return session.moduleComponents.fileStructureCache.getFileStructure(this) return session.moduleComponents.fileStructureCache.getFileStructure(this)
} }
analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/firTestUtils.kt
+4 -4
View File
@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousInitializerSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirFileSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirFileSymbol
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirModuleResolveState import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
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.project.structure.getKtModule import org.jetbrains.kotlin.analysis.project.structure.getKtModule
import org.jetbrains.kotlin.psi.KtElement import org.jetbrains.kotlin.psi.KtElement
@@ -37,9 +37,9 @@ internal fun FirDeclaration.name(): String = symbol.name()
internal inline fun <R> resolveWithClearCaches( internal inline fun <R> resolveWithClearCaches(
context: KtElement, context: KtElement,
noinline configureSession: LLFirSession.() -> Unit = {}, noinline configureSession: LLFirSession.() -> Unit = {},
action: (LLFirModuleResolveState) -> R, action: (LLFirResolveSession) -> R,
): R { ): R {
val project = context.project val project = context.project
val resolveState = createResolveStateForNoCaching(context.getKtModule(project), project, configureSession) val firResolveSession = createFirResolveSessionForNoCaching(context.getKtModule(project), project, configureSession)
return action(resolveState) return action(firResolveSession)
} }
analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/resolve/AbstractInnerDeclarationsResolvePhaseTest.kt
+2 -2
View File
@@ -19,8 +19,8 @@ import org.jetbrains.kotlin.test.services.assertions
abstract class AbstractInnerDeclarationsResolvePhaseTest : AbstractLowLevelApiSingleFileTest() { abstract class AbstractInnerDeclarationsResolvePhaseTest : AbstractLowLevelApiSingleFileTest() {
override fun doTestByFileStructure(ktFile: KtFile, moduleStructure: TestModuleStructure, testServices: TestServices) { override fun doTestByFileStructure(ktFile: KtFile, moduleStructure: TestModuleStructure, testServices: TestServices) {
resolveWithClearCaches(ktFile) { resolveState -> resolveWithClearCaches(ktFile) { firResolveSession ->
val firFile = ktFile.getOrBuildFirOfType<FirFile>(resolveState) val firFile = ktFile.getOrBuildFirOfType<FirFile>(firResolveSession)
val actual = firFile.render(FirRenderer.RenderMode.WithResolvePhases) val actual = firFile.render(FirRenderer.RenderMode.WithResolvePhases)
testServices.assertions.assertEqualsToTestDataFileSibling(actual, extension = ".fir.txt") testServices.assertions.assertEqualsToTestDataFileSibling(actual, extension = ".fir.txt")
} }
analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/test/base/AnalysisApiFirTestServiceRegistrar.kt
+2 -2
View File
@@ -12,7 +12,7 @@ import com.intellij.psi.impl.PsiElementFinderImpl
import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
import org.jetbrains.kotlin.analysis.api.KtAnalysisSessionProvider import org.jetbrains.kotlin.analysis.api.KtAnalysisSessionProvider
import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSessionProvider import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSessionProvider
import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveStateService import org.jetbrains.kotlin.analysis.low.level.api.fir.LLFirResolveSessionService
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.FirSealedClassInheritorsProcessorFactory import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.FirSealedClassInheritorsProcessorFactory
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.PackagePartProviderFactory import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.PackagePartProviderFactory
import org.jetbrains.kotlin.analysis.low.level.api.fir.services.LLFirSealedClassInheritorsProcessorFactoryForTests import org.jetbrains.kotlin.analysis.low.level.api.fir.services.LLFirSealedClassInheritorsProcessorFactoryForTests
@@ -41,7 +41,7 @@ object AnalysisApiFirTestServiceRegistrar : AnalysisApiTestServiceRegistrar() {
project.apply { project.apply {
registerService(KtAnalysisSessionProvider::class.java, KtFirAnalysisSessionProvider(this)) registerService(KtAnalysisSessionProvider::class.java, KtFirAnalysisSessionProvider(this))
registerService(FirSealedClassInheritorsProcessorFactory::class.java, LLFirSealedClassInheritorsProcessorFactoryForTests()) registerService(FirSealedClassInheritorsProcessorFactory::class.java, LLFirSealedClassInheritorsProcessorFactoryForTests())
registerService(LLFirResolveStateService::class.java) registerService(LLFirResolveSessionService::class.java)
registerService(PackagePartProviderFactory::class.java, PackagePartProviderTestImpl(testServices)) registerService(PackagePartProviderFactory::class.java, PackagePartProviderTestImpl(testServices))
registerService(SymbolLightClassFacadeCache::class.java) registerService(SymbolLightClassFacadeCache::class.java)