feat: gradle source sets support

Author: amgdev9

app/src/main/kotlin/org/kotlinlsp/buildsystem/Gradle.kt

@@ -36,6 +36,7 @@ class GradleBuildSystem(
 
     override fun resolveModulesIfNeeded(cachedMetadata: String?): BuildSystem.Result? {
         val androidVariant = "debug"    // TODO Make it a config parameter
+
         if(!shouldReloadGradleProject(cachedMetadata)) {
             return null
         }
@@ -59,7 +60,7 @@ class GradleBuildSystem(
         println(output)
 
         val jvmTarget = checkNotNull(JvmTarget.fromString(ideaProject.jdkName)) { "Unknown jdk target" }
-        val jdkModule = ideaProject.javaLanguageSettings?.jdk?.let { jdk ->
+        val jdkModule = ideaProject.javaLanguageSettings.jdk?.let { jdk ->
             LibraryModule(
                 id = "JDK ${jvmTarget.description}",
                 appEnvironment = appEnvironment,
@@ -70,43 +71,73 @@ class GradleBuildSystem(
             )
         }
 
-        val modules = ideaProject.modules.map { module ->
-            val dependencies = module
-                .dependencies
-                .filterIsInstance<IdeaSingleEntryLibraryDependency>()
-                .map { dependency ->
-                    LibraryModule(
-                        id = dependency.file.name,
-                        appEnvironment = appEnvironment,
-                        project = project,
-                        javaVersion = jvmTarget,
-                        contentRoots = listOf(dependency.file.toPath()),
-                    )
+        val modules = ideaProject
+            .modules
+            .asSequence()
+            .mapNotNull { module ->
+                val contentRoot =
+                    module.contentRoots.first()   // Don't know in which cases we would have multiple contentRoots
+                val sourceDirs = contentRoot.sourceDirectories.map { it.directory.toPath() }
+                val testDirs = contentRoot.testDirectories.map { it.directory.toPath() }
+
+                // Ignore empty modules
+                if(sourceDirs.isEmpty()) return@mapNotNull null
+
+                // Seems that dependencies are the same for source and test source-sets?
+                val dependencies: MutableList<Module> = module
+                    .dependencies
+                    .filterIsInstance<IdeaSingleEntryLibraryDependency>()
+                    .map { dependency ->
+                        LibraryModule(
+                            id = dependency.file.name,
+                            appEnvironment = appEnvironment,
+                            project = project,
+                            javaVersion = jvmTarget,
+                            contentRoots = listOf(dependency.file.toPath()),
+                        )
+                    }
+                    .toMutableList()
+
+                if (jdkModule != null) {
+                    dependencies.add(jdkModule)
                 }
 
-            val allDependencies: MutableList<Module> = dependencies.toMutableList()
-            if (jdkModule != null) {
-                allDependencies.add(jdkModule)
+                val sourceModule = SourceModule(
+                    id = module.name,
+                    project = project,
+                    contentRoots = sourceDirs,
+                    dependencies = dependencies,
+                    javaVersion = jvmTarget,
+                    kotlinVersion = LanguageVersion.KOTLIN_2_1,
+                )
+
+                if (testDirs.isEmpty()) return@mapNotNull listOf(sourceModule)
+
+                val testDependencies = dependencies.toMutableList()
+                testDependencies.add(sourceModule)
+
+                val testModule = SourceModule(
+                    id = module.name,
+                    project = project,
+                    contentRoots = testDirs,
+                    dependencies = testDependencies,
+                    javaVersion = jvmTarget,
+                    kotlinVersion = LanguageVersion.KOTLIN_2_1,
+                )
+
+                return@mapNotNull listOf(sourceModule, testModule)
             }
-            
-            SourceModule(
-                id = module.name,
-                project = project,
-                contentRoots = listOf(module.contentRoots.first().rootDirectory.toPath()),
-                dependencies = allDependencies,
-                javaVersion = jvmTarget,
-                kotlinVersion = LanguageVersion.KOTLIN_2_1,
-            )
-        }
+            .flatten()
+            .toList()
 
-        // TODO Support multiple modules, for now take the last one
-        val rootModule = modules.last()
         progressNotifier.onReportProgress(WorkDoneProgressKind.end, PROGRESS_TOKEN, "[GRADLE] Done")
 
         val metadata = Gson().toJson(computeGradleMetadata(ideaProject))
+
         connection.close()
         androidInitScript.delete()
-        return BuildSystem.Result(listOf(rootModule), metadata)
+
+        return BuildSystem.Result(modules, metadata)
     }
 }
 

app/src/test/kotlin/org/kotlinlsp/Gradle.kt

@@ -13,6 +13,7 @@ import org.kotlinlsp.buildsystem.GradleBuildSystem
 import org.mockito.Mockito.mock
 import java.nio.file.Paths
 import org.kotlinlsp.analysis.modules.Module
+import kotlin.io.path.Path
 import kotlin.io.path.absolutePathString
 
 class Gradle {
@@ -45,19 +46,36 @@ class Gradle {
     fun `loads single module project successfully`() = scenario("single-module") { buildSystem ->
         // Act
         val (modules, _) = buildSystem.resolveModulesIfNeeded(cachedMetadata = null)!!
-        val rootModule = modules.first()
 
         // Assert
-        assertEquals(rootModule.isSourceModule, true)
-        assertEquals(rootModule.contentRoots.first().absolutePathString(), "$cwd/test-projects/single-module/app")
-        assertEquals(rootModule.dependencies.size, 3)
-        rootModule.dependencies.forEach {
+        assertEquals(modules.size, 2)
+        assertEquals(modules[0].isSourceModule, true)
+        assertEquals(
+            modules[0].contentRoots,
+            listOf(
+                Path("$cwd/test-projects/single-module/app/src/main/java"),
+                Path("$cwd/test-projects/single-module/app/src/main/kotlin"),
+            )
+        )
+        assertEquals(modules[0].dependencies.size, 3)
+        modules[0].dependencies.forEach {
             assertEquals(it.dependencies.size, 0)
             assertEquals(it.contentRoots.size, 1)
         }
-        val depNames = rootModule.dependencies.map { it.firstContentRootFilename() }.toSet()
+        val depNames = modules[0].dependencies.map { it.firstContentRootFilename() }.toSet()
         assertTrue("annotations-13.0.jar" in depNames)
         assertTrue("kotlin-stdlib-2.1.20.jar" in depNames)
+
+        assertEquals(modules[1].isSourceModule, true)
+        assertEquals(
+            modules[1].contentRoots,
+            listOf(
+                Path("$cwd/test-projects/single-module/app/src/test/java"),
+                Path("$cwd/test-projects/single-module/app/src/test/kotlin"),
+            )
+        )
+        assertEquals(modules[1].dependencies.size, 4)
+        assertEquals(modules[1].dependencies.filter { it.isSourceModule }.size, 1)
     }
 
     @Test