AA: use existing utils to define library scope

No visible differences from end clients, and we can avoid uses/shares of
Jar file system across modules

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

@@ -9,7 +9,6 @@ import com.intellij.mock.MockApplication
 import com.intellij.mock.MockProject
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.StandardFileSystems
-import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem
 import com.intellij.psi.PsiElementFinder
 import com.intellij.psi.PsiManager
 import com.intellij.psi.search.GlobalSearchScope
@@ -86,18 +85,14 @@ public fun configureApplicationEnvironment(app: MockApplication) {
  *    * given [ktFiles] as Kotlin sources
  *    * other Java sources in [compilerConfig] (set via [addJavaSourceRoots])
  *    * JVM class paths in [compilerConfig] (set via [addJvmClasspathRoots]) as library.
- *
- *  To make sure the same instance of [CoreJarFileSystem] is used (and thus file lookup in jars is cached),
- *    pass [jarFileSystem] from [KotlinCoreEnvironment] if available.
  */
 public fun configureProjectEnvironment(
     project: MockProject,
     compilerConfig: CompilerConfiguration,
     packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
-    jarFileSystem: CoreJarFileSystem = CoreJarFileSystem(),
 ) {
     val ktFiles = getKtFilesFromPaths(project, getSourceFilePaths(compilerConfig))
-    configureProjectEnvironment(project, compilerConfig, ktFiles, packagePartProvider, jarFileSystem)
+    configureProjectEnvironment(project, compilerConfig, ktFiles, packagePartProvider)
 }
 
 private fun getSourceFilePaths(
@@ -139,7 +134,6 @@ internal fun configureProjectEnvironment(
     compilerConfig: CompilerConfiguration,
     ktFiles: List<KtFile>,
     packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
-    jarFileSystem: CoreJarFileSystem = CoreJarFileSystem(),
 ) {
     reRegisterJavaElementFinder(project)
 
@@ -181,7 +175,6 @@ internal fun configureProjectEnvironment(
             compilerConfig,
             project,
             ktFiles,
-            jarFileSystem
         )
     )
     project.picoContainer.registerComponentInstance(

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

@@ -6,10 +6,8 @@
 package org.jetbrains.kotlin.analysis.project.structure.impl
 
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analysis.api.impl.base.util.LibraryUtils
+import com.intellij.psi.search.ProjectScope
 import org.jetbrains.kotlin.analysis.project.structure.KtLibraryModule
 import org.jetbrains.kotlin.analysis.project.structure.KtLibrarySourceModule
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
@@ -52,7 +50,6 @@ internal class KtSourceModuleByCompilerConfiguration(
     compilerConfig: CompilerConfiguration,
     project: Project,
     ktFiles: List<KtFile>,
-    jarFileSystem: CoreJarFileSystem,
 ) : BaseKtModuleByCompilerConfiguration(compilerConfig, project), KtSourceModule {
     override val directRegularDependencies: List<KtLibraryModule> by lazy {
         val libraryRoots = compilerConfig.jvmModularRoots + compilerConfig.jvmClasspathRoots
@@ -62,16 +59,14 @@ internal class KtSourceModuleByCompilerConfiguration(
                 directories.forEach {
                     // E.g., project/app/build/intermediates/javac/debug/classes
                     val root = it.toPath()
-                    val virtualFilesProvider = { LibraryUtils.getAllVirtualFilesFromDirectory(root) }
-                    add(KtLibraryModuleByCompilerConfiguration(compilerConfig, project, virtualFilesProvider, root))
+                    add(KtLibraryModuleByCompilerConfiguration(compilerConfig, project, root))
                 }
             }
             libraryRootsByType[false]?.let { jars ->
                 jars.forEach {
                     // E.g., project/libs/libA/a.jar
                     val root = it.toPath()
-                    val virtualFilesProvider = { LibraryUtils.getAllVirtualFilesFromJar(root, jarFileSystem) }
-                    add(KtLibraryModuleByCompilerConfiguration(compilerConfig, project, virtualFilesProvider, root))
+                    add(KtLibraryModuleByCompilerConfiguration(compilerConfig, project, root))
                 }
             }
         }
@@ -85,8 +80,7 @@ internal class KtSourceModuleByCompilerConfiguration(
 internal class KtLibraryModuleByCompilerConfiguration(
     compilerConfig: CompilerConfiguration,
     project: Project,
-    virtualFilesProvider: () -> Collection<VirtualFile>,
-    private val root: Path,
+    root: Path,
 ) : BaseKtModuleByCompilerConfiguration(compilerConfig, project), KtLibraryModule {
     override val directRegularDependencies: List<KtModule> get() = emptyList()
 
@@ -97,12 +91,10 @@ internal class KtLibraryModuleByCompilerConfiguration(
         get() = null
 
     override val contentScope: GlobalSearchScope by lazy {
-        GlobalSearchScope.filesScope(project, virtualFilesProvider())
+        ProjectScope.getLibrariesScope(project)
     }
 
-    private val binaryRoots by lazy {
-        listOf(root)
-    }
+    private val binaryRoots = listOf(root)
 
     override fun getBinaryRoots(): Collection<Path> = binaryRoots
 }

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

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.analysis.project.structure.impl
 
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analysis.project.structure.KtLibraryModule
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
@@ -18,9 +17,8 @@ internal class KtModuleProviderByCompilerConfiguration(
     compilerConfig: CompilerConfiguration,
     project: Project,
     ktFiles: List<KtFile>,
-    jarFileSystem: CoreJarFileSystem,
 ) : ProjectStructureProvider() {
-    private val sourceModule = KtSourceModuleByCompilerConfiguration(compilerConfig, project, ktFiles, jarFileSystem)
+    private val sourceModule = KtSourceModuleByCompilerConfiguration(compilerConfig, project, ktFiles)
 
     private val libraryModules: Collection<KtLibraryModule> by lazy {
         sourceModule.directRegularDependencies

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/CompilerConfigurationProvider.kt

@@ -7,7 +7,6 @@ package org.jetbrains.kotlin.test.services
 
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
@@ -15,7 +14,6 @@ import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider
-import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreApplicationEnvironment
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
@@ -62,10 +60,6 @@ abstract class CompilerConfigurationProvider(val testServices: TestServices) : T
         val bootClasspath = mockJdk?.let { listOf(it) }
         environment.registerJavac(kotlinFiles = ktFiles, bootClasspath = bootClasspath)
     }
-
-    fun getJarFileSystem(module: TestModule): CoreJarFileSystem {
-        return getKotlinCoreEnvironment(module).projectEnvironment.environment.jarFileSystem as CoreJarFileSystem
-    }
 }
 
 val TestServices.compilerConfigurationProvider: CompilerConfigurationProvider by TestServices.testServiceAccessor()