AA: reuse CoreJarFileSystem from KotlinCoreEnvironment

analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/util/LibraryUtils.kt

@@ -12,8 +12,16 @@ import com.intellij.util.io.URLUtil.JAR_SEPARATOR
 import java.nio.file.Path
 
 object LibraryUtils {
-    fun getAllVirtualFilesFromJar(jar: Path): Collection<VirtualFile> {
-        val jarFileSystem = CoreJarFileSystem()
+    /**
+     * Get all [VirtualFile]s inside the given [jar] (of [Path])
+     *
+     * Note that, if [CoreJarFileSystem] is not given, a fresh instance will be used, which will create fresh instances of [VirtualFile],
+     *   resulting in potential hash mismatch (e.g., if used in scope membership check).
+     */
+    fun getAllVirtualFilesFromJar(
+        jar: Path,
+        jarFileSystem: CoreJarFileSystem = CoreJarFileSystem(),
+    ): Collection<VirtualFile> {
         val root = jarFileSystem.refreshAndFindFileByPath(jar.toAbsolutePath().toString() + JAR_SEPARATOR)!!
 
         val files = mutableSetOf<VirtualFile>()

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

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.analysis.api.standalone
 import com.intellij.mock.MockApplication
 import com.intellij.mock.MockProject
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem
 import com.intellij.psi.PsiElementFinder
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analysis.api.InvalidWayOfUsingAnalysisSession
@@ -81,12 +82,16 @@ 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,
     ktFiles: List<KtFile>,
     packagePartProvider: (GlobalSearchScope) -> PackagePartProvider,
+    jarFileSystem: CoreJarFileSystem = CoreJarFileSystem(),
 ) {
     reRegisterJavaElementFinder(project)
 
@@ -115,7 +120,12 @@ public fun configureProjectEnvironment(
 
     project.picoContainer.registerComponentInstance(
         ProjectStructureProvider::class.qualifiedName,
-        ProjectStructureProviderByCompilerConfiguration(compilerConfig, project, ktFiles)
+        ProjectStructureProviderByCompilerConfiguration(
+            compilerConfig,
+            project,
+            ktFiles,
+            jarFileSystem
+        )
     )
     project.picoContainer.registerComponentInstance(
         KotlinDeclarationProviderFactory::class.qualifiedName,

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

@@ -7,6 +7,7 @@ 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 org.jetbrains.kotlin.analysis.project.structure.KtLibraryModule
@@ -51,10 +52,11 @@ internal class KtSourceModuleByCompilerConfiguration(
     compilerConfig: CompilerConfiguration,
     project: Project,
     ktFiles: List<KtFile>,
+    jarFileSystem: CoreJarFileSystem,
 ) : BaseKtModuleByCompilerConfiguration(compilerConfig, project), KtSourceModule {
     override val directRegularDependencies: List<KtModule> by lazy {
         (compilerConfig.jvmModularRoots + compilerConfig.jvmClasspathRoots).map {
-            KtLibraryModuleByCompilerConfiguration(compilerConfig, project, it.toPath())
+            KtLibraryModuleByCompilerConfiguration(compilerConfig, project, it.toPath(), jarFileSystem)
         }
     }
 
@@ -66,11 +68,12 @@ internal class KtLibraryModuleByCompilerConfiguration(
     compilerConfig: CompilerConfiguration,
     project: Project,
     private val jar: Path,
+    jarFileSystem: CoreJarFileSystem,
 ) : BaseKtModuleByCompilerConfiguration(compilerConfig, project), KtLibraryModule {
     override val directRegularDependencies: List<KtModule> get() = emptyList()
 
     internal val virtualFiles: Collection<VirtualFile> by lazy {
-        LibraryUtils.getAllVirtualFilesFromJar(jar)
+        LibraryUtils.getAllVirtualFilesFromJar(jar, jarFileSystem)
     }
 
     override val libraryName: String

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

@@ -6,6 +6,7 @@
 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.KtModule
 import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider
@@ -19,6 +20,7 @@ internal class ProjectStructureProviderByCompilerConfiguration(
     private val compilerConfig: CompilerConfiguration,
     project: Project,
     ktFiles: List<KtFile>,
+    jarFileSystem: CoreJarFileSystem,
 ) : ProjectStructureProvider() {
     private val sourceFiles: Set<String> by lazy {
         buildSet {
@@ -37,7 +39,7 @@ internal class ProjectStructureProviderByCompilerConfiguration(
         }
     }
 
-    private val sourceModule = KtSourceModuleByCompilerConfiguration(compilerConfig, project, ktFiles)
+    private val sourceModule = KtSourceModuleByCompilerConfiguration(compilerConfig, project, ktFiles, jarFileSystem)
 
     override fun getKtModuleForKtElement(element: PsiElement): KtModule {
         val containingFilePath = element.containingFile.virtualFile.path