[LL API] Migrate 'getKtModule()' usages to 'ProjectStructureProvider'

Ensure the contextual module is passed wherever possible.

^KT-57559 Fixed

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

@@ -11,7 +11,7 @@ import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule
-import org.jetbrains.kotlin.analysis.project.structure.getKtModule
+import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider
 import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.container.get
@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner
 import org.jetbrains.kotlin.util.CancellationChecker
 
-class CliFe10AnalysisFacade(private val project: Project) : Fe10AnalysisFacade {
+class CliFe10AnalysisFacade : Fe10AnalysisFacade {
     override fun getResolveSession(element: KtElement): ResolveSession {
         return getHandler(element).resolveSession ?: error("Resolution is not performed")
     }
@@ -68,7 +68,7 @@ class CliFe10AnalysisFacade(private val project: Project) : Fe10AnalysisFacade {
     }
 
     private fun getHandler(useSiteElement: KtElement): KtFe10AnalysisHandlerExtension {
-        val ktModule = useSiteElement.getKtModule(project)
+        val ktModule = ProjectStructureProvider.getModule(useSiteElement, contextualModule = null)
         return KtFe10AnalysisHandlerExtension.getInstance(ktModule.project, ktModule)
     }
 }

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

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 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.getKtModule
+import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 
@@ -28,7 +28,7 @@ class KtFe10AnalysisSession(
 ) : KtAnalysisSession(analysisContext.token) {
     constructor(contextElement: KtElement, token: KtLifetimeToken) : this(
         Fe10AnalysisContext(Fe10AnalysisFacade.getInstance(contextElement.project), contextElement, token),
-        contextElement.getKtModule()
+        ProjectStructureProvider.getModule(contextElement, contextualModule = null)
     )
 
 

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

@@ -9,11 +9,8 @@ import com.intellij.openapi.project.Project
 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.api.descriptors.symbols.base.KtFe10Symbol
-import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeTokenFactory
-import org.jetbrains.kotlin.analysis.project.structure.getKtModule
 import org.jetbrains.kotlin.psi.KtElement
 import java.lang.UnsupportedOperationException
 

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

@@ -14,17 +14,14 @@ import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnaly
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.KtFe10DescDefaultBackingFieldSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getDescriptor
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtSymbol
+import org.jetbrains.kotlin.analysis.api.getModule
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.api.symbols.KtBackingFieldSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtDeclarationSymbol
 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.KtSymbolWithKind
-import org.jetbrains.kotlin.analysis.project.structure.KtLibraryModule
-import org.jetbrains.kotlin.analysis.project.structure.KtLibrarySourceModule
-import org.jetbrains.kotlin.analysis.project.structure.KtModule
-import org.jetbrains.kotlin.analysis.project.structure.getKtModule
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.analysis.project.structure.*
 import org.jetbrains.kotlin.load.kotlin.JvmPackagePartSource
 import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
@@ -54,39 +51,42 @@ internal class KtFe10SymbolContainingDeclarationProvider(
 
     // TODO this is a dummy and incorrect implementation just to satisfy some tests
     override fun getContainingModule(symbol: KtSymbol): KtModule {
-        val psiForModule = symbol.getDescriptor()?.let { DescriptorToSourceUtils.getContainingFile(it) }
-            ?: symbol.psi
+        val descriptor = symbol.getDescriptor()
 
-        return psiForModule?.getKtModule(analysisSession.analysisContext.resolveSession.project)
-            ?: symbol.getDescriptor()?.getFakeContainingKtModule()
-            ?: (symbol as? KtBackingFieldSymbol)?.owningProperty?.let { getContainingModule(it) }
-            ?: TODO(symbol::class.java.name)
+        val symbolPsi = descriptor?.let(DescriptorToSourceUtils::getContainingFile) ?: symbol.psi
+        if (symbolPsi != null) {
+            return analysisSession.getModule(symbolPsi)
+        }
+
+        if (descriptor is DescriptorWithContainerSource) {
+            return getFakeContainingKtModule(descriptor)
+        }
+
+        if (symbol is KtBackingFieldSymbol) {
+            return getContainingModule(symbol.owningProperty)
+        }
+
+        TODO(symbol::class.java.name)
     }
 
-    private fun DeclarationDescriptor.getFakeContainingKtModule(): KtModule? {
-        return when (this) {
-            is DescriptorWithContainerSource -> {
-                val libraryPath = Paths.get((containerSource as JvmPackagePartSource).knownJvmBinaryClass?.containingLibrary!!)
-                object : KtLibraryModule {
-                    override val libraryName: String = libraryPath.fileName.toString().substringBeforeLast(".")
-                    override val librarySources: KtLibrarySourceModule? = null
-                    override fun getBinaryRoots(): Collection<Path> = listOf(libraryPath)
-                    override val directRegularDependencies: List<KtModule> = emptyList()
-                    override val directDependsOnDependencies: List<KtModule> = emptyList()
-                    override val transitiveDependsOnDependencies: List<KtModule> = emptyList()
-                    override val directFriendDependencies: List<KtModule> = emptyList()
-                    override val contentScope: GlobalSearchScope = ProjectScope.getLibrariesScope(project)
-                    override val platform: TargetPlatform
-                        get() = this@getFakeContainingKtModule.platform!!
-                    override val analyzerServices: PlatformDependentAnalyzerServices
-                        get() = JvmPlatformAnalyzerServices
-                    override val project: Project
-                        get() = analysisSession.analysisContext.resolveSession.project
+    private fun getFakeContainingKtModule(descriptor: DescriptorWithContainerSource): KtModule {
+        val libraryPath = Paths.get((descriptor.containerSource as JvmPackagePartSource).knownJvmBinaryClass?.containingLibrary!!)
+        return object : KtLibraryModule {
+            override val libraryName: String = libraryPath.fileName.toString().substringBeforeLast(".")
+            override val librarySources: KtLibrarySourceModule? = null
+            override fun getBinaryRoots(): Collection<Path> = listOf(libraryPath)
+            override val directRegularDependencies: List<KtModule> = emptyList()
+            override val directDependsOnDependencies: List<KtModule> = emptyList()
+            override val transitiveDependsOnDependencies: List<KtModule> = emptyList()
+            override val directFriendDependencies: List<KtModule> = emptyList()
+            override val contentScope: GlobalSearchScope = ProjectScope.getLibrariesScope(project)
+            override val platform: TargetPlatform
+                get() = descriptor.platform!!
+            override val analyzerServices: PlatformDependentAnalyzerServices
+                get() = JvmPlatformAnalyzerServices
+            override val project: Project
+                get() = analysisSession.analysisContext.resolveSession.project
 
-                }
-            }
-
-            else -> null
         }
     }
 }

analysis/analysis-api-fe10/tests/org/jetbrains/kotlin/analysis/api/fe10/test/configurator/AnalysisApiFe10TestServiceRegistrar.kt

@@ -37,7 +37,7 @@ object AnalysisApiFe10TestServiceRegistrar : AnalysisApiTestServiceRegistrar() {
     override fun registerProjectModelServices(project: MockProject, testServices: TestServices) {
         project.apply {
             registerService(KtAnalysisSessionProvider::class.java, KtFe10AnalysisSessionProvider(project))
-            registerService(Fe10AnalysisFacade::class.java, CliFe10AnalysisFacade(project))
+            registerService(Fe10AnalysisFacade::class.java, CliFe10AnalysisFacade())
             registerService(ModuleVisibilityManager::class.java, CliModuleVisibilityManagerImpl(enabled = true))
 
             registerService(ReadWriteAccessChecker::class.java, ReadWriteAccessCheckerDescriptorsImpl())