java-functional-lsp 0.9.8__tar.gz → 0.9.10__tar.gz

{java_functional_lsp-0.9.8 → java_functional_lsp-0.9.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.9.8
+Version: 0.9.10
 Summary: Java LSP server enforcing functional programming best practices — null safety, immutability, no exceptions
 Project-URL: Homepage, https://github.com/aviadshiber/java-functional-lsp
 Project-URL: Repository, https://github.com/aviadshiber/java-functional-lsp

{java_functional_lsp-0.9.8 → java_functional_lsp-0.9.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "java-functional-lsp"
-version = "0.9.8"
+version = "0.9.10"
 description = "Java LSP server enforcing functional programming best practices — null safety, immutability, no exceptions"
 readme = "README.md"
 license = { text = "MIT" }

{java_functional_lsp-0.9.8 → java_functional_lsp-0.9.10}/src/java_functional_lsp/__init__.py

@@ -1,3 +1,3 @@
 """java-functional-lsp: A Java LSP server enforcing functional programming best practices."""
 
-__version__ = "0.9.8"
+__version__ = "0.9.10"

{java_functional_lsp-0.9.8 → java_functional_lsp-0.9.10}/src/java_functional_lsp/proxy.py

@@ -28,6 +28,7 @@ _INITIALIZE_TIMEOUT = 120.0  # seconds — module-scoped init can still be slow
 _START_RETRY_COOLDOWN = 300.0  # seconds — retry jdtls startup after transient failure
 DEFAULT_JVM_MAX_HEAP = "4g"
 _STDERR_LINE_MAX = 1000
+_MAX_EXPANDED_GROUPS: int = 5  # hard cap on concurrent Maven group workspace folders (prevents jdtls OOM)
 
 #: Minimum Java major version required by jdtls 1.57+. Anything below this
 #: is rejected by the jdtls Python launcher with ``"jdtls requires at least
@@ -374,6 +375,10 @@ class ModuleRegistry:
         if event is not None:
             event.set()
 
+    def uris(self) -> list[str]:
+        """Return all tracked module URIs (any state)."""
+        return list(self._states)
+
     def clear(self) -> None:
         """Reset all state. Used by tests."""
         self._states.clear()
@@ -445,6 +450,7 @@ def _version_key(name: str) -> tuple[int, ...]:
     return tuple(parts)
 
 
+@lru_cache(maxsize=64)
 def _find_maven_group_root(initial_module: Path, workspace_root: Path) -> Path:
     """Return the tightest Maven multi-module parent of *initial_module*.
 
@@ -641,7 +647,7 @@ class JdtlsProxy:
         self._initial_module_uri: str | None = None
         self.modules = ModuleRegistry()
         self.has_lombok = False
-        self._workspace_expanded = False
+        self._expanded_groups: set[str] = set()
         # Merkle snapshot diff: module_uri → (diff | None, current_snapshot)
         # Populated by _kick_module_diff (background task on add_module_if_new).
         # Consumed by server._apply_module_diff after module reaches READY.
@@ -887,33 +893,76 @@ class JdtlsProxy:
                 pass  # result storage is _kick_module_diff's responsibility
 
     async def add_module_if_new(self, file_uri: str) -> str | None:
-        """Add the module containing *file_uri* to jdtls if not already added.
+        """Add the module's Maven group to jdtls if not already expanded.
+
+        When the user navigates to a file in a new Maven group, we add the
+        group root (not the individual module) as a workspace folder.  This
+        gives jdtls the full Maven classpath for cross-module navigation
+        within that group.
 
-        Returns the module URI if a new module was added (UNKNOWN → ADDED),
-        or ``None`` if already known or unavailable. The returned URI can be
-        used with ``modules.wait_until_ready()`` for adaptive waiting.
+        Returns the module URI if a new group was expanded (for use with
+        ``modules.wait_until_ready()``), or ``None`` if already covered.
 
-        Calls ``modules.mark_added()`` before any ``await`` to prevent
-        duplicate add calls from concurrent coroutines.
+        Capped at ``_MAX_EXPANDED_GROUPS`` to prevent jdtls OOM.
         """
-        if not self._available or self._workspace_expanded:
+        if not self._available:
             return None
+        from pygls.uris import from_fs_path, to_fs_path
+
         module_uri = _resolve_module_uri(file_uri)
         if module_uri is None or self.modules.was_added(module_uri):
             return None
+
+        # Resolve the Maven group root for this module.
+        module_path = to_fs_path(module_uri)
+        workspace_path = to_fs_path(self._original_root_uri) if self._original_root_uri else None
+        if module_path and workspace_path:
+            group_root = _find_maven_group_root(Path(module_path), Path(workspace_path))
+            group_uri = from_fs_path(str(group_root)) or module_uri
+        else:
+            group_uri = module_uri
+
+        # Already expanded this group — module is covered, nothing to do.
+        if group_uri in self._expanded_groups:
+            return None
+
+        # Hard cap: refuse expansion beyond the limit.
+        if len(self._expanded_groups) >= _MAX_EXPANDED_GROUPS:
+            logger.warning(
+                "jdtls: refusing to expand group for %s — %d groups already expanded (max %d). Restart IDE to reset.",
+                Path(module_path or module_uri).name,
+                len(self._expanded_groups),
+                _MAX_EXPANDED_GROUPS,
+            )
+            return None
+
+        # Remove individually-added child modules within this group to avoid
+        # double-indexing once the group root covers them.  Must run BEFORE
+        # mark_added so we don't remove the module we're about to add.
+        group_path = Path(to_fs_path(group_uri) or group_uri)
+        removed: list[dict[str, str]] = []
+        for uri in self.modules.uris():
+            if uri == group_uri:
+                continue
+            p = Path(to_fs_path(uri) or uri)
+            if p == group_path or p.is_relative_to(group_path):
+                removed.append({"uri": uri, "name": p.name})
+
         # Mark ADDED before await — atomic in asyncio, prevents duplicate sends.
         self.modules.mark_added(module_uri)
-        from pygls.uris import to_fs_path
+        self.modules.mark_added(group_uri)
+        self._expanded_groups.add(group_uri)
 
-        logger.info("jdtls: adding module %s", _redact_path(to_fs_path(module_uri)))
-        mod_name = Path(to_fs_path(module_uri) or module_uri).name
+        group_name = Path(to_fs_path(group_uri) or group_uri).name
+        logger.info(
+            "jdtls: expanding to group %s (group %d/%d)", group_name, len(self._expanded_groups), _MAX_EXPANDED_GROUPS
+        )
         await self.send_notification(
             _WORKSPACE_DID_CHANGE_FOLDERS,
-            {"event": {"added": [{"uri": module_uri, "name": mod_name}], "removed": []}},
+            {"event": {"added": [{"uri": group_uri, "name": group_name}], "removed": removed}},
         )
-        # Fire-and-forget: compute snapshot diff in background so it is ready
-        # when the module reaches READY state.  Does NOT block the jdtls
-        # readiness timeout (which starts ticking at mark_added above).
+
+        # Fire-and-forget: compute snapshot diff in background.
         diff_task = asyncio.create_task(self._kick_module_diff(module_uri))
         self._proxy_bg_tasks.add(diff_task)
         diff_task.add_done_callback(self._proxy_bg_tasks.discard)
@@ -921,24 +970,16 @@ class JdtlsProxy:
         return module_uri
 
     async def expand_full_workspace(self) -> None:
-        """Expand jdtls workspace to the nearest Maven module-group root.
+        """Expand jdtls workspace to the initial module's Maven group root.
 
-        Instead of expanding all the way to the IDE workspace root (which may
-        contain hundreds of Maven modules and cause jdtls OOM), this walks up
-        from the initial module to find the *nearest* ancestor directory whose
-        ``pom.xml`` declares ``<modules>`` — i.e. the tightest multi-module
-        Maven parent.  This covers sibling modules (the common case for
-        cross-module navigation) without ballooning the index.
-
-        Falls back to the initial module itself when no intermediate
-        multi-module parent is found (e.g. flat modules sitting directly
-        under the workspace root), keeping the jdtls scope as tight as
-        possible.
+        Called once during lazy start.  Subsequent groups are expanded
+        on-demand by ``add_module_if_new()`` as the user navigates to
+        files in other Maven groups.
 
         Removes all individually-added module folders to avoid double-indexing
         with the newly added group root.
         """
-        if self._workspace_expanded or not self._available or not self._original_root_uri:
+        if not self._available or not self._original_root_uri:
             return
         from pygls.uris import from_fs_path, to_fs_path
 
@@ -952,26 +993,31 @@ class JdtlsProxy:
 
         root_path = group_root_path
         root_uri = from_fs_path(root_path) or self._original_root_uri
-        if self.modules.was_added(root_uri):
-            self._workspace_expanded = True
+
+        # Already expanded (e.g. initial module IS the group root, or called twice).
+        if root_uri in self._expanded_groups or self.modules.was_added(root_uri):
+            self._expanded_groups.add(root_uri)
             return
         self.modules.mark_added(root_uri)
 
-        # Remove ALL individually-added modules to prevent double-indexing with
-        # the full root.  This covers both the initial scoped module and any
-        # modules added by add_module_if_new during the ensure_started window.
+        # Remove individually-added modules that are children of the new root.
+        # This covers the initial scoped module and any modules added by
+        # add_module_if_new during the ensure_started window.
+        root_path_obj = Path(root_path)
         removed: list[dict[str, str]] = []
-        for uri in list(self.modules._states):
-            if uri != root_uri:
-                p = to_fs_path(uri) or uri
-                removed.append({"uri": uri, "name": Path(p).name})
+        for uri in self.modules.uris():
+            if uri == root_uri:
+                continue
+            p = Path(to_fs_path(uri) or uri)
+            if p == root_path_obj or p.is_relative_to(root_path_obj):
+                removed.append({"uri": uri, "name": p.name})
 
         logger.info("jdtls: expanding workspace to module group %s", _redact_path(root_path))
         await self.send_notification(
             _WORKSPACE_DID_CHANGE_FOLDERS,
             {"event": {"added": [{"uri": root_uri, "name": Path(root_path).name}], "removed": removed}},
         )
-        self._workspace_expanded = True
+        self._expanded_groups.add(root_uri)
 
     async def stop(self) -> None:
         """Shutdown jdtls subprocess gracefully."""

{java_functional_lsp-0.9.8 → java_functional_lsp-0.9.10}/src/java_functional_lsp/server.py

@@ -76,13 +76,18 @@ class JavaFunctionalLspServer(LanguageServer):
         self._skip_jdtls_registration: bool = False
         self._init_generation: int = 0
 
-    def _on_jdtls_diagnostics(self, uri: str, _diagnostics: list[Any]) -> None:
+    def _on_jdtls_diagnostics(self, uri: str, diagnostics: list[Any]) -> None:
         """Called when jdtls publishes diagnostics — merge with custom and re-publish.
 
         Also marks the file's module as READY, since receiving diagnostics from
         jdtls is a reliable signal that the module has been indexed (more reliable
         than a first non-None response which may be semantically empty).
 
+        Exception: if any diagnostic carries ``_JDTLS_NON_PROJECT_CODE`` (code 16),
+        jdtls has opened the file but hasn't resolved its Maven project yet — only
+        syntax errors are available.  We skip the READY transition and wait for the
+        follow-up publish (after Maven import completes) that arrives without code 16.
+
         When a module transitions to READY, fires ``_apply_module_diff`` to
         notify jdtls about any externally changed files (e.g., after git pull).
         """
@@ -90,12 +95,18 @@ class JavaFunctionalLspServer(LanguageServer):
             return
         module_uri = _resolve_module_uri(uri)
         if module_uri:
-            already_ready = self._proxy.modules.is_ready(module_uri)
-            self._proxy.modules.mark_ready(module_uri)
-            if not already_ready:
-                # First READY transition only — subsequent diagnostics for the same
-                # module are no-ops to avoid spawning O(files) redundant tasks.
-                _fire_and_forget(_apply_module_diff(self._proxy, module_uri))
+            is_non_project = any(
+                str(d.get("code", "")) == _JDTLS_NON_PROJECT_CODE for d in diagnostics if isinstance(d, dict)
+            )
+            if is_non_project:
+                logger.info("jdtls: skipping READY for %s (non-project file, Maven import pending)", Path(uri).name)
+            else:
+                already_ready = self._proxy.modules.is_ready(module_uri)
+                self._proxy.modules.mark_ready(module_uri)
+                if not already_ready:
+                    # First READY transition only — subsequent diagnostics for the same
+                    # module are no-ops to avoid spawning O(files) redundant tasks.
+                    _fire_and_forget(_apply_module_diff(self._proxy, module_uri))
         try:
             _analyze_and_publish(uri)
         except FileNotFoundError:
@@ -419,7 +430,7 @@ def on_initialize(params: lsp.InitializeParams) -> lsp.InitializeResult:
 
 
 @server.feature(lsp.INITIALIZED)
-async def on_initialized(_params: lsp.InitializedParams) -> None:
+async def on_initialized(_: lsp.InitializedParams) -> None:
     """Check jdtls availability; actual start deferred to first didOpen."""
     logger.info(
         "java-functional-lsp initialized (rules: %s)",
@@ -672,6 +683,12 @@ _LIGHTWEIGHT_METHODS: frozenset[str] = frozenset(
     }
 )
 
+# jdtls diagnostic code for files it opened but hasn't resolved into a Maven project yet.
+# When this appears in a publishDiagnostics batch, jdtls has syntax info only — no classpath,
+# no cross-file resolution.  We must NOT mark the module READY yet; wait for a re-publish
+# without code 16 (after Maven project import finishes).
+_JDTLS_NON_PROJECT_CODE: str = "16"
+
 
 async def _ensure_module_and_forward(
     method: str,
@@ -707,7 +724,7 @@ async def _ensure_module_and_forward(
         return result
 
     # Cold path: add module if unknown, then wait for ready.
-    logger.info("jdtls: %s [cold] module=%s expanded=%s", method, short_mod, proxy._workspace_expanded)
+    logger.info("jdtls: %s [cold] module=%s groups=%d", method, short_mod, len(proxy._expanded_groups))
     new_module_uri = await proxy.add_module_if_new(file_uri)
 
     serialized = _serialize_params(params)

{java_functional_lsp-0.9.8 → java_functional_lsp-0.9.10}/tests/test_proxy.py

@@ -983,6 +983,13 @@ class TestFindModuleRoot:
 class TestLazyStart:
     """Tests for lazy-start proxy features."""
 
+    @pytest.fixture(autouse=True)
+    def _clear_group_root_cache(self) -> None:  # type: ignore[override]
+        """Clear _find_maven_group_root lru_cache between tests."""
+        from java_functional_lsp.proxy import _find_maven_group_root
+
+        _find_maven_group_root.cache_clear()
+
     def test_check_available_true(self) -> None:
         from java_functional_lsp.proxy import JdtlsProxy
 
@@ -1164,7 +1171,7 @@ class TestLazyStart:
 
         # No notification — module was already added and is already the tightest scope
         proxy.send_notification.assert_not_called()  # type: ignore[attr-defined]
-        assert proxy._workspace_expanded is True
+        assert len(proxy._expanded_groups) > 0
 
     async def test_expand_full_workspace_sends_notification(self) -> None:
         from unittest.mock import AsyncMock
@@ -1177,7 +1184,7 @@ class TestLazyStart:
         proxy.send_notification = AsyncMock()  # type: ignore[assignment]
         await proxy.expand_full_workspace()
         proxy.send_notification.assert_called_once()  # type: ignore[attr-defined]
-        assert proxy._workspace_expanded is True
+        assert len(proxy._expanded_groups) > 0
 
     async def test_expand_full_workspace_removes_initial_module(self, tmp_path: Path) -> None:
         """All modules in _states are removed when expanding to an intermediate group root."""
@@ -1227,7 +1234,7 @@ class TestLazyStart:
         proxy.send_notification = AsyncMock()  # type: ignore[assignment]
         await proxy.expand_full_workspace()
         proxy.send_notification.assert_not_called()  # type: ignore[attr-defined]
-        assert proxy._workspace_expanded is False
+        assert len(proxy._expanded_groups) == 0
 
     async def test_expand_full_workspace_noop_when_already_added(self) -> None:
         from unittest.mock import AsyncMock
@@ -1241,7 +1248,109 @@ class TestLazyStart:
         proxy.send_notification = AsyncMock()  # type: ignore[assignment]
         await proxy.expand_full_workspace()
         proxy.send_notification.assert_not_called()  # type: ignore[attr-defined]
-        assert proxy._workspace_expanded is True
+        assert len(proxy._expanded_groups) > 0
+
+    async def test_add_module_cross_group_expands_new_group(self, tmp_path: Path) -> None:
+        """Navigating to a file in a different Maven group expands that group."""
+        from unittest.mock import AsyncMock
+
+        from java_functional_lsp.proxy import JdtlsProxy
+
+        # Layout: monorepo/group-a/mod-a, monorepo/group-b/mod-b
+        monorepo = tmp_path / "monorepo"
+        group_a = monorepo / "group-a"
+        mod_a = group_a / "mod-a"
+        group_b = monorepo / "group-b"
+        mod_b = group_b / "mod-b"
+        for d in (mod_a, mod_b):
+            d.mkdir(parents=True)
+            (d / "pom.xml").write_text("<project/>")
+        (group_a / "pom.xml").write_text("<project><modules><module>mod-a</module></modules></project>")
+        (group_b / "pom.xml").write_text("<project><modules><module>mod-b</module></modules></project>")
+
+        proxy = JdtlsProxy()
+        proxy._available = True
+        proxy._original_root_uri = monorepo.as_uri()
+        proxy._initial_module_uri = mod_a.as_uri()
+        proxy._expanded_groups.add(group_a.as_uri())  # simulate initial expansion done
+        proxy.modules.mark_added(mod_a.as_uri())
+        proxy.send_notification = AsyncMock()  # type: ignore[assignment]
+
+        file_uri = (mod_b / "src" / "Foo.java").as_uri()
+        # Create the file so _resolve_module_uri can find mod-b's pom.xml
+        (mod_b / "src").mkdir()
+        (mod_b / "src" / "Foo.java").touch()
+
+        result = await proxy.add_module_if_new(file_uri)
+        assert result is not None  # module_uri returned for wait_until_ready
+        proxy.send_notification.assert_called_once()  # type: ignore[attr-defined]
+        call_args = proxy.send_notification.call_args[0]  # type: ignore[attr-defined]
+        event = call_args[1]["event"]
+        assert event["added"][0]["uri"] == group_b.as_uri()
+        assert event["removed"] == []  # no child modules to remove from new group
+        assert group_b.as_uri() in proxy._expanded_groups
+        assert len(proxy._expanded_groups) == 2
+
+    async def test_add_module_within_expanded_group_is_noop(self, tmp_path: Path) -> None:
+        """A file within an already-expanded group returns None."""
+        from unittest.mock import AsyncMock
+
+        from java_functional_lsp.proxy import JdtlsProxy
+
+        monorepo = tmp_path / "monorepo"
+        group = monorepo / "group"
+        mod_a = group / "mod-a"
+        mod_b = group / "mod-b"
+        for d in (mod_a, mod_b):
+            d.mkdir(parents=True)
+            (d / "pom.xml").write_text("<project/>")
+        (group / "pom.xml").write_text(
+            "<project><modules><module>mod-a</module><module>mod-b</module></modules></project>"
+        )
+
+        proxy = JdtlsProxy()
+        proxy._available = True
+        proxy._original_root_uri = monorepo.as_uri()
+        proxy._expanded_groups.add(group.as_uri())
+        proxy.send_notification = AsyncMock()  # type: ignore[assignment]
+
+        file_uri = (mod_b / "src" / "Bar.java").as_uri()
+        (mod_b / "src").mkdir()
+        (mod_b / "src" / "Bar.java").touch()
+
+        result = await proxy.add_module_if_new(file_uri)
+        assert result is None
+        proxy.send_notification.assert_not_called()  # type: ignore[attr-defined]
+
+    async def test_add_module_at_cap_refuses_expansion(self, tmp_path: Path) -> None:
+        """Expansion is refused when _MAX_EXPANDED_GROUPS is reached."""
+        from unittest.mock import AsyncMock
+
+        from java_functional_lsp.proxy import _MAX_EXPANDED_GROUPS, JdtlsProxy
+
+        monorepo = tmp_path / "monorepo"
+        new_group = monorepo / "new-group"
+        mod = new_group / "mod"
+        mod.mkdir(parents=True)
+        (mod / "pom.xml").write_text("<project/>")
+        (new_group / "pom.xml").write_text("<project><modules><module>mod</module></modules></project>")
+
+        proxy = JdtlsProxy()
+        proxy._available = True
+        proxy._original_root_uri = monorepo.as_uri()
+        # Fill up to the cap with dummy groups
+        for i in range(_MAX_EXPANDED_GROUPS):
+            proxy._expanded_groups.add(f"file:///fake/group-{i}")
+        proxy.send_notification = AsyncMock()  # type: ignore[assignment]
+
+        file_uri = (mod / "src" / "Baz.java").as_uri()
+        (mod / "src").mkdir()
+        (mod / "src" / "Baz.java").touch()
+
+        result = await proxy.add_module_if_new(file_uri)
+        assert result is None
+        proxy.send_notification.assert_not_called()  # type: ignore[attr-defined]
+        assert len(proxy._expanded_groups) == _MAX_EXPANDED_GROUPS
 
     async def test_ensure_started_no_build_file(self) -> None:
         """ensure_started with no build file should pass module_root_uri=None."""

{java_functional_lsp-0.9.8 → java_functional_lsp-0.9.10}/tests/test_server.py

@@ -290,6 +290,54 @@ class TestServerInternals:
         finally:
             server.workspace.remove_text_document(uri)
 
+    def test_on_jdtls_diagnostics_non_project_skips_ready(self) -> None:
+        """A publishDiagnostics batch with code-16 must NOT mark the module READY."""
+        from unittest.mock import patch
+
+        from java_functional_lsp.proxy import ModuleState
+        from java_functional_lsp.server import server
+
+        server._proxy.modules.clear()
+        uri = "file:///mod/Foo.java"
+        non_project_diag = {
+            "code": "16",
+            "message": "Foo.java is a non-project file, only syntax errors are reported",
+            "source": "Java",
+            "severity": 2,
+            "range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 1}},
+        }
+        with (
+            patch("java_functional_lsp.server._resolve_module_uri", return_value="file:///mod"),
+            patch("java_functional_lsp.server._analyze_and_publish"),
+        ):
+            server._on_jdtls_diagnostics(uri, [non_project_diag])
+        assert server._proxy.modules.get_state("file:///mod") != ModuleState.READY
+
+    def test_on_jdtls_diagnostics_project_file_marks_ready(self) -> None:
+        """A publishDiagnostics batch without code-16 MUST mark the module READY."""
+        from unittest.mock import patch
+
+        from java_functional_lsp.proxy import ModuleState
+        from java_functional_lsp.server import server
+
+        server._proxy.modules.clear()
+        uri = "file:///mod/Pr.java"
+        real_diag = {
+            "code": "268435844",
+            "message": "Some unused import",
+            "source": "Java",
+            "severity": 2,
+            "range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 1}},
+        }
+        with (
+            patch("java_functional_lsp.server._resolve_module_uri", return_value="file:///mod"),
+            patch("java_functional_lsp.server._analyze_and_publish"),
+            patch("java_functional_lsp.server._fire_and_forget"),
+        ):
+            server._on_jdtls_diagnostics(uri, [real_diag])
+        assert server._proxy.modules.get_state("file:///mod") == ModuleState.READY
+        server._proxy.modules.clear()
+
     def test_init_capabilities_exclude_jdtls_features(self) -> None:
         """Static capabilities must NOT include hover/definition/references/completion/documentSymbol.
 
@@ -541,7 +589,7 @@ class TestServerInternals:
         mock_add = AsyncMock(return_value="file:///mod")
         mock_send = AsyncMock(side_effect=[None, {"result": "ok"}])
 
-        async def mock_wait(uri: str, timeout: float = 30.0) -> bool:  # pyright: ignore[reportUnusedParameter]
+        async def mock_wait(uri: str, timeout: float = 30.0) -> bool:  # type: ignore[reportUnusedParameter]
             srv._proxy.modules.mark_ready(uri)
             return True