java-functional-lsp 0.9.0__tar.gz → 0.9.2__tar.gz

{java_functional_lsp-0.9.0 → java_functional_lsp-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.9.0
+Version: 0.9.2
 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.0 → java_functional_lsp-0.9.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "java-functional-lsp"
-version = "0.9.0"
+version = "0.9.2"
 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.0 → java_functional_lsp-0.9.2}/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.0"
+__version__ = "0.9.2"

{java_functional_lsp-0.9.0 → java_functional_lsp-0.9.2}/src/java_functional_lsp/proxy.py

@@ -445,6 +445,42 @@ def _version_key(name: str) -> tuple[int, ...]:
     return tuple(parts)
 
 
+def _find_maven_group_root(initial_module: Path, workspace_root: Path) -> Path:
+    """Return the tightest Maven multi-module parent of *initial_module*.
+
+    Walks up from ``initial_module.parent`` (the module itself is skipped —
+    we want its *parent* group, not the module's own pom) toward (and
+    including) ``workspace_root``, returning the first ancestor whose
+    ``pom.xml`` contains a ``<modules>`` section.  Falls back to
+    ``workspace_root`` when no such intermediate parent exists (e.g. flat
+    single-level monorepos).
+
+    This keeps the jdtls index bounded to a module *group* (typically
+    5-20 modules) rather than the full IDE workspace (potentially 200+ modules)
+    which would cause ``OutOfMemoryError: Java heap space`` during indexing.
+
+    Both *initial_module* and *workspace_root* are resolved to real paths
+    before walking to avoid symlink-based boundary escapes.
+    """
+    workspace_root = workspace_root.resolve()
+    current = initial_module.resolve().parent
+    # Bail immediately if the initial module is outside the workspace.
+    if not current.is_relative_to(workspace_root):
+        return workspace_root
+    while True:
+        pom = current / "pom.xml"
+        if pom.is_file():
+            try:
+                if "<modules>" in pom.read_text(encoding="utf-8", errors="ignore"):
+                    return current
+            except OSError:
+                pass
+        if current in (workspace_root, current.parent):
+            break
+        current = current.parent
+    return workspace_root
+
+
 @lru_cache(maxsize=256)
 def _module_snapshot_path(module_uri: str) -> Path:
     """Return the path for the persistent snapshot file for *module_uri*.
@@ -777,6 +813,11 @@ class JdtlsProxy:
         Uses a ``deque(maxlen=200)`` so oldest entries are dropped in O(1)
         when the queue overflows during long jdtls startup.
         """
+        if len(self._queued_notifications) >= _MAX_QUEUED_NOTIFICATIONS:
+            logger.warning(
+                "jdtls: notification queue full (%d cap) — oldest entry dropped; some didOpen events may be missed",
+                _MAX_QUEUED_NOTIFICATIONS,
+            )
         self._queued_notifications.append((method, params))
 
     async def flush_queued_notifications(self) -> None:
@@ -832,7 +873,7 @@ class JdtlsProxy:
         Calls ``modules.mark_added()`` before any ``await`` to prevent
         duplicate add calls from concurrent coroutines.
         """
-        if not self._available:
+        if not self._available or self._workspace_expanded:
             return None
         module_uri = _resolve_module_uri(file_uri)
         if module_uri is None or self.modules.was_added(module_uri):
@@ -857,29 +898,50 @@ class JdtlsProxy:
         return module_uri
 
     async def expand_full_workspace(self) -> None:
-        """Expand jdtls workspace to the full monorepo root (background task).
+        """Expand jdtls workspace to the nearest Maven module-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 full IDE workspace root when no intermediate
+        multi-module parent is found.
 
-        Removes the initial module-scoped folder and adds the full root to
-        avoid double-indexing.
+        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:
             return
         from pygls.uris import from_fs_path, to_fs_path
 
-        root_path = to_fs_path(self._original_root_uri) or self._original_root_uri
+        workspace_path = to_fs_path(self._original_root_uri) or self._original_root_uri
+
+        # Find the tightest multi-module Maven parent of the initial module.
+        group_root_path: str = workspace_path
+        if self._initial_module_uri:
+            initial_path = to_fs_path(self._initial_module_uri) or self._initial_module_uri
+            group_root_path = str(_find_maven_group_root(Path(initial_path), Path(workspace_path)))
+
+        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
             return
         self.modules.mark_added(root_uri)
 
-        # Remove initial module folder to avoid double-indexing.
+        # 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.
         removed: list[dict[str, str]] = []
-        if self._initial_module_uri and self._initial_module_uri != root_uri:
-            ini_path = to_fs_path(self._initial_module_uri) or self._initial_module_uri
-            removed.append({"uri": self._initial_module_uri, "name": Path(ini_path).name})
+        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})
 
-        logger.info("jdtls: expanding to full workspace %s", _redact_path(root_path))
+        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}},

{java_functional_lsp-0.9.0 → java_functional_lsp-0.9.2}/src/java_functional_lsp/server.py

@@ -98,6 +98,8 @@ class JavaFunctionalLspServer(LanguageServer):
                 _fire_and_forget(_apply_module_diff(self._proxy, module_uri))
         try:
             _analyze_and_publish(uri)
+        except FileNotFoundError:
+            pass  # Virtual jdtls file (e.g., decompiled source in jdtls-data); skip silently.
         except Exception as e:
             logger.error("Error re-publishing diagnostics for %s: %s", uri, e)
 
@@ -602,14 +604,21 @@ async def _lazy_start_jdtls(file_uri: str) -> None:
     """Background task: start jdtls scoped to the module containing *file_uri*.
 
     Runs in the background so ``on_did_open`` returns immediately with custom
-    diagnostics. After jdtls initializes, registers capabilities and flushes
-    queued notifications. Workspace expansion is NOT done eagerly — modules
-    are loaded on-demand via ``add_module_if_new()`` as files are opened.
+    diagnostics.  After jdtls initializes, the workspace is immediately expanded
+    to the full IDE workspace root (inside-out) so jdtls discovers all sibling
+    modules before any queued ``didOpen`` notifications are flushed.  This means
+    ``add_module_if_new`` is a no-op for all subsequent file opens — jdtls
+    already covers the whole project.
     """
     try:
         started = await server._proxy.ensure_started(server._init_params, file_uri, config=server._config)
         if started:
             logger.info("jdtls proxy active — full Java language support enabled")
+            # Expand to full workspace BEFORE flushing queued notifications so
+            # all files are processed in the full-workspace context (inside-out).
+            # expand_full_workspace is a no-op for standalone projects where
+            # the workspace root equals the initial module.
+            await server._proxy.expand_full_workspace()
             if server._skip_jdtls_registration:
                 logger.info("Skipping dynamic capability registration (no-register mode)")
             else:

{java_functional_lsp-0.9.0 → java_functional_lsp-0.9.2}/tests/test_proxy.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import asyncio
 import json
 import subprocess
+from pathlib import Path
 from typing import Any
 from unittest.mock import MagicMock, patch
 
@@ -1037,6 +1038,65 @@ class TestLazyStart:
             assert result2 is None  # Already known
             assert proxy.send_notification.call_count == 1  # type: ignore[attr-defined]
 
+    async def test_expand_uses_maven_group_root_not_workspace_root(self, tmp_path: Path) -> None:
+        """expand_full_workspace expands to nearest multi-module Maven parent, not the full IDE root."""
+        from unittest.mock import AsyncMock
+
+        from java_functional_lsp.proxy import JdtlsProxy
+
+        # Layout: workspace/group/module  — group/pom.xml has <modules>
+        workspace = tmp_path / "workspace"
+        group = workspace / "group"
+        module = group / "module"
+        module.mkdir(parents=True)
+        (group / "pom.xml").write_text("<project><modules><module>module</module></modules></project>")
+        (workspace / "pom.xml").write_text("<project><modules><module>group</module></modules></project>")
+
+        module_uri = module.as_uri()
+        workspace_uri = workspace.as_uri()
+
+        proxy = JdtlsProxy()
+        proxy._available = True
+        proxy._original_root_uri = workspace_uri
+        proxy._initial_module_uri = module_uri
+        proxy.modules.mark_added(module_uri)
+        proxy.send_notification = AsyncMock()  # type: ignore[assignment]
+        await proxy.expand_full_workspace()
+
+        call_args = proxy.send_notification.call_args[0]  # type: ignore[attr-defined]
+        event = call_args[1]["event"]
+        # Should expand to group/, NOT workspace/
+        assert event["added"][0]["uri"] == group.as_uri()
+        assert event["added"][0]["uri"] != workspace_uri
+
+    async def test_expand_falls_back_to_workspace_root_when_no_group_pom(self, tmp_path: Path) -> None:
+        """Falls back to the IDE workspace root when no intermediate multi-module parent exists."""
+        from unittest.mock import AsyncMock
+
+        from java_functional_lsp.proxy import JdtlsProxy
+
+        # Flat layout: workspace/module — no intermediate pom.xml
+        workspace = tmp_path / "workspace"
+        module = workspace / "module"
+        module.mkdir(parents=True)
+        # workspace/pom.xml has <modules>, but there's nothing in between
+        (workspace / "pom.xml").write_text("<project><modules><module>module</module></modules></project>")
+
+        module_uri = module.as_uri()
+        workspace_uri = workspace.as_uri()
+
+        proxy = JdtlsProxy()
+        proxy._available = True
+        proxy._original_root_uri = workspace_uri
+        proxy._initial_module_uri = module_uri
+        proxy.modules.mark_added(module_uri)
+        proxy.send_notification = AsyncMock()  # type: ignore[assignment]
+        await proxy.expand_full_workspace()
+
+        call_args = proxy.send_notification.call_args[0]  # type: ignore[attr-defined]
+        event = call_args[1]["event"]
+        assert event["added"][0]["uri"] == workspace_uri
+
     async def test_expand_full_workspace_sends_notification(self) -> None:
         from unittest.mock import AsyncMock
 
@@ -1051,7 +1111,7 @@ class TestLazyStart:
         assert proxy._workspace_expanded is True
 
     async def test_expand_full_workspace_removes_initial_module(self) -> None:
-        """When _initial_module_uri differs from root, it should be in the removed list."""
+        """All modules in _states (not just _initial_module_uri) are removed on expansion."""
         from unittest.mock import AsyncMock
 
         from java_functional_lsp.proxy import JdtlsProxy
@@ -1060,13 +1120,17 @@ class TestLazyStart:
         proxy._available = True
         proxy._original_root_uri = "file:///workspace/monorepo"
         proxy._initial_module_uri = "file:///workspace/monorepo/module-a"
+        # Simulate that module-a was mark_added during start() and module-b via add_module_if_new
+        proxy.modules.mark_added("file:///workspace/monorepo/module-a")
+        proxy.modules.mark_added("file:///workspace/monorepo/module-b")
         proxy.send_notification = AsyncMock()  # type: ignore[assignment]
         await proxy.expand_full_workspace()
         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 len(event["removed"]) == 1
-        assert event["removed"][0]["uri"] == "file:///workspace/monorepo/module-a"
+        removed_uris = {e["uri"] for e in event["removed"]}
+        assert "file:///workspace/monorepo/module-a" in removed_uris
+        assert "file:///workspace/monorepo/module-b" in removed_uris
         assert event["added"][0]["uri"] == "file:///workspace/monorepo"
 
     async def test_expand_full_workspace_noop_when_not_available(self) -> None: