[AA, tests] Limit scopes of test libraries to their roots, add JDK_HOME

Without the fix, all libraries share the global scope for all project
libraries. JDK_HOME was used implicitly for things such as providing
Record support, but was not included as a test library/sdk.

KT-59637

analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/project/structure/KtSourceModuleByCompilerConfiguration.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.test.framework.project.structure
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiFile
 import com.intellij.psi.search.GlobalSearchScope
-import com.intellij.psi.search.ProjectScope
+import org.jetbrains.kotlin.analysis.api.standalone.base.project.structure.StandaloneProjectFactory
 import org.jetbrains.kotlin.analysis.project.structure.*
 import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
 import org.jetbrains.kotlin.cli.jvm.config.jvmClasspathRoots
@@ -16,12 +16,14 @@ import org.jetbrains.kotlin.cli.jvm.config.jvmModularRoots
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
 import org.jetbrains.kotlin.test.getAnalyzerServices
 import org.jetbrains.kotlin.test.model.TestModule
 import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.compilerConfigurationProvider
+import org.jetbrains.kotlin.utils.addIfNotNull
 import java.io.File
 import java.nio.file.Path
 import java.nio.file.Paths
@@ -30,7 +32,7 @@ abstract class KtModuleByCompilerConfiguration(
     val project: Project,
     val testModule: TestModule,
     val psiFiles: List<PsiFile>,
-    testServices: TestServices,
+    val testServices: TestServices,
 ) {
     private val moduleProvider = testServices.ktModuleProvider
     private val compilerConfigurationProvider = testServices.compilerConfigurationProvider
@@ -43,14 +45,29 @@ abstract class KtModuleByCompilerConfiguration(
     val directRegularDependencies: List<KtModule> by lazy(LazyThreadSafetyMode.PUBLICATION) {
         buildList {
             testModule.allDependencies.mapTo(this) { moduleProvider.getModule(it.moduleName) }
-            addAll(
-                librariesByRoots(
-                    (configuration.jvmModularRoots + configuration.jvmClasspathRoots).map(File::toPath)
-                )
-            )
+            val roots = buildList {
+                addAll(configuration.jvmModularRoots.map(File::toPath))
+                addAll(configuration.jvmClasspathRoots.map(File::toPath))
+            }
+            addAll(librariesByRoots(roots))
+            addIfNotNull(createJdkFromConfiguration())
         }
     }
 
+    private fun createJdkFromConfiguration(): KtSdkModule? = configuration.get(JVMConfigurationKeys.JDK_HOME)?.let { jdkHome ->
+        val jdkHomePaths = StandaloneProjectFactory.getDefaultJdkModulePaths(project, jdkHome.toPath())
+        val scope = TestModuleStructureFactory.getScopeForLibraryByRoots(jdkHomePaths, project, testServices)
+
+        KtJdkModuleImpl(
+            "jdk",
+            JvmPlatforms.defaultJvmPlatform,
+            scope,
+            project,
+            jdkHomePaths,
+        )
+    }
+
+    @Suppress("MemberVisibilityCanBePrivate") // used for overrides in subclasses
     val directDependsOnDependencies: List<KtModule> by lazy(LazyThreadSafetyMode.PUBLICATION) {
         testModule.dependsOnDependencies
             .map { moduleProvider.getModule(it.moduleName) }
@@ -69,7 +86,7 @@ abstract class KtModuleByCompilerConfiguration(
 
     protected abstract val ktModule: KtModule
 
-    private fun librariesByRoots(roots: List<Path>): List<LibraryByRoot> = roots.map { LibraryByRoot(it, ktModule, project) }
+    private fun librariesByRoots(roots: List<Path>): List<LibraryByRoot> = roots.map { LibraryByRoot(it, ktModule, project, testServices) }
 
     val languageVersionSettings: LanguageVersionSettings
         get() = testModule.languageVersionSettings
@@ -127,13 +144,14 @@ private class LibraryByRoot(
     private val root: Path,
     private val parentModule: KtModule,
     override val project: Project,
+    testServices: TestServices,
 ) : KtLibraryModule {
+    override val contentScope: GlobalSearchScope = TestModuleStructureFactory.getScopeForLibraryByRoots(listOf(root), project, testServices)
     override val libraryName: String get() = "Test Library $root"
     override val directRegularDependencies: List<KtModule> get() = emptyList()
     override val directDependsOnDependencies: List<KtModule> get() = emptyList()
     override val transitiveDependsOnDependencies: List<KtModule> get() = emptyList()
     override val directFriendDependencies: List<KtModule> get() = emptyList()
-    override val contentScope: GlobalSearchScope get() = ProjectScope.getLibrariesScope(project)
     override val platform: TargetPlatform get() = parentModule.platform
     override val analyzerServices: PlatformDependentAnalyzerServices get() = parentModule.analyzerServices
     override fun getBinaryRoots(): Collection<Path> = listOf(root)

analysis/analysis-test-framework/tests/org/jetbrains/kotlin/analysis/test/framework/project/structure/TestModuleStructureFactory.kt

@@ -173,7 +173,7 @@ object TestModuleStructureFactory {
         )
     }
 
-    private fun getScopeForLibraryByRoots(roots: Collection<Path>, project: Project, testServices: TestServices): GlobalSearchScope {
+    fun getScopeForLibraryByRoots(roots: Collection<Path>, project: Project, testServices: TestServices): GlobalSearchScope {
         val virtualFileRoots = StandaloneProjectFactory.getVirtualFilesForLibraryRoots(
             roots,
             testServices.environmentManager.getProjectEnvironment()