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

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

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

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

{java_functional_lsp-0.9.7 → java_functional_lsp-0.9.9}/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,
@@ -696,12 +713,18 @@ async def _ensure_module_and_forward(
         return None
 
     module_uri = _resolve_module_uri(file_uri)
+    short_mod = Path(to_fs_path(module_uri) or module_uri).name if module_uri else "<none>"
 
     # Hot path: module already confirmed working.
     if module_uri and proxy.modules.is_ready(module_uri):
-        return await proxy.send_request(method, _serialize_params(params))
+        logger.info("jdtls: %s [hot] module=%s", method, short_mod)
+        result = await proxy.send_request(method, _serialize_params(params))
+        if result is None:
+            logger.info("jdtls: %s [hot] → null (jdtls has no result for this file_uri)", method)
+        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)
     new_module_uri = await proxy.add_module_if_new(file_uri)
 
     serialized = _serialize_params(params)
@@ -719,11 +742,13 @@ async def _ensure_module_and_forward(
     # If a concurrent request succeeds, Event.set() wakes us early.
     wait_uri = new_module_uri or module_uri
     if wait_uri and not proxy.modules.is_ready(wait_uri):
+        logger.info("jdtls: %s [cold] waiting for module %s to become ready", method, short_mod)
         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 can_mark_ready and module_uri:
         proxy.modules.mark_ready(module_uri)
+    logger.info("jdtls: %s [cold] retry → %s", method, "result" if result is not None else "null")
     return result
 
 
@@ -803,8 +828,11 @@ async def _on_incoming_calls(
     if result is None:
         return None
     try:
-        return [_converter.structure(c, lsp.CallHierarchyIncomingCall) for c in result]
-    except Exception:
+        structured = [_converter.structure(c, lsp.CallHierarchyIncomingCall) for c in result]
+        logger.info("jdtls: incomingCalls → %d callers", len(structured))
+        return structured
+    except Exception as e:
+        logger.warning("jdtls: incomingCalls structuring failed: %s (raw=%r)", e, result)
         return None
 
 

{java_functional_lsp-0.9.7 → java_functional_lsp-0.9.9}/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