[LL API] Rename 'KtModuleKind' to 'KtModuleResolutionStrategy'

The word "kind" is ambiguous – users might assume the kind is somehow
related to 'KtSourceModule'/'KtScriptModule'.

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

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 KtSourceModule -> LLSourceModuleResolutionStrategyProvider
-            is KtLibraryModule, is KtLibrarySourceModule -> LLLibraryModuleKindProvider(module)
+            is KtLibraryModule, is KtLibrarySourceModule -> LLLibraryModuleResolutionStrategyProvider(module)
-            is KtScriptModule -> LLScriptModuleKindProvider(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)
+                    val contextResolutionStrategyProvider = createResolutionStrategyProvider(contextModule, moduleProvider)
-                    LLCodeFragmentKindProvider(contextModuleKindProvider)
+                    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 {
+private object LLSourceModuleResolutionStrategyProvider : LLModuleResolutionStrategyProvider {
-    override fun getKind(module: KtModule): KtModuleKind {
+    override fun getKind(module: KtModule): LLModuleResolutionStrategy {
         return when (module) {
-            is KtSourceModule -> KtModuleKind.RESOLVABLE_MODULE
+            is KtSourceModule -> LLModuleResolutionStrategy.LAZY
-            is KtBuiltinsModule, is KtLibraryModule -> KtModuleKind.BINARY_MODULE
+            is KtBuiltinsModule, is KtLibraryModule -> LLModuleResolutionStrategy.STATIC
             else -> unexpectedElementError("module", module)
         }
     }
 }
 
-private class LLLibraryModuleKindProvider(private val useSiteModule: KtModule) : LLModuleKindProvider {
+private class LLLibraryModuleResolutionStrategyProvider(private val useSiteModule: KtModule) : LLModuleResolutionStrategyProvider {
-    override fun getKind(module: KtModule): KtModuleKind {
+    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 {
+private class LLScriptModuleResolutionStrategyProvider(private val useSiteModule: KtModule) : LLModuleResolutionStrategyProvider {
-    override fun getKind(module: KtModule): KtModuleKind {
+    override fun getKind(module: KtModule): LLModuleResolutionStrategy {
         return when (module) {
-            useSiteModule, is KtSourceModule -> KtModuleKind.RESOLVABLE_MODULE
+            useSiteModule, is KtSourceModule -> LLModuleResolutionStrategy.LAZY
-            is KtBuiltinsModule, is KtLibraryModule -> KtModuleKind.BINARY_MODULE
+            is KtBuiltinsModule, is KtLibraryModule -> LLModuleResolutionStrategy.STATIC
             else -> unexpectedElementError("module", module)
         }
     }
 }
 
-private class LLCodeFragmentKindProvider(private val delegate: LLModuleKindProvider) : LLModuleKindProvider {
+private class LLCodeFragmentResolutionStrategyProvider(private val delegate: LLModuleResolutionStrategyProvider) : LLModuleResolutionStrategyProvider {
-    override fun getKind(module: KtModule): KtModuleKind {
+    override fun getKind(module: KtModule): LLModuleResolutionStrategy {
         return when (module) {
-            is KtCodeFragmentModule -> KtModuleKind.RESOLVABLE_MODULE
+            is KtCodeFragmentModule -> LLModuleResolutionStrategy.LAZY
             else -> delegate.getKind(module)
         }
     }

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

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)) {
+        return when (getModuleResolutionStrategy(module)) {
-            KtModuleKind.RESOLVABLE_MODULE -> findSourceFirSymbol(ktDeclaration, module).also { resolveFirToPhase(it.fir, phase) }
+            LLModuleResolutionStrategy.LAZY -> findSourceFirSymbol(ktDeclaration, module).also { resolveFirToPhase(it.fir, phase) }
-            KtModuleKind.BINARY_MODULE -> findFirCompiledSymbol(ktDeclaration, module)
+            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 {
+    private fun getModuleResolutionStrategy(module: KtModule): LLModuleResolutionStrategy {
-        return moduleKindProvider.getKind(module)
+        return resolutionStrategyProvider.getKind(module)
     }
 
     private fun findDeclarationInSourceViaResolve(ktDeclaration: KtExpression): FirBasedSymbol<*> {

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLModuleKindProvider.kt

@@ -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
-        }
-    }
-}

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
+        }
+    }
+}