From 1293eb0fabb4a355988af5d0454e39b9eb28c5e2 Mon Sep 17 00:00:00 2001 From: Yan Zhulanow Date: Fri, 15 Sep 2023 22:36:03 +0900 Subject: [PATCH] [LL API] Rename 'KtModuleKind' to 'KtModuleResolutionStrategy' MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The word "kind" is ambiguous – users might assume the kind is somehow related to 'KtSourceModule'/'KtScriptModule'. --- .../api/fir/LLFirResolveSessionDepended.kt | 2 +- .../level/api/fir/LLFirResolveStateService.kt | 54 +++++++++--------- .../level/api/fir/api/LLFirResolveSession.kt | 4 +- .../state/LLFirResolvableResolveSession.kt | 16 +++--- .../api/fir/state/LLModuleKindProvider.kt | 46 --------------- .../LLModuleResolutionStrategyProvider.kt | 56 +++++++++++++++++++ 6 files changed, 94 insertions(+), 84 deletions(-) delete mode 100644 analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLModuleKindProvider.kt create mode 100644 analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLModuleResolutionStrategyProvider.kt diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirResolveSessionDepended.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirResolveSessionDepended.kt index 978a460e701..2913a900052 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirResolveSessionDepended.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirResolveSessionDepended.kt @@ -47,7 +47,7 @@ internal class LLFirResolveSessionDepended( private val ktToFirMapping: KtToFirMapping?, ) : LLFirResolveSession( originalFirResolveSession.moduleProvider, - originalFirResolveSession.moduleKindProvider, + originalFirResolveSession.resolutionStrategyProvider, originalFirResolveSession.sessionProvider, LLDependedScopeSessionProvider(originalFirResolveSession.project), LLDependedDiagnosticProvider diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirResolveStateService.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirResolveStateService.kt index ac121e36949..42113fc27fc 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirResolveStateService.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirResolveStateService.kt @@ -11,13 +11,13 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirLibraryOrLibrarySourceResolvableModuleSession import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSession import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSessionCache -import org.jetbrains.kotlin.analysis.low.level.api.fir.state.KtModuleKind +import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLModuleResolutionStrategy import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLDiagnosticProvider import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLEmptyDiagnosticProvider import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirResolvableResolveSession -import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLModuleKindProvider +import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLModuleResolutionStrategyProvider import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLModuleProvider -import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLSimpleResolvableModuleKindProvider +import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLSimpleResolutionStrategyProvider import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLSessionProvider import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLSourceDiagnosticProvider import org.jetbrains.kotlin.analysis.low.level.api.fir.util.errorWithFirSpecificEntries @@ -43,28 +43,28 @@ class LLFirResolveSessionService(project: Project) { private fun create(module: KtModule, factory: (KtModule) -> LLFirSession): LLFirResolvableResolveSession { val moduleProvider = LLModuleProvider(module) val sessionProvider = LLSessionProvider(module, factory) - val moduleKindProvider = createModuleKindProvider(module, moduleProvider) + val resolutionStrategyProvider = createResolutionStrategyProvider(module, moduleProvider) val diagnosticProvider = createDiagnosticProvider(moduleProvider, sessionProvider) - return LLFirResolvableResolveSession(moduleProvider, moduleKindProvider, sessionProvider, diagnosticProvider) + return LLFirResolvableResolveSession(moduleProvider, resolutionStrategyProvider, sessionProvider, diagnosticProvider) } - private fun createModuleKindProvider(module: KtModule, moduleProvider: LLModuleProvider): LLModuleKindProvider { + private fun createResolutionStrategyProvider(module: KtModule, moduleProvider: LLModuleProvider): LLModuleResolutionStrategyProvider { return when (module) { - is KtSourceModule -> LLSourceModuleKindProvider - is KtLibraryModule, is KtLibrarySourceModule -> LLLibraryModuleKindProvider(module) - is KtScriptModule -> LLScriptModuleKindProvider(module) + is KtSourceModule -> LLSourceModuleResolutionStrategyProvider + is KtLibraryModule, is KtLibrarySourceModule -> LLLibraryModuleResolutionStrategyProvider(module) + is KtScriptModule -> LLScriptModuleResolutionStrategyProvider(module) is KtCodeFragmentModule -> { val contextElement = module.codeFragment.context if (contextElement != null) { val contextModule = moduleProvider.getModule(contextElement) - val contextModuleKindProvider = createModuleKindProvider(contextModule, moduleProvider) - LLCodeFragmentKindProvider(contextModuleKindProvider) + val contextResolutionStrategyProvider = createResolutionStrategyProvider(contextModule, moduleProvider) + LLCodeFragmentResolutionStrategyProvider(contextResolutionStrategyProvider) } else { - LLSimpleResolvableModuleKindProvider(module) + LLSimpleResolutionStrategyProvider(module) } } - is KtNotUnderContentRootModule -> LLSimpleResolvableModuleKindProvider(module) + is KtNotUnderContentRootModule -> LLSimpleResolutionStrategyProvider(module) else -> { errorWithFirSpecificEntries("Unexpected ${module::class.java}") { withEntry("module", module) { it.moduleDescription } @@ -88,37 +88,37 @@ class LLFirResolveSessionService(project: Project) { } } -private object LLSourceModuleKindProvider : LLModuleKindProvider { - override fun getKind(module: KtModule): KtModuleKind { +private object LLSourceModuleResolutionStrategyProvider : LLModuleResolutionStrategyProvider { + override fun getKind(module: KtModule): LLModuleResolutionStrategy { return when (module) { - is KtSourceModule -> KtModuleKind.RESOLVABLE_MODULE - is KtBuiltinsModule, is KtLibraryModule -> KtModuleKind.BINARY_MODULE + is KtSourceModule -> LLModuleResolutionStrategy.LAZY + is KtBuiltinsModule, is KtLibraryModule -> LLModuleResolutionStrategy.STATIC else -> unexpectedElementError("module", module) } } } -private class LLLibraryModuleKindProvider(private val useSiteModule: KtModule) : LLModuleKindProvider { - override fun getKind(module: KtModule): KtModuleKind { +private class LLLibraryModuleResolutionStrategyProvider(private val useSiteModule: KtModule) : LLModuleResolutionStrategyProvider { + override fun getKind(module: KtModule): LLModuleResolutionStrategy { LLFirLibraryOrLibrarySourceResolvableModuleSession.checkIsValidKtModule(module) - return if (module == useSiteModule) KtModuleKind.RESOLVABLE_MODULE else KtModuleKind.BINARY_MODULE + return if (module == useSiteModule) LLModuleResolutionStrategy.LAZY else LLModuleResolutionStrategy.STATIC } } -private class LLScriptModuleKindProvider(private val useSiteModule: KtModule) : LLModuleKindProvider { - override fun getKind(module: KtModule): KtModuleKind { +private class LLScriptModuleResolutionStrategyProvider(private val useSiteModule: KtModule) : LLModuleResolutionStrategyProvider { + override fun getKind(module: KtModule): LLModuleResolutionStrategy { return when (module) { - useSiteModule, is KtSourceModule -> KtModuleKind.RESOLVABLE_MODULE - is KtBuiltinsModule, is KtLibraryModule -> KtModuleKind.BINARY_MODULE + useSiteModule, is KtSourceModule -> LLModuleResolutionStrategy.LAZY + is KtBuiltinsModule, is KtLibraryModule -> LLModuleResolutionStrategy.STATIC else -> unexpectedElementError("module", module) } } } -private class LLCodeFragmentKindProvider(private val delegate: LLModuleKindProvider) : LLModuleKindProvider { - override fun getKind(module: KtModule): KtModuleKind { +private class LLCodeFragmentResolutionStrategyProvider(private val delegate: LLModuleResolutionStrategyProvider) : LLModuleResolutionStrategyProvider { + override fun getKind(module: KtModule): LLModuleResolutionStrategy { return when (module) { - is KtCodeFragmentModule -> KtModuleKind.RESOLVABLE_MODULE + is KtCodeFragmentModule -> LLModuleResolutionStrategy.LAZY else -> delegate.getKind(module) } } diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/LLFirResolveSession.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/LLFirResolveSession.kt index 1bc7f5957e7..d572eed5fcd 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/LLFirResolveSession.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/LLFirResolveSession.kt @@ -10,7 +10,7 @@ import com.intellij.psi.PsiElement import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.FirTowerContextProvider import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSession import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLDiagnosticProvider -import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLModuleKindProvider +import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLModuleResolutionStrategyProvider import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLModuleProvider import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLScopeSessionProvider import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLSessionProvider @@ -34,7 +34,7 @@ import org.jetbrains.kotlin.psi.KtFile */ abstract class LLFirResolveSession( val moduleProvider: LLModuleProvider, - val moduleKindProvider: LLModuleKindProvider, + val resolutionStrategyProvider: LLModuleResolutionStrategyProvider, val sessionProvider: LLSessionProvider, val scopeSessionProvider: LLScopeSessionProvider, val diagnosticProvider: LLDiagnosticProvider diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLFirResolvableResolveSession.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLFirResolvableResolveSession.kt index a8a4e246a86..44c4e941da7 100644 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLFirResolvableResolveSession.kt +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLFirResolvableResolveSession.kt @@ -33,12 +33,12 @@ import org.jetbrains.kotlin.utils.exceptions.errorWithAttachment internal class LLFirResolvableResolveSession( moduleProvider: LLModuleProvider, - moduleKindProvider: LLModuleKindProvider, + resolutionStrategyProvider: LLModuleResolutionStrategyProvider, sessionProvider: LLSessionProvider, diagnosticProvider: LLDiagnosticProvider ) : LLFirResolveSession( moduleProvider = moduleProvider, - moduleKindProvider = moduleKindProvider, + resolutionStrategyProvider = resolutionStrategyProvider, sessionProvider = sessionProvider, scopeSessionProvider = LLDefaultScopeSessionProvider, diagnosticProvider = diagnosticProvider @@ -64,9 +64,9 @@ internal class LLFirResolvableResolveSession( ): FirBasedSymbol<*> { val containingKtFile = ktDeclaration.containingKtFile val module = getModule(containingKtFile.originalKtFile ?: containingKtFile) - return when (getModuleKind(module)) { - KtModuleKind.RESOLVABLE_MODULE -> findSourceFirSymbol(ktDeclaration, module).also { resolveFirToPhase(it.fir, phase) } - KtModuleKind.BINARY_MODULE -> findFirCompiledSymbol(ktDeclaration, module) + return when (getModuleResolutionStrategy(module)) { + LLModuleResolutionStrategy.LAZY -> findSourceFirSymbol(ktDeclaration, module).also { resolveFirToPhase(it.fir, phase) } + LLModuleResolutionStrategy.STATIC -> findFirCompiledSymbol(ktDeclaration, module) } } @@ -86,7 +86,7 @@ internal class LLFirResolvableResolveSession( } private fun findSourceFirDeclarationByDeclaration(ktDeclaration: KtDeclaration, module: KtModule): FirBasedSymbol<*> { - require(getModuleKind(module) == KtModuleKind.RESOLVABLE_MODULE) { + require(getModuleResolutionStrategy(module) == LLModuleResolutionStrategy.LAZY) { "Declaration should be resolvable module, instead it had ${module::class}" } @@ -107,8 +107,8 @@ internal class LLFirResolvableResolveSession( return findDeclarationInSourceViaResolve(ktDeclaration) } - private fun getModuleKind(module: KtModule): KtModuleKind { - return moduleKindProvider.getKind(module) + private fun getModuleResolutionStrategy(module: KtModule): LLModuleResolutionStrategy { + return resolutionStrategyProvider.getKind(module) } private fun findDeclarationInSourceViaResolve(ktDeclaration: KtExpression): FirBasedSymbol<*> { diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLModuleKindProvider.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLModuleKindProvider.kt deleted file mode 100644 index 24a5f7662be..00000000000 --- a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLModuleKindProvider.kt +++ /dev/null @@ -1,46 +0,0 @@ -/* - * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.analysis.low.level.api.fir.state - -import org.jetbrains.kotlin.analysis.project.structure.KtModule -import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase - -interface LLModuleKindProvider { - /** - * Returns [KtModuleKind.BINARY_MODULE] if the [module] is treated as a binary for the current session, - * and [KtModuleKind.RESOLVABLE_MODULE] otherwise. - * - * In some cases, modules of the same type might be treated differently by the session, and have a different [KtModuleKind]. - * For instance, for a resolvable library session, only the target library is considered resolvable, and its dependencies are binary. - */ - fun getKind(module: KtModule): KtModuleKind -} - -/** - * Specifies the way declarations are loaded and handled in the module. - */ -enum class KtModuleKind { - /** - * Declarations in resolvable modules might be in an unresolved state. - * Call [lazyResolveToPhase] on them before usage if needed. - */ - RESOLVABLE_MODULE, - - /** - * Declarations in binary modules always come fully resolved, as they are loaded from JAR/klib, where the complete type information - * is available. - */ - BINARY_MODULE -} - -internal class LLSimpleResolvableModuleKindProvider(private val useSiteModule: KtModule) : LLModuleKindProvider { - override fun getKind(module: KtModule): KtModuleKind { - return when (module) { - useSiteModule -> KtModuleKind.RESOLVABLE_MODULE - else -> KtModuleKind.BINARY_MODULE - } - } -} \ No newline at end of file diff --git a/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLModuleResolutionStrategyProvider.kt b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLModuleResolutionStrategyProvider.kt new file mode 100644 index 00000000000..74cc675dc0d --- /dev/null +++ b/analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLModuleResolutionStrategyProvider.kt @@ -0,0 +1,56 @@ +/* + * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.analysis.low.level.api.fir.state + +import org.jetbrains.kotlin.analysis.project.structure.KtModule +import org.jetbrains.kotlin.analysis.project.structure.KtLibraryModule +import org.jetbrains.kotlin.analysis.project.structure.KtScriptModule +import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule +import org.jetbrains.kotlin.fir.symbols.lazyResolveToPhase + +interface LLModuleResolutionStrategyProvider { + /** + * Returns [LLModuleResolutionStrategy.STATIC] if the [module] is treated as a binary for the current session, + * and [LLModuleResolutionStrategy.LAZY] otherwise. + * + * In some cases, modules of the same type might be treated differently by the session, and have a different [LLModuleResolutionStrategy]. + * For instance, for a resolvable library session, only the target library is considered resolvable, and its dependencies are binary. + */ + fun getKind(module: KtModule): LLModuleResolutionStrategy +} + +/** + * Specifies the way declarations are loaded and handled in the module. + */ +enum class LLModuleResolutionStrategy { + /** + * When a module is analyzed with a [LAZY] resolution strategy, its declarations might be in an unresolved + * (or partially resolved) state. Call [lazyResolveToPhase] on the declarations before usage if needed. + * + * Some modules, such as [KtSourceModule] or [KtScriptModule], are always analyzed as [LAZY]. + * [KtLibraryModule] can be analyzed both ways (different types of sessions will be created). + */ + LAZY, + + /** + * With a [STATIC] resolution strategy, all declarations in a module are always considered fully resolved. Typically, they are loaded + * from a binary storage, such as a JAR file, or a klib, where the complete type information is present. + * Normally, declarations inside [STATIC] modules do not change. On a backing binary storage change, the whole session is invalided. + */ + STATIC +} + +/** + * A resolution strategy that treats all modules but the [useSiteModule] as [LLModuleResolutionStrategy.STATIC]. + */ +internal class LLSimpleResolutionStrategyProvider(private val useSiteModule: KtModule) : LLModuleResolutionStrategyProvider { + override fun getKind(module: KtModule): LLModuleResolutionStrategy { + return when (module) { + useSiteModule -> LLModuleResolutionStrategy.LAZY + else -> LLModuleResolutionStrategy.STATIC + } + } +} \ No newline at end of file