ADFA-6381: Build one Kotlin library module per jar

collectKtModules held the boot classpath as a lazy Sequence that called addLibrary, so every source module re-ran it and got a fresh KtLibraryModule for android.jar from each Android module: modules x Android-modules copies. Each copy materializes the jar's full file list for its search scope.

GlitchTip breadcrumbs show the same android.jar scope built 55-71 times on large multi-module projects, behind 219 of 336 OOM events.

addLibrary now reuses the module for a path, and the boot classpath is a distinct List, so each jar maps to exactly one module.

Author: hal-eisen-adfa

lsp/kotlin/src/main/java/com/itsaky/androidide/lsp/kotlin/compiler/WorkspaceExts.kt

@@ -30,24 +30,25 @@ internal fun Workspace.collectKtModules(
 
 	val jarToModMap = mutableMapOf<Path, KtLibraryModule>()
 
-	fun addLibrary(path: Path): KtLibraryModule {
-		val module = buildKtLibraryModule(project, appEnv) {
-			id = path.pathString
-			addContentRoot(path)
+	// One module per jar: every module shares android.jar, and each KtLibraryModule
+	// materializes the jar's full file list for its search scope (ADFA-6381).
+	fun addLibrary(path: Path): KtLibraryModule =
+		jarToModMap.getOrPut(path) {
+			buildKtLibraryModule(project, appEnv) {
+				id = path.pathString
+				addContentRoot(path)
+			}
 		}
-		jarToModMap[path] = module
-		return module
-	}
 
+	// A List, not a Sequence: a Sequence would re-run addLibrary for every source module below.
 	val bootClassPaths = moduleProjects
 		.filterIsInstance<AndroidModule>()
-		.flatMap { project ->
-			project.bootClassPaths
-				.asSequence()
-				.filter { it.exists() }
-				.map { it.toPath() }
-				.map(::addLibrary)
-		}
+		.flatMap { it.bootClassPaths.asSequence() }
+		.filter { it.exists() }
+		.map { it.toPath() }
+		.distinct()
+		.map(::addLibrary)
+		.toList()
 
 	val libraryDependencies = moduleProjects
 		.flatMap { it.getCompileClasspaths() }

lsp/kotlin/src/test/java/com/itsaky/androidide/lsp/kotlin/compiler/CollectKtModulesTest.kt

@@ -0,0 +1,62 @@
+package com.itsaky.androidide.lsp.kotlin.compiler
+
+import com.google.common.truth.Truth.assertThat
+import com.itsaky.androidide.lsp.kotlin.compiler.modules.KtLibraryModule
+import com.itsaky.androidide.lsp.kotlin.fixtures.KtLspTest
+import com.itsaky.androidide.project.AndroidModels
+import com.itsaky.androidide.project.GradleModels
+import com.itsaky.androidide.projects.api.AndroidModule
+import com.itsaky.androidide.projects.api.GradleProject
+import com.itsaky.androidide.projects.api.Workspace
+import org.junit.Test
+import kotlin.io.path.createFile
+import kotlin.io.path.pathString
+
+class CollectKtModulesTest : KtLspTest() {
+	@Test
+	fun `modules sharing android jar share one library module`() {
+		val androidJar = lspTestRule.tempDir.root.toPath().resolve("android.jar").createFile()
+		val modulePaths = listOf(":a", ":b", ":c")
+		val workspace =
+			Workspace(
+				rootProject = GradleProject(gradleProject(":")),
+				subProjects = modulePaths.map { AndroidModule(gradleProject(it, androidJar.pathString)) },
+				syncIssues = emptyList(),
+			)
+
+		val sourceModules = workspace.collectKtModules(env.project, env.applicationEnv)
+
+		val androidJarDeps =
+			sourceModules.map { module ->
+				module.directRegularDependencies.filterIsInstance<KtLibraryModule>().filter { it.id == androidJar.pathString }
+			}
+		assertThat(sourceModules).hasSize(modulePaths.size)
+		// Before ADFA-6381 each source module depended on one fresh copy per Android module (3 x 3 here).
+		androidJarDeps.forEach { assertThat(it).hasSize(1) }
+		androidJarDeps.flatten().forEach { assertThat(it).isSameInstanceAs(androidJarDeps.first().first()) }
+	}
+
+	private fun gradleProject(
+		path: String,
+		bootClassPath: String? = null,
+	): GradleModels.GradleProject {
+		val dir = "/tmp/collect-kt-modules${path.replace(':', '/')}"
+		return GradleModels.GradleProject
+			.newBuilder()
+			.setName(path.trimStart(':'))
+			.setPath(path)
+			.setProjectDirPath(dir)
+			.setBuildDirPath("$dir/build")
+			.setBuildScriptPath("$dir/build.gradle")
+			.apply {
+				if (bootClassPath != null) {
+					setAndroidProject(
+						AndroidModels.AndroidProject
+							.newBuilder()
+							.setProjectType(AndroidModels.ProjectType.LibraryProject)
+							.addBootClassPaths(bootClassPath),
+					)
+				}
+			}.build()
+	}
+}