AA: drop ProjectStructureProvider#getKtBinaryModules

Instead, provide an option to register PSI declaration provider inside
Analysis API session builder where we can retrieve all necessary pieces,
including CoreJarFileSystem, PackagePartProvider, and binary modules
from internal project structure provider.

analysis/analysis-api-standalone/analysis-api-standalone-base/src/org/jetbrains/kotlin/analysis/api/standalone/base/project/structure/KtStaticModuleProvider.kt

@@ -7,11 +7,10 @@ package org.jetbrains.kotlin.analysis.api.standalone.base.project.structure
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analysis.project.structure.*
-import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.psi.psiUtil.contains
 
 class KtStaticModuleProvider(
-    private val projectStructure: KtModuleProjectStructure,
+    val projectStructure: KtModuleProjectStructure,
 ) : ProjectStructureProvider() {
     override fun getKtModuleForKtElement(element: PsiElement): KtModule {
         return projectStructure.mainModules
@@ -19,8 +18,4 @@ class KtStaticModuleProvider(
                 module.ktModule.contentScope.contains(element)
             }.ktModule
     }
-
-    override fun getKtBinaryModules(): Collection<KtBinaryModule> {
-        return projectStructure.allKtModules().filterIsInstance<KtBinaryModule>()
-    }
 }

analysis/analysis-api-standalone/src/org/jetbrains/kotlin/analysis/api/standalone/StandaloneAnalysisAPISessionBuilder.kt

@@ -9,6 +9,7 @@ import com.intellij.openapi.Disposable
 import com.intellij.openapi.application.Application
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Disposer
+import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem
 import com.intellij.psi.PsiElementFinder
 import com.intellij.psi.impl.PsiElementFinderImpl
 import com.intellij.psi.search.GlobalSearchScope
@@ -33,14 +34,8 @@ import org.jetbrains.kotlin.analysis.project.structure.impl.KtModuleProviderImpl
 import org.jetbrains.kotlin.analysis.project.structure.impl.buildKtModuleProviderByCompilerConfiguration
 import org.jetbrains.kotlin.analysis.project.structure.impl.getPsiFilesFromPaths
 import org.jetbrains.kotlin.analysis.project.structure.impl.getSourceFilePaths
-import org.jetbrains.kotlin.analysis.providers.KotlinAnnotationsResolverFactory
-import org.jetbrains.kotlin.analysis.providers.KotlinDeclarationProviderFactory
-import org.jetbrains.kotlin.analysis.providers.KotlinModificationTrackerFactory
-import org.jetbrains.kotlin.analysis.providers.KotlinPackageProviderFactory
-import org.jetbrains.kotlin.analysis.providers.impl.KotlinStaticAnnotationsResolverFactory
-import org.jetbrains.kotlin.analysis.providers.impl.KotlinStaticDeclarationProviderFactory
-import org.jetbrains.kotlin.analysis.providers.impl.KotlinStaticModificationTrackerFactory
-import org.jetbrains.kotlin.analysis.providers.impl.KotlinStaticPackageProviderFactory
+import org.jetbrains.kotlin.analysis.providers.*
+import org.jetbrains.kotlin.analysis.providers.impl.*
 import org.jetbrains.kotlin.asJava.KotlinAsJavaSupport
 import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreProjectEnvironment
@@ -167,6 +162,23 @@ public class StandaloneAnalysisAPISessionBuilder(
         PsiElementFinder.EP.getPoint(project).registerExtension(PsiElementFinderImpl(project))
     }
 
+    private fun registerPsiDeclarationFromBinaryModuleProvider(
+        packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
+    ) {
+        val ktModuleProviderImpl = projectStructureProvider as KtModuleProviderImpl
+        kotlinCoreProjectEnvironment.project.apply {
+            registerService(
+                KotlinPsiDeclarationProviderFactory::class.java,
+                KotlinStaticPsiDeclarationProviderFactory(
+                    this,
+                    packagePartProvider,
+                    ktModuleProviderImpl.binaryModules,
+                    kotlinCoreProjectEnvironment.environment.jarFileSystem as CoreJarFileSystem
+                )
+            )
+        }
+    }
+
     public fun <T : Any> registerProjectService(serviceInterface: Class<T>, serviceImplementation: T) {
         kotlinCoreProjectEnvironment.project.apply {
             registerService(serviceInterface, serviceImplementation)
@@ -179,7 +191,9 @@ public class StandaloneAnalysisAPISessionBuilder(
         }
     }
 
-    public fun build(): StandaloneAnalysisAPISession {
+    public fun build(
+        withPsiDeclarationFromBinaryModuleProvider: Boolean = false,
+    ): StandaloneAnalysisAPISession {
         val ktModuleProviderImpl = projectStructureProvider as KtModuleProviderImpl
         val modules = ktModuleProviderImpl.mainModules
         val allSourceFiles = ktModuleProviderImpl.allSourceFiles()
@@ -204,6 +218,9 @@ public class StandaloneAnalysisAPISessionBuilder(
             ktFiles,
             createPackagePartProvider,
         )
+        if (withPsiDeclarationFromBinaryModuleProvider) {
+            registerPsiDeclarationFromBinaryModuleProvider(createPackagePartProvider)
+        }
 
         return StandaloneAnalysisAPISession(
             kotlinCoreProjectEnvironment,
@@ -216,6 +233,7 @@ public class StandaloneAnalysisAPISessionBuilder(
 public inline fun buildStandaloneAnalysisAPISession(
     applicationDisposable: Disposable = Disposer.newDisposable("StandaloneAnalysisAPISession.application"),
     projectDisposable: Disposable = Disposer.newDisposable("StandaloneAnalysisAPISession.project"),
+    withPsiDeclarationFromBinaryModuleProvider: Boolean = false,
     init: StandaloneAnalysisAPISessionBuilder.() -> Unit
 ): StandaloneAnalysisAPISession {
     contract {
@@ -224,5 +242,7 @@ public inline fun buildStandaloneAnalysisAPISession(
     return StandaloneAnalysisAPISessionBuilder(
         applicationDisposable,
         projectDisposable,
-    ).apply(init).build()
+    ).apply(init).build(
+        withPsiDeclarationFromBinaryModuleProvider,
+    )
 }

analysis/analysis-api-standalone/src/org/jetbrains/kotlin/analysis/project/structure/impl/KtModuleProviderImpl.kt

@@ -43,16 +43,12 @@ internal class KtModuleProviderImpl(
         }
     }
 
-    private val binaryModules: Collection<KtBinaryModule> by lazy {
+    internal val binaryModules: List<KtBinaryModule> by lazy {
         mainModules
             .flatMap { it.allDirectDependencies() }
             .filterIsInstance<KtBinaryModule>()
     }
 
-    override fun getKtBinaryModules(): Collection<KtBinaryModule> {
-        return binaryModules
-    }
-
     internal fun allSourceFiles(): List<PsiFileSystemItem> = buildList {
         val files = mainModules.mapNotNull { (it as? KtSourceModuleImpl)?.sourceRoots }.flatten()
         addAll(files)

analysis/analysis-api-standalone/tests/org/jetbrains/kotlin/analysis/api/standalone/fir/test/StandaloneModeTestServiceRegistrar.kt

@@ -8,8 +8,10 @@ package org.jetbrains.kotlin.analysis.api.standalone.fir.test
 import com.intellij.mock.MockApplication
 import com.intellij.mock.MockProject
 import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem
+import org.jetbrains.kotlin.analysis.api.standalone.base.project.structure.KtStaticModuleProvider
 import org.jetbrains.kotlin.analysis.api.standalone.base.project.structure.StandaloneProjectFactory
 import org.jetbrains.kotlin.analysis.decompiled.light.classes.ClsJavaStubByVirtualFileCache
+import org.jetbrains.kotlin.analysis.project.structure.KtBinaryModule
 import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider
 import org.jetbrains.kotlin.analysis.providers.KotlinPsiDeclarationProviderFactory
 import org.jetbrains.kotlin.analysis.providers.impl.KotlinStaticPsiDeclarationProviderFactory
@@ -23,7 +25,9 @@ object StandaloneModeTestServiceRegistrar : AnalysisApiTestServiceRegistrar() {
 
     override fun registerProjectServices(project: MockProject, testServices: TestServices) {
         val projectStructureProvider = project.getService(ProjectStructureProvider::class.java)
-        val binaryModules = projectStructureProvider.getKtBinaryModules().toList()
+        val binaryModules =
+            (projectStructureProvider as? KtStaticModuleProvider)?.projectStructure?.allKtModules()?.filterIsInstance<KtBinaryModule>()
+                ?: emptyList()
         val projectEnvironment = testServices.environmentManager.getProjectEnvironment()
         val binaryRoots = StandaloneProjectFactory.getAllBinaryRoots(binaryModules, projectEnvironment)
         project.apply {

analysis/project-structure/src/org/jetbrains/kotlin/analysis/project/structure/ProjectStructureProvider.kt

@@ -7,19 +7,12 @@ package org.jetbrains.kotlin.analysis.project.structure
 
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.platform.TargetPlatform
 
 public abstract class ProjectStructureProvider {
     /**
      * For a given [PsiElement] get a [KtModule] to which [PsiElement] belongs.
      */
     public abstract fun getKtModuleForKtElement(element: PsiElement): KtModule
-
-    /**
-     * Returns all dependent [KtBinaryModule]s in this project.
-     */
-    // TODO: We rather need a session or facade that maintains this information.
-    public abstract fun getKtBinaryModules(): Collection<KtBinaryModule>
 }
 
 /**