[Analysis API FE1.0] support calling analyze with KtModule in FE10 implementation

^KT-65307 fixed

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/CliFe10AnalysisFacade.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.analysis.api.descriptors
 import com.intellij.openapi.extensions.AreaInstance
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
+import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule
@@ -35,33 +36,32 @@ import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner
 import org.jetbrains.kotlin.util.CancellationChecker
 
 class CliFe10AnalysisFacade : Fe10AnalysisFacade {
-    override fun getResolveSession(element: KtElement): ResolveSession {
-        return getHandler(element).resolveSession ?: error("Resolution is not performed")
+    override fun getAnalysisContext(element: KtElement, token: KtLifetimeToken): Fe10AnalysisContext {
+        val handler = getHandler(element)
+        return getAnalysisContext(handler, token)
     }
 
-    override fun getDeprecationResolver(element: KtElement): DeprecationResolver {
-        return getHandler(element).deprecationResolver ?: error("Resolution is not performed")
+    override fun getAnalysisContext(ktModule: KtModule, token: KtLifetimeToken): Fe10AnalysisContext {
+        val handler = KtFe10AnalysisHandlerExtension.getInstance(ktModule.project, ktModule)
+        return getAnalysisContext(handler, token)
     }
 
-    override fun getCallResolver(element: KtElement): CallResolver {
-        return getHandler(element).callResolver ?: error("Resolution is not performed")
-    }
-
-    override fun getKotlinToResolvedCallTransformer(element: KtElement): KotlinToResolvedCallTransformer {
-        return getHandler(element).kotlinToResolvedCallTransformer ?: error("Resolution is not performed")
-    }
-
-    override fun getOverloadingConflictResolver(element: KtElement): OverloadingConflictResolver<ResolvedCall<*>> {
-        return getHandler(element).overloadingConflictResolver ?: error("Resolution is not performed")
-    }
-
-    override fun getKotlinTypeRefiner(element: KtElement): KotlinTypeRefiner {
-        return getHandler(element).kotlinTypeRefiner ?: error("Resolution is not performed")
+    private fun getAnalysisContext(handler: KtFe10AnalysisHandlerExtension, token: KtLifetimeToken): Fe10AnalysisContext {
+        return Fe10AnalysisContext(
+            facade = this,
+            handler.resolveSession.orThrowResolutionNotPerformedError(),
+            handler.deprecationResolver.orThrowResolutionNotPerformedError(),
+            handler.callResolver.orThrowResolutionNotPerformedError(),
+            handler.kotlinToResolvedCallTransformer.orThrowResolutionNotPerformedError(),
+            handler.overloadingConflictResolver.orThrowResolutionNotPerformedError(),
+            handler.kotlinTypeRefiner.orThrowResolutionNotPerformedError(),
+            token,
+        )
     }
 
     override fun analyze(elements: List<KtElement>, mode: Fe10AnalysisFacade.AnalysisMode): BindingContext {
         val element = elements.firstOrNull() ?: return BindingContext.EMPTY
-        return getResolveSession(element).bindingContext
+        return getHandler(element).resolveSession.orThrowResolutionNotPerformedError().bindingContext
     }
 
     override fun getOrigin(file: VirtualFile): KtSymbolOrigin {
@@ -73,6 +73,9 @@ class CliFe10AnalysisFacade : Fe10AnalysisFacade {
         val ktModule = ProjectStructureProvider.getModule(project, useSiteElement, contextualModule = null)
         return KtFe10AnalysisHandlerExtension.getInstance(project, ktModule)
     }
+
+    private fun <T : Any> T?.orThrowResolutionNotPerformedError(): T =
+        this ?: error("Resolution is not performed")
 }
 
 class KtFe10AnalysisHandlerExtension(

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/Fe10AnalysisFacade.kt

@@ -7,8 +7,9 @@ package org.jetbrains.kotlin.analysis.api.descriptors
 
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
-import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
+import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
+import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.psi.KtElement
@@ -28,12 +29,9 @@ interface Fe10AnalysisFacade {
         }
     }
 
-    fun getResolveSession(element: KtElement): ResolveSession
-    fun getDeprecationResolver(element: KtElement): DeprecationResolver
-    fun getCallResolver(element: KtElement): CallResolver
-    fun getKotlinToResolvedCallTransformer(element: KtElement): KotlinToResolvedCallTransformer
-    fun getOverloadingConflictResolver(element: KtElement): OverloadingConflictResolver<ResolvedCall<*>>
-    fun getKotlinTypeRefiner(element: KtElement): KotlinTypeRefiner
+    fun getAnalysisContext(element: KtElement, token: KtLifetimeToken): Fe10AnalysisContext
+
+    fun getAnalysisContext(ktModule: KtModule, token: KtLifetimeToken): Fe10AnalysisContext
 
     fun analyze(elements: List<KtElement>, mode: AnalysisMode = AnalysisMode.FULL): BindingContext
 
@@ -53,16 +51,14 @@ interface Fe10AnalysisFacade {
 
 class Fe10AnalysisContext(
     facade: Fe10AnalysisFacade,
-    val contextElement: KtElement,
-    val token: KtLifetimeToken
+    val resolveSession: ResolveSession,
+    val deprecationResolver: DeprecationResolver,
+    val callResolver: CallResolver,
+    val kotlinToResolvedCallTransformer: KotlinToResolvedCallTransformer,
+    val overloadingConflictResolver: OverloadingConflictResolver<ResolvedCall<*>>,
+    val kotlinTypeRefiner: KotlinTypeRefiner,
+    val token: KtLifetimeToken,
 ) : Fe10AnalysisFacade by facade {
-    val resolveSession: ResolveSession = getResolveSession(contextElement)
-    val deprecationResolver: DeprecationResolver = getDeprecationResolver(contextElement)
-    val callResolver: CallResolver = getCallResolver(contextElement)
-    val kotlinToResolvedCallTransformer: KotlinToResolvedCallTransformer = getKotlinToResolvedCallTransformer(contextElement)
-    val overloadingConflictResolver: OverloadingConflictResolver<ResolvedCall<*>> = getOverloadingConflictResolver(contextElement)
-    val kotlinTypeRefiner: KotlinTypeRefiner = getKotlinTypeRefiner(contextElement)
-
     val builtIns: KotlinBuiltIns
         get() = resolveSession.moduleDescriptor.builtIns
 

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/KtFe10AnalysisSession.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors
 
-import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analysis.api.KtAnalysisApiInternals
 import org.jetbrains.kotlin.analysis.api.KtAnalysisNonPublicApi
@@ -19,20 +18,14 @@ import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolProvider
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolProviderByJavaPsi
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
-import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider
-import org.jetbrains.kotlin.psi.KtElement
 
 @OptIn(KtAnalysisApiInternals::class, KtAnalysisNonPublicApi::class)
 @Suppress("LeakingThis")
 class KtFe10AnalysisSession(
     val analysisContext: Fe10AnalysisContext,
-    override val useSiteModule: KtModule
-) : KtAnalysisSession(analysisContext.token) {
-    constructor(project: Project, contextElement: KtElement, token: KtLifetimeToken) : this(
-        Fe10AnalysisContext(Fe10AnalysisFacade.getInstance(project), contextElement, token),
-        ProjectStructureProvider.getModule(project, contextElement, contextualModule = null)
-    )
-
+    override val useSiteModule: KtModule,
+    token: KtLifetimeToken,
+) : KtAnalysisSession(token) {
 
     override val smartCastProviderImpl: KtSmartCastProvider = KtFe10SmartCastProvider(this)
     override val diagnosticProviderImpl: KtDiagnosticProvider = KtFe10DiagnosticProvider(this)

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/KtFe10CliAnalysisSessionProvider.kt

@@ -10,19 +10,25 @@ import org.jetbrains.kotlin.analysis.api.KtAnalysisApiInternals
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.session.KtAnalysisSessionProvider
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
-import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeTokenFactory
+import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider
 import org.jetbrains.kotlin.psi.KtElement
-import java.lang.UnsupportedOperationException
 
 
 @OptIn(KtAnalysisApiInternals::class)
 class KtFe10AnalysisSessionProvider(project: Project) : KtAnalysisSessionProvider(project) {
     override fun getAnalysisSession(useSiteKtElement: KtElement): KtAnalysisSession {
-        return KtFe10AnalysisSession(project, useSiteKtElement, tokenFactory.create(project))
+        val facade = Fe10AnalysisFacade.getInstance(project)
+        val token = tokenFactory.create(project)
+        val context = facade.getAnalysisContext(useSiteKtElement, token)
+        val useSiteModule = ProjectStructureProvider.getModule(project, useSiteKtElement, contextualModule = null)
+        return KtFe10AnalysisSession(context, useSiteModule, token)
     }
 
     override fun getAnalysisSessionByUseSiteKtModule(useSiteKtModule: KtModule): KtAnalysisSession {
-        throw UnsupportedOperationException("getAnalysisSessionByModule() should not be used on KtFe10AnalysisSession")
+        val facade = Fe10AnalysisFacade.getInstance(project)
+        val token = tokenFactory.create(project)
+        val context = facade.getAnalysisContext(useSiteKtModule, token)
+        return KtFe10AnalysisSession(context, useSiteKtModule, token)
     }
 
     override fun clearCaches() {}