java-functional-lsp 0.9.6__tar.gz → 0.9.7__tar.gz

{java_functional_lsp-0.9.6 → java_functional_lsp-0.9.7}/PKG-INFO

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

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

{java_functional_lsp-0.9.6 → java_functional_lsp-0.9.7}/src/java_functional_lsp/server.py

@@ -660,7 +660,24 @@ async def _lazy_start_jdtls(file_uri: str) -> None:
 # they only activate after jdtls starts.
 
 
-async def _ensure_module_and_forward(method: str, params: Any, file_uri: str) -> Any | None:
+# Methods that operate on a single file and succeed before cross-file indexing
+# is complete. A successful response from these does NOT mean the module is fully
+# indexed, so we must NOT use them to transition the module to READY — doing so
+# would cause cross-file requests (references, callHierarchy) to skip the wait
+# and return empty results from an under-indexed jdtls instance.
+_LIGHTWEIGHT_METHODS: frozenset[str] = frozenset(
+    {
+        "textDocument/documentHighlight",
+        "textDocument/documentSymbol",
+    }
+)
+
+
+async def _ensure_module_and_forward(
+    method: str,
+    params: Any,
+    file_uri: str,
+) -> Any | None:
     """Forward a request to jdtls, ensuring the file's module is loaded.
 
     Uses ``ModuleRegistry`` for adaptive waiting:
@@ -668,8 +685,11 @@ async def _ensure_module_and_forward(method: str, params: Any, file_uri: str) ->
     - **UNKNOWN**: add module, wait until ready (adaptive, not fixed sleep)
     - **ADDED**: module sent but not confirmed — wait until ready
 
-    When a request succeeds, marks the module as READY so subsequent
-    requests skip the wait entirely.
+    When a request that requires full project indexing succeeds, marks the
+    module as READY so subsequent requests skip the wait entirely.
+    Methods in ``_LIGHTWEIGHT_METHODS`` operate on a single file and succeed
+    before cross-file indexing completes — their success is never used to
+    signal readiness.
     """
     proxy = server._proxy
     if not proxy.is_available:
@@ -687,9 +707,10 @@ async def _ensure_module_and_forward(method: str, params: Any, file_uri: str) ->
     serialized = _serialize_params(params)
     result = await proxy.send_request(method, serialized)
 
+    can_mark_ready = method not in _LIGHTWEIGHT_METHODS
     if result is not None:
-        # Success — mark module as ready so future requests are instant.
-        if module_uri:
+        # Success — mark module as ready so future cross-file requests are instant.
+        if can_mark_ready and module_uri:
             proxy.modules.mark_ready(module_uri)
         return result
 
@@ -701,7 +722,7 @@ async def _ensure_module_and_forward(method: str, params: Any, file_uri: str) ->
         await proxy.modules.wait_until_ready(wait_uri, timeout=5.0)
     # Always retry once after waiting — even on timeout the module may be ready.
     result = await proxy.send_request(method, serialized)
-    if result is not None and module_uri:
+    if result is not None and can_mark_ready and module_uri:
         proxy.modules.mark_ready(module_uri)
     return result
 

{java_functional_lsp-0.9.6 → java_functional_lsp-0.9.7}/tests/test_server.py

@@ -581,6 +581,34 @@ class TestServerInternals:
         finally:
             srv._proxy.modules.clear()
 
+    async def test_ensure_module_and_forward_lightweight_methods_skip_transition(self) -> None:
+        """Methods in _LIGHTWEIGHT_METHODS do not transition module to READY."""
+        from unittest.mock import AsyncMock, patch
+
+        from java_functional_lsp.proxy import ModuleState
+        from java_functional_lsp.server import _LIGHTWEIGHT_METHODS, _ensure_module_and_forward
+        from java_functional_lsp.server import server as srv
+
+        mock_add = AsyncMock(return_value="file:///mod")
+        raw_result = [{"range": {"start": {"line": 0, "character": 0}, "end": {"line": 0, "character": 3}}}]
+        mock_send = AsyncMock(return_value=raw_result)
+        try:
+            for lightweight_method in _LIGHTWEIGHT_METHODS:
+                srv._proxy.modules.clear()
+                with (
+                    patch.object(srv._proxy, "add_module_if_new", mock_add),
+                    patch.object(srv._proxy, "send_request", mock_send),
+                    patch.object(srv._proxy, "_available", True),
+                    patch("java_functional_lsp.server._resolve_module_uri", return_value="file:///mod"),
+                ):
+                    await _ensure_module_and_forward(lightweight_method, {}, "file:///mod/F.java")
+                # Module should NOT be READY — lightweight op does not confirm full indexing.
+                assert srv._proxy.modules.get_state("file:///mod") != ModuleState.READY, (
+                    f"{lightweight_method} should not mark module as READY"
+                )
+        finally:
+            srv._proxy.modules.clear()
+
     async def test_on_prepare_call_hierarchy_forwards_to_jdtls(self) -> None:
         """_on_prepare_call_hierarchy forwards request and structures result."""
         from unittest.mock import AsyncMock, patch