feat: allow walking generated sources inside target folder

Author: AlexandrosAlexiou

server/src/main/kotlin/org/javacs/kt/CompilerClassPath.kt

@@ -45,7 +45,7 @@ class CompilerClassPath(
         compiler.updateConfiguration(config)
     }
 
-    /** Updates and possibly reinstantiates the compiler using new paths. */
+    /** Updates and possibly re-instantiates the compiler using new paths. */
     private fun refresh(
         updateClassPath: Boolean = true,
         updateBuildScriptClassPath: Boolean = true,

shared/src/main/kotlin/org/javacs/kt/SourceExclusions.kt

@@ -1,48 +1,78 @@
 package org.javacs.kt
 
-import org.javacs.kt.util.filePath
-import java.io.File
 import java.net.URI
 import java.nio.file.FileSystems
 import java.nio.file.Path
-import java.nio.file.Paths
+import org.javacs.kt.util.filePath
 
 // TODO: Read exclusions from gitignore/settings.json/... instead of
 // hardcoding them
 class SourceExclusions(
     private val workspaceRoots: Collection<Path>,
-    private val scriptsConfig: ScriptsConfiguration
+    scriptsConfig: ScriptsConfiguration,
 ) {
-    val excludedPatterns = (listOf(
-        ".git", ".hg", ".svn",                                                      // Version control systems
-        ".idea", ".idea_modules", ".vs", ".vscode", ".code-workspace", ".settings", // IDEs
-        "bazel-*", "bin", "build", "node_modules", "target",                        // Build systems
-    ) + when {
-        !scriptsConfig.enabled -> listOf("*.kts")
-        !scriptsConfig.buildScriptsEnabled -> listOf("*.gradle.kts")
-        else -> emptyList()
-    })
+    val excludedPatterns =
+        (listOf(
+            ".git",
+            ".hg",
+            ".svn", // Version control systems
+            ".idea",
+            ".idea_modules",
+            ".vs",
+            ".vscode",
+            ".code-workspace",
+            ".settings", // IDEs
+            "bazel-*",
+            "bin",
+            "build",
+            "node_modules",
+        ) +
+            when {
+                !scriptsConfig.enabled -> listOf("*.kts")
+                !scriptsConfig.buildScriptsEnabled -> listOf("*.gradle.kts")
+                else -> emptyList()
+            })
 
     private val exclusionMatchers = excludedPatterns
+        .filter { !it.startsWith("!") }
         .map { FileSystems.getDefault().getPathMatcher("glob:$it") }
 
-    /** Finds all non-excluded files recursively. */
-    fun walkIncluded(): Sequence<Path> = workspaceRoots.asSequence().flatMap { root ->
-        root.toFile()
-            .walk()
-            .onEnter { isPathIncluded(it.toPath()) }
-            .map { it.toPath() }
-    }
+    fun walkIncluded(): Sequence<Path> =
+        workspaceRoots.asSequence().flatMap { root ->
+            root.toFile().walk().onEnter { isPathIncluded(it.toPath()) }.map { it.toPath() }
+        }
 
-    /** Tests whether the given URI is not excluded. */
     fun isURIIncluded(uri: URI) = uri.filePath?.let(this::isPathIncluded) ?: false
 
-    /** Tests whether the given path is not excluded. */
-    fun isPathIncluded(file: Path): Boolean = workspaceRoots.any { file.startsWith(it) }
-        && exclusionMatchers.none { matcher ->
-            workspaceRoots
-                .mapNotNull { if (file.startsWith(it)) it.relativize(file) else null }
-                .flatMap { it } // Extract path segments
-                .any(matcher::matches)
+    fun isPathIncluded(file: Path): Boolean {
+        if (!workspaceRoots.any { file.startsWith(it) }) {
+            return false
+        }
+
+        val relativePaths = workspaceRoots
+            .mapNotNull { if (file.startsWith(it)) it.relativize(file) else null }
+            .flatten()
+
+        // Check if we're in a target directory
+        if (relativePaths.contains(Path.of("target"))) {
+            val pathList = relativePaths.toList()
+            val targetIndex = pathList.indexOf(Path.of("target"))
+
+            // Allow only target directory itself or if next directory is generated-sources
+            return pathList.size <= targetIndex + 1 ||
+                pathList[targetIndex + 1] == Path.of("generated-sources")
+        }
+
+        // If path matches any exclusion pattern, exclude it
+        if (exclusionMatchers.any { matcher ->
+                relativePaths.any(matcher::matches)
+            }) {
+            return false
         }
+
+        // Include paths outside target directory by default
+        return true
+    }
+
 }
+