ADFA-6381: Add each module dependency once

Now that addLibrary returns one shared KtLibraryModule per jar, a jar on
both the boot classpath and a module's compile classpath was added to
that module's dependencies twice as the same instance. Both module
builders now keep dependencies in a LinkedHashSet: O(1) dedupe, order
preserved.

Tests: compile-classpath jars shared across modules resolve to one
instance; a jar on both classpaths is one dependency (fails without the
builder change: size 2).

Author: hal-eisen-adfa

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

@@ -47,7 +47,9 @@ internal class KtLibraryModule(
 	) {
 		lateinit var id: String
 		private val contentRoots = mutableSetOf<Path>()
-		private val dependencies = mutableListOf<KtModule>()
+
+		// A set, like KtSourceModule.Builder: no module is a dependency twice.
+		private val dependencies = linkedSetOf<KtModule>()
 		var isSdk: Boolean = false
 		var jvmTarget: JvmTarget = DEFAULT_JVM_TARGET
 		var librarySources: KaLibrarySourceModule? = null

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

@@ -31,7 +31,9 @@ internal class KtSourceModule(
 		private val project: Project,
 	) {
 		lateinit var module: ModuleProject
-		private val dependencies = mutableListOf<KtModule>()
+
+		// A set: a jar on both the boot and compile classpath is one shared module (ADFA-6381).
+		private val dependencies = linkedSetOf<KtModule>()
 
 		fun addDependency(dep: KtModule) {
 			dependencies.add(dep)

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

@@ -2,47 +2,85 @@ 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.compiler.modules.KtSourceModule
 import com.itsaky.androidide.lsp.kotlin.fixtures.KtLspTest
 import com.itsaky.androidide.project.AndroidModels
 import com.itsaky.androidide.project.GradleModels
+import com.itsaky.androidide.project.JavaModels
 import com.itsaky.androidide.projects.api.AndroidModule
 import com.itsaky.androidide.projects.api.GradleProject
+import com.itsaky.androidide.projects.api.JavaModule
+import com.itsaky.androidide.projects.api.ModuleProject
 import com.itsaky.androidide.projects.api.Workspace
 import org.junit.Test
+import java.nio.file.Path
 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 androidJar = tempJar("android.jar")
 		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 sourceModules = collect(modulePaths.map { AndroidModule(gradleProject(it, bootClassPath = androidJar)) })
 
-		val androidJarDeps =
-			sourceModules.map { module ->
-				module.directRegularDependencies.filterIsInstance<KtLibraryModule>().filter { it.id == androidJar.pathString }
-			}
+		val androidJarDeps = sourceModules.map { it.libraryDeps(androidJar) }
 		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()) }
 	}
 
+	@Test
+	fun `modules sharing a compile classpath jar share one library module`() {
+		val libJar = tempJar("lib.jar")
+
+		val sourceModules = collect(listOf(":a", ":b").map { JavaModule(gradleProject(it, compileJar = libJar)) })
+
+		val libJarDeps = sourceModules.map { it.libraryDeps(libJar) }
+		libJarDeps.forEach { assertThat(it).hasSize(1) }
+		assertThat(libJarDeps[1].single()).isSameInstanceAs(libJarDeps[0].single())
+	}
+
+	@Test
+	fun `a jar on both the boot and compile classpath is one dependency`() {
+		val androidJar = tempJar("android.jar")
+
+		// Boot classpaths from every Android module go to every source module, so :j sees
+		// android.jar twice: once from :a's boot classpath, once from its own compile classpath.
+		val sourceModules =
+			collect(
+				listOf(
+					AndroidModule(gradleProject(":a", bootClassPath = androidJar)),
+					JavaModule(gradleProject(":j", compileJar = androidJar)),
+				),
+			)
+
+		assertThat(sourceModules.single { it.id == ":j" }.libraryDeps(androidJar)).hasSize(1)
+	}
+
+	private fun tempJar(name: String): Path =
+		lspTestRule.tempDir.root
+			.toPath()
+			.resolve(name)
+			.createFile()
+
+	private fun collect(subProjects: List<ModuleProject>): List<KtSourceModule> =
+		Workspace(
+			rootProject = GradleProject(gradleProject(":")),
+			subProjects = subProjects,
+			syncIssues = emptyList(),
+		).collectKtModules(env.project, env.applicationEnv)
+			.filterIsInstance<KtSourceModule>()
+
+	private fun KtSourceModule.libraryDeps(jar: Path) =
+		directRegularDependencies.filterIsInstance<KtLibraryModule>().filter { it.id == jar.pathString }
+
 	private fun gradleProject(
 		path: String,
-		bootClassPath: String? = null,
+		bootClassPath: Path? = null,
+		compileJar: Path? = null,
 	): GradleModels.GradleProject {
 		val dir = "/tmp/collect-kt-modules${path.replace(':', '/')}"
 		return GradleModels.GradleProject
@@ -58,7 +96,18 @@ class CollectKtModulesTest : KtLspTest() {
 						AndroidModels.AndroidProject
 							.newBuilder()
 							.setProjectType(AndroidModels.ProjectType.LibraryProject)
-							.addBootClassPaths(bootClassPath),
+							.addBootClassPaths(bootClassPath.pathString),
+					)
+				}
+				if (compileJar != null) {
+					setJavaProject(
+						JavaModels.JavaProject.newBuilder().addDependency(
+							JavaModels.JavaDependency
+								.newBuilder()
+								.setJarFilePath(compileJar.pathString)
+								.setScope(JavaModule.SCOPE_COMPILE)
+								.setExternalLibrary(JavaModels.JavaExternalLibraryDependency.getDefaultInstance()),
+						),
 					)
 				}
 			}.build()