java-functional-lsp 0.7.9__tar.gz → 0.8.0__tar.gz

{java_functional_lsp-0.7.9 → java_functional_lsp-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.7.9
+Version: 0.8.0
 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
@@ -230,6 +230,7 @@ Create `.java-functional-lsp.json` in your project root to customize rules:
 **Options:**
 - `excludes` — glob patterns for files/directories to skip entirely (supports `**` for multi-segment wildcards)
 - `rules` — per-rule severity: `error`, `warning` (default), `info`, `hint`, `off`
+- `suppressJdtlsPatterns` — list of regex patterns to suppress jdtls diagnostics (see below)
 
 **Spring-aware behavior:**
 - `throw-statement`, `catch-rethrow`, and `try-catch-to-monadic` are automatically suppressed inside `@Bean` methods
@@ -267,7 +268,22 @@ The server auto-discovers `lombok.jar` from these locations (first match wins):
 3. **Maven cache** — auto-discovered from `~/.m2/repository/org/projectlombok/lombok/`
 4. **Dedicated directory** — `~/.jdtls-libs/lombok.jar`
 
-If Lombok is used in your project but the jar isn't found, the server automatically filters common Lombok false-positive errors (like "builder() is undefined") so they don't clutter your diagnostics.
+If Lombok is used in your project but the jar isn't found, the server logs a warning. The jdtls cache is automatically cleared on version upgrade, so adding Lombok support takes effect immediately after `brew upgrade`.
+
+### Suppressing jdtls diagnostics
+
+For project-specific jdtls false positives (e.g., annotation processor methods, MapStruct mappers), use `suppressJdtlsPatterns` to add custom regex filters:
+
+```json
+{
+  "suppressJdtlsPatterns": [
+    "The method \\w+Mapper\\(\\) is undefined",
+    "cannot be resolved to a type"
+  ]
+}
+```
+
+Each entry is a regex matched against jdtls diagnostic messages. Invalid patterns are skipped with a warning.
 
 ## Code actions (quick fixes)
 

{java_functional_lsp-0.7.9 → java_functional_lsp-0.8.0}/README.md

@@ -202,6 +202,7 @@ Create `.java-functional-lsp.json` in your project root to customize rules:
 **Options:**
 - `excludes` — glob patterns for files/directories to skip entirely (supports `**` for multi-segment wildcards)
 - `rules` — per-rule severity: `error`, `warning` (default), `info`, `hint`, `off`
+- `suppressJdtlsPatterns` — list of regex patterns to suppress jdtls diagnostics (see below)
 
 **Spring-aware behavior:**
 - `throw-statement`, `catch-rethrow`, and `try-catch-to-monadic` are automatically suppressed inside `@Bean` methods
@@ -239,7 +240,22 @@ The server auto-discovers `lombok.jar` from these locations (first match wins):
 3. **Maven cache** — auto-discovered from `~/.m2/repository/org/projectlombok/lombok/`
 4. **Dedicated directory** — `~/.jdtls-libs/lombok.jar`
 
-If Lombok is used in your project but the jar isn't found, the server automatically filters common Lombok false-positive errors (like "builder() is undefined") so they don't clutter your diagnostics.
+If Lombok is used in your project but the jar isn't found, the server logs a warning. The jdtls cache is automatically cleared on version upgrade, so adding Lombok support takes effect immediately after `brew upgrade`.
+
+### Suppressing jdtls diagnostics
+
+For project-specific jdtls false positives (e.g., annotation processor methods, MapStruct mappers), use `suppressJdtlsPatterns` to add custom regex filters:
+
+```json
+{
+  "suppressJdtlsPatterns": [
+    "The method \\w+Mapper\\(\\) is undefined",
+    "cannot be resolved to a type"
+  ]
+}
+```
+
+Each entry is a regex matched against jdtls diagnostic messages. Invalid patterns are skipped with a warning.
 
 ## Code actions (quick fixes)
 

{java_functional_lsp-0.7.9 → java_functional_lsp-0.8.0}/pyproject.toml

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

{java_functional_lsp-0.7.9 → java_functional_lsp-0.8.0}/src/java_functional_lsp/__init__.py

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

{java_functional_lsp-0.7.9 → java_functional_lsp-0.8.0}/src/java_functional_lsp/proxy.py

@@ -444,6 +444,29 @@ def _version_key(name: str) -> tuple[int, ...]:
     return tuple(parts)
 
 
+def _clear_cache_on_version_change(cache_root: Path) -> None:
+    """Clear jdtls data cache when the server version changes.
+
+    Stores a ``.version`` marker in the cache root. On version mismatch
+    (e.g., Lombok agent added, jdtls config changed), wipes the entire
+    cache so jdtls re-indexes from scratch with the current configuration.
+    """
+    from . import __version__
+
+    marker = cache_root / ".version"
+    try:
+        if marker.exists() and marker.read_text().strip() == __version__:
+            return
+        # Version changed or first run — clear stale caches.
+        if cache_root.exists():
+            shutil.rmtree(cache_root)
+            logger.info("jdtls: cleared stale cache (version changed to %s)", __version__)
+        cache_root.mkdir(parents=True, exist_ok=True)
+        marker.write_text(__version__)
+    except OSError as e:
+        logger.warning("jdtls: failed to manage cache version marker: %s", e)
+
+
 def _find_lombok_jar(config: Mapping[str, Any] | None = None) -> str | None:
     """Find lombok.jar from configurable and auto-discovered locations.
 
@@ -550,20 +573,35 @@ class JdtlsProxy:
         if not jdtls_path:
             return False
 
-        # Data-dir hash: use module URI when scoped so each module gets its own
-        # clean jdtls state. This avoids loading a 2.5GB monorepo index when only
-        # one module is needed. Without expansion, each session is module-scoped,
-        # so the data-dir should match that scope.
         original_root: str = init_params.get("rootUri") or init_params.get("rootPath") or str(Path.cwd())
         self._original_root_uri = original_root
+        effective_root_uri = module_root_uri or original_root
+
+        # Mark ADDED before any await to prevent duplicate module additions
+        # from concurrent coroutines during the executor yield below.
+        self._initial_module_uri = module_root_uri
+        self.modules.mark_added(effective_root_uri)
+
+        # All blocking startup I/O in a single executor call: cache version check
+        # (may rmtree on upgrade), Lombok discovery, and jdtls env build.
+        cache_root = Path.home() / ".cache" / "jdtls-data"
+
+        def _blocking_startup() -> tuple[dict[str, str], str | None]:
+            _clear_cache_on_version_change(cache_root)
+            return build_jdtls_env(), _find_lombok_jar(config)
+
+        loop = asyncio.get_running_loop()
+        jdtls_env, lombok_jar = await loop.run_in_executor(None, _blocking_startup)
+        if lombok_jar:
+            logger.info("jdtls: using Lombok agent from %s", _redact_path(lombok_jar))
+
         hash_source = module_root_uri or original_root
         data_hash = hashlib.sha256(hash_source.encode()).hexdigest()[:12]
-        data_dir = Path.home() / ".cache" / "jdtls-data" / data_hash
+        data_dir = cache_root / data_hash
         data_dir.mkdir(parents=True, exist_ok=True)
 
         # Deep copy to avoid mutating server._init_params.
         effective_params = copy.deepcopy(init_params)
-        effective_root_uri = module_root_uri or original_root
         if module_root_uri:
             effective_params["rootUri"] = module_root_uri
             from pygls.uris import to_fs_path
@@ -580,16 +618,6 @@ class JdtlsProxy:
         ws = caps.setdefault("workspace", {})
         ws["workspaceFolders"] = True
 
-        # Track the initial module as already loaded (mark ADDED before await).
-        self._initial_module_uri = module_root_uri
-        self.modules.mark_added(effective_root_uri)
-
-        # Build a clean environment and find Lombok jar (both do blocking I/O).
-        loop = asyncio.get_running_loop()
-        jdtls_env, lombok_jar = await loop.run_in_executor(None, lambda: (build_jdtls_env(), _find_lombok_jar(config)))
-        if lombok_jar:
-            logger.info("jdtls: using Lombok agent from %s", _redact_path(lombok_jar))
-
         jdtls_cmd: list[str] = [
             jdtls_path,
             "-data",

{java_functional_lsp-0.7.9 → java_functional_lsp-0.8.0}/src/java_functional_lsp/server.py

@@ -65,6 +65,7 @@ class JavaFunctionalLspServer(LanguageServer):
         self._config: dict[str, Any] = {}
         self._init_params: dict[str, Any] = {}
         self._proxy = JdtlsProxy(on_diagnostics=self._on_jdtls_diagnostics)
+        self._user_suppress_patterns: list[re.Pattern[str]] = []
 
     def _on_jdtls_diagnostics(self, uri: str, diagnostics: list[Any]) -> None:
         """Called when jdtls publishes diagnostics — merge with custom and re-publish.
@@ -198,38 +199,54 @@ def _jdtls_raw_to_lsp_diagnostics(raw_diagnostics: list[Any]) -> list[lsp.Diagno
     return result
 
 
-# Lombok-specific patterns: only match diagnostics that are clearly Lombok-generated.
-# Intentionally narrow to avoid suppressing real compile errors.
-_LOMBOK_PATTERNS = re.compile(
-    r"(?:"
-    r"The method builder\(\)|"  # @Builder
-    r"The method toBuilder\(\)|"  # @Builder(toBuilder=true)
-    r"log cannot be resolved|"  # @Slf4j, @Log
-    r"\w+Builder cannot be resolved to a type|"  # @Builder inner class
-    r"The blank final field \w+ may not have been initialized"  # @Value final fields
-    r")"
-)
+def _compile_user_patterns(config: dict[str, Any]) -> list[re.Pattern[str]]:
+    """Compile user-defined suppressJdtlsPatterns from config."""
+    raw = config.get("suppressJdtlsPatterns", [])
+    if not isinstance(raw, list):
+        logger.warning("suppressJdtlsPatterns must be a list of regex strings, got %s", type(raw).__name__)
+        return []
+    patterns: list[re.Pattern[str]] = []
+    for entry in raw:
+        if not isinstance(entry, str):
+            continue
+        try:
+            patterns.append(re.compile(entry))
+        except re.error as e:
+            logger.warning("Invalid suppressJdtlsPatterns regex %r: %s", entry, e)
+    return patterns
 
 
-def _is_lombok_false_positive(diag: dict[str, Any]) -> bool:
-    """Check if a jdtls diagnostic is likely a Lombok false positive.
+def _is_jdtls_suppressed(diag: dict[str, Any], user_patterns: list[re.Pattern[str]]) -> bool:
+    """Check if a jdtls diagnostic matches a user-configured suppress pattern.
 
-    Only matches narrow Lombok-specific patterns to avoid suppressing real errors.
+    No built-in patterns — the root cause (stale jdtls caches) is fixed by
+    clearing the cache on version change. Users can still suppress specific
+    jdtls messages via suppressJdtlsPatterns in .java-functional-lsp.json.
     """
+    if not user_patterns:
+        return False
     msg = diag.get("message", "")
-    return bool(_LOMBOK_PATTERNS.search(msg))
+    for pat in user_patterns:
+        if pat.search(msg):
+            return True
+    return False
 
 
 def _run_analysis(source: str, uri: str) -> list[lsp.Diagnostic]:
-    """Run custom analyzers on source text and merge with jdtls diagnostics."""
+    """Run custom analyzers on source text and merge with jdtls diagnostics.
+
+    jdtls processing is isolated: if it fails, custom diagnostics still publish.
+    """
     custom_diags = _analyze_document(source, uri)
 
     jdtls_diags: list[lsp.Diagnostic] = []
     if server._proxy.is_available:
-        raw = server._proxy.get_cached_diagnostics(uri)
-        if not server._proxy.has_lombok:
-            raw = [d for d in raw if not _is_lombok_false_positive(d)]
-        jdtls_diags = _jdtls_raw_to_lsp_diagnostics(raw)
+        try:
+            raw = server._proxy.get_cached_diagnostics(uri)
+            raw = [d for d in raw if not _is_jdtls_suppressed(d, server._user_suppress_patterns)]
+            jdtls_diags = _jdtls_raw_to_lsp_diagnostics(raw)
+        except Exception as e:
+            logger.warning("jdtls diagnostic processing failed for %s: %s", uri, e)
 
     return jdtls_diags + custom_diags
 
@@ -257,6 +274,7 @@ def on_initialize(params: lsp.InitializeParams) -> lsp.InitializeResult:
         root = params.root_path
 
     server._config = _load_config(root)
+    server._user_suppress_patterns = _compile_user_patterns(server._config)
 
     return lsp.InitializeResult(
         capabilities=lsp.ServerCapabilities(
@@ -363,7 +381,10 @@ def _analyze_and_publish(uri: str) -> None:
 async def _deferred_validate(uri: str) -> None:
     """Debounced validation — waits before analyzing to batch rapid edits."""
     await asyncio.sleep(_DEBOUNCE_SECONDS)
-    _analyze_and_publish(uri)
+    try:
+        _analyze_and_publish(uri)
+    except Exception as e:
+        logger.error("Validation failed for %s: %s", uri, e)
 
 
 def _forward_or_queue(method: str, serialized: Any) -> None:
@@ -402,7 +423,10 @@ async def on_did_open(params: lsp.DidOpenTextDocumentParams) -> None:
             task.add_done_callback(_bg_tasks.discard)
 
     # Custom diagnostics always publish immediately — never blocked by jdtls.
-    _analyze_and_publish(uri)
+    try:
+        _analyze_and_publish(uri)
+    except Exception as e:
+        logger.error("Analysis failed on open for %s: %s", uri, e)
 
 
 @server.feature(lsp.TEXT_DOCUMENT_DID_CHANGE)
@@ -420,7 +444,10 @@ async def on_did_change(params: lsp.DidChangeTextDocumentParams) -> None:
 async def on_did_save(params: lsp.DidSaveTextDocumentParams) -> None:
     """Forward to jdtls and re-analyze immediately (no debounce on save)."""
     _forward_or_queue("textDocument/didSave", _serialize_params(params))
-    _analyze_and_publish(params.text_document.uri)
+    try:
+        _analyze_and_publish(params.text_document.uri)
+    except Exception as e:
+        logger.error("Analysis failed on save for %s: %s", params.text_document.uri, e)
 
 
 @server.feature(lsp.TEXT_DOCUMENT_DID_CLOSE)

{java_functional_lsp-0.7.9 → java_functional_lsp-0.8.0}/tests/test_server.py

@@ -647,55 +647,107 @@ class TestServerInternals:
 # --------------------------------------------------------------------------
 
 
-class TestLombokFalsePositive:
-    """Tests for _is_lombok_false_positive()."""
+class TestUserSuppressPatterns:
+    """Tests for configurable suppressJdtlsPatterns."""
 
-    def test_matches_builder_undefined(self) -> None:
-        from java_functional_lsp.server import _is_lombok_false_positive
+    def test_user_pattern_matches(self) -> None:
+        from java_functional_lsp.server import _compile_user_patterns, _is_jdtls_suppressed
 
-        diag = {"code": "67108964", "message": "The method builder() is undefined for the type Foo"}
-        assert _is_lombok_false_positive(diag) is True
+        patterns = _compile_user_patterns({"suppressJdtlsPatterns": [r"The method generateReport\(\) is undefined"]})
+        diag = {"message": "The method generateReport() is undefined for the type InternalService"}
+        assert _is_jdtls_suppressed(diag, patterns) is True
 
-    def test_matches_log_unresolved(self) -> None:
-        from java_functional_lsp.server import _is_lombok_false_positive
+    def test_user_pattern_does_not_match_unrelated(self) -> None:
+        from java_functional_lsp.server import _compile_user_patterns, _is_jdtls_suppressed
 
-        diag = {"code": "570425394", "message": "log cannot be resolved"}
-        assert _is_lombok_false_positive(diag) is True
+        patterns = _compile_user_patterns({"suppressJdtlsPatterns": [r"The method generateReport\(\) is undefined"]})
+        diag = {"message": "The method foo() is undefined for the type String"}
+        assert _is_jdtls_suppressed(diag, patterns) is False
 
-    def test_matches_builder_type_unresolved(self) -> None:
-        from java_functional_lsp.server import _is_lombok_false_positive
+    def test_no_patterns_passes_everything(self) -> None:
+        """With no user patterns, nothing is suppressed."""
+        from java_functional_lsp.server import _is_jdtls_suppressed
 
-        diag = {"code": "16777218", "message": "FooBuilder cannot be resolved to a type"}
-        assert _is_lombok_false_positive(diag) is True
+        diag = {"message": "The method builder() is undefined for the type Foo"}
+        assert _is_jdtls_suppressed(diag, []) is False
 
-    def test_does_not_match_real_undefined_method(self) -> None:
-        from java_functional_lsp.server import _is_lombok_false_positive
+    def test_invalid_regex_skipped(self) -> None:
+        from java_functional_lsp.server import _compile_user_patterns
 
-        diag = {"code": "67108964", "message": "The method foo() is undefined for the type String"}
-        assert _is_lombok_false_positive(diag) is False
+        patterns = _compile_user_patterns({"suppressJdtlsPatterns": [r"valid", r"[invalid"]})
+        assert len(patterns) == 1
+        assert patterns[0].search("valid") is not None
 
-    def test_does_not_match_real_unresolved_type(self) -> None:
-        from java_functional_lsp.server import _is_lombok_false_positive
+    def test_non_list_ignored(self) -> None:
+        from java_functional_lsp.server import _compile_user_patterns
 
-        diag = {"code": "16777218", "message": "SomeClass cannot be resolved to a type"}
-        assert _is_lombok_false_positive(diag) is False
+        patterns = _compile_user_patterns({"suppressJdtlsPatterns": "not a list"})
+        assert patterns == []
 
-    def test_empty_message(self) -> None:
-        from java_functional_lsp.server import _is_lombok_false_positive
+    def test_empty_config(self) -> None:
+        from java_functional_lsp.server import _compile_user_patterns
 
-        diag = {"code": "67108964", "message": ""}
-        assert _is_lombok_false_positive(diag) is False
+        patterns = _compile_user_patterns({})
+        assert patterns == []
 
-    def test_missing_fields(self) -> None:
-        from java_functional_lsp.server import _is_lombok_false_positive
 
-        assert _is_lombok_false_positive({}) is False
+class TestJdtlsIsolation:
+    """Tests that jdtls failures don't suppress custom diagnostics."""
 
-    def test_matches_blank_final_field(self) -> None:
-        from java_functional_lsp.server import _is_lombok_false_positive
+    def test_jdtls_exception_does_not_suppress_custom_diags(self) -> None:
+        """If jdtls diagnostic processing throws, custom diagnostics still publish."""
+        from unittest.mock import patch
+
+        from java_functional_lsp.server import _run_analysis
+
+        java_source = "public class Foo { public String bar() { return null; } }"
+
+        with patch("java_functional_lsp.server.server") as mock_server:
+            mock_server._proxy.is_available = True
+            mock_server._proxy.get_cached_diagnostics.side_effect = RuntimeError("jdtls corrupt")
+            mock_server._user_suppress_patterns = []
+            mock_server._config = {}
+            mock_server._parser = __import__("java_functional_lsp.analyzers.base", fromlist=["get_parser"]).get_parser()
+
+            result = _run_analysis(java_source, "file:///test/Foo.java")
+
+        custom_diags = [d for d in result if d.source == "java-functional-lsp"]
+        assert len(custom_diags) > 0, "Custom diagnostics should publish even when jdtls fails"
+
+    def test_jdtls_unavailable_still_publishes_custom_diags(self) -> None:
+        """When jdtls is not available, custom diagnostics still publish."""
+        from unittest.mock import patch
+
+        from java_functional_lsp.server import _run_analysis
+
+        java_source = "public class Foo { public String bar() { return null; } }"
+
+        with patch("java_functional_lsp.server.server") as mock_server:
+            mock_server._proxy.is_available = False
+            mock_server._config = {}
+            mock_server._parser = __import__("java_functional_lsp.analyzers.base", fromlist=["get_parser"]).get_parser()
+
+            result = _run_analysis(java_source, "file:///test/Foo.java")
+
+        custom_diags = [d for d in result if d.source == "java-functional-lsp"]
+        assert len(custom_diags) > 0, "Custom diagnostics should publish without jdtls"
+
+    def test_analyze_and_publish_exception_does_not_crash_handler(self) -> None:
+        """Handler-level try/except prevents server crash when _analyze_and_publish raises."""
+        from unittest.mock import patch
+
+        from java_functional_lsp.server import _deferred_validate
 
-        diag = {"code": "33554513", "message": "The blank final field name may not have been initialized"}
-        assert _is_lombok_false_positive(diag) is True
+        with patch("java_functional_lsp.server._analyze_and_publish", side_effect=RuntimeError("boom")):
+            import asyncio
+
+            loop = asyncio.new_event_loop()
+            try:
+                # _deferred_validate should catch the exception and log, not raise
+                loop.run_until_complete(_deferred_validate("file:///test/Foo.java"))
+            finally:
+                loop.close()
+        # If we get here without exception, the handler caught it correctly
 
 
 class TestFindLombokJar:
@@ -761,6 +813,51 @@ class TestFindLombokJar:
         assert any("does not exist" in r.getMessage() for r in caplog.records)
 
 
+class TestCacheClear:
+    """Tests for _clear_cache_on_version_change()."""
+
+    def test_clears_on_version_mismatch(self, tmp_path: Any) -> None:
+        from java_functional_lsp.proxy import _clear_cache_on_version_change
+
+        cache = tmp_path / "jdtls-data"
+        cache.mkdir()
+        stale_dir = cache / "abc123"
+        stale_dir.mkdir()
+        (cache / ".version").write_text("0.7.9")
+
+        _clear_cache_on_version_change(cache)
+
+        assert not stale_dir.exists(), "Stale data-dir should be cleared"
+        assert cache.exists(), "Cache root should be recreated"
+        from java_functional_lsp import __version__
+
+        assert (cache / ".version").read_text() == __version__
+
+    def test_keeps_cache_on_same_version(self, tmp_path: Any) -> None:
+        from java_functional_lsp import __version__
+        from java_functional_lsp.proxy import _clear_cache_on_version_change
+
+        cache = tmp_path / "jdtls-data"
+        cache.mkdir()
+        existing_dir = cache / "abc123"
+        existing_dir.mkdir()
+        (cache / ".version").write_text(__version__)
+
+        _clear_cache_on_version_change(cache)
+
+        assert existing_dir.exists(), "Existing data-dir should be preserved"
+
+    def test_creates_marker_on_first_run(self, tmp_path: Any) -> None:
+        from java_functional_lsp.proxy import _clear_cache_on_version_change
+
+        cache = tmp_path / "jdtls-data"
+        _clear_cache_on_version_change(cache)
+
+        from java_functional_lsp import __version__
+
+        assert (cache / ".version").read_text() == __version__
+
+
 # Subprocess-based tests — zero mocks, real LSP transport
 # --------------------------------------------------------------------------
 

{java_functional_lsp-0.7.9 → java_functional_lsp-0.8.0}/uv.lock

@@ -184,7 +184,7 @@ wheels = [
 
 [[package]]
 name = "java-functional-lsp"
-version = "0.7.9"
+version = "0.8.0"
 source = { editable = "." }
 dependencies = [
     { name = "pygls" },