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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.7.9
+Version: 0.8.1
 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
@@ -128,6 +128,8 @@ Use the [LSP4IJ](https://github.com/redhat-developer/lsp4ij) plugin (works on Co
 2. **Settings** → **Languages & Frameworks** → **Language Servers** → **`+`**
 3. Set **Command**: `java-functional-lsp`, then in **Mappings** → **File name patterns** add `*.java` with Language Id `java`
 
+The server automatically detects JetBrains IDEs and disables the jdtls proxy (IntelliJ provides native Java support). To force-enable jdtls, set `JAVA_FUNCTIONAL_LSP_JDTLS=on` in the server command environment.
+
 See [editors/intellij/README.md](editors/intellij/README.md) for detailed instructions.
 
 ### Claude Code
@@ -230,6 +232,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 +270,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.1}/README.md

@@ -100,6 +100,8 @@ Use the [LSP4IJ](https://github.com/redhat-developer/lsp4ij) plugin (works on Co
 2. **Settings** → **Languages & Frameworks** → **Language Servers** → **`+`**
 3. Set **Command**: `java-functional-lsp`, then in **Mappings** → **File name patterns** add `*.java` with Language Id `java`
 
+The server automatically detects JetBrains IDEs and disables the jdtls proxy (IntelliJ provides native Java support). To force-enable jdtls, set `JAVA_FUNCTIONAL_LSP_JDTLS=on` in the server command environment.
+
 See [editors/intellij/README.md](editors/intellij/README.md) for detailed instructions.
 
 ### Claude Code
@@ -202,6 +204,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 +242,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.1}/editors/intellij/README.md

@@ -73,7 +73,7 @@ Project-level rules are configured via `.java-functional-lsp.json` in your proje
 
 ## Coexistence with IntelliJ's Java Support
 
-LSP4IJ is designed to **supplement** IntelliJ's native Java support, not replace it. Your custom functional programming diagnostics appear alongside IntelliJ's built-in inspections. No conflicts.
+The server automatically detects JetBrains IDEs and disables the jdtls proxy — IntelliJ provides its own Java language features (completions, hover, go-to-definition, compile errors). Only the 16 custom functional programming rules run, and they appear alongside IntelliJ's built-in inspections.
 
 ## Troubleshooting
 
@@ -85,6 +85,7 @@ LSP4IJ is designed to **supplement** IntelliJ's native Java support, not replace
 - Ensure the file mapping is set to Language: `Java`, Language ID: `java`
 - Check that `.java-functional-lsp.json` doesn't have rules set to `"off"`
 - Try restarting the language server: **Tools** → **Language Servers** → **Restart**
+- If diagnostics worked before but stopped, the jdtls proxy may be interfering. Set `JAVA_FUNCTIONAL_LSP_JDTLS=off` in the server command environment to force-disable jdtls. The server auto-detects JetBrains IDEs and disables jdtls by default (since IntelliJ provides native Java support), but this can be overridden with `JAVA_FUNCTIONAL_LSP_JDTLS=on`.
 
 ### PATH not found
 - IntelliJ may not inherit your shell's PATH. Use the full absolute path to the binary in the server command.

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "java-functional-lsp"
-version = "0.7.9"
+version = "0.8.1"
 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.1}/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.1"

{java_functional_lsp-0.7.9 → java_functional_lsp-0.8.1}/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.1}/src/java_functional_lsp/server.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
+import os
 import re
 import sys
 from pathlib import Path
@@ -46,6 +47,10 @@ _ANALYZERS: list[Analyzer] = [
     FunctionalChecker(),
 ]
 
+# JetBrains IDE detection — all products contain one of these substrings in clientInfo.name.
+# When detected, jdtls is skipped because IntelliJ provides native Java language support.
+_JDTLS_SKIP_CLIENTS = ("IntelliJ", "JetBrains")
+
 #: LSP-aware cattrs converter. Unstructures to the LSP JSON shape
 #: (camelCase field names, discriminated unions, None-field pruning) and
 #: correspondingly structures from the same shape. Using a vanilla
@@ -65,6 +70,10 @@ 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]] = []
+        self._skip_jdtls: bool = False
+        self._skip_jdtls_registration: bool = False
+        self._init_generation: int = 0
 
     def _on_jdtls_diagnostics(self, uri: str, diagnostics: list[Any]) -> None:
         """Called when jdtls publishes diagnostics — merge with custom and re-publish.
@@ -198,38 +207,60 @@ 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")"
-)
+_MAX_PATTERN_LENGTH = 500  # Cap regex length to mitigate ReDoS from pathological patterns
+
+
+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
+        if len(entry) > _MAX_PATTERN_LENGTH:
+            logger.warning("suppressJdtlsPatterns entry too long (%d chars, max %d)", len(entry), _MAX_PATTERN_LENGTH)
+            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 +288,39 @@ 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)
+
+    # Determine jdtls mode: env var takes priority, then auto-detect JetBrains IDEs.
+    client_name = (params.client_info.name if params.client_info else "")[:200]
+    logger.info("LSP client: %s", client_name or "(unknown)")
+
+    # Reset flags so re-initialization (non-standard but defensive) starts clean.
+    # Bump generation so in-flight _register_jdtls_capabilities from a prior
+    # session detects the stale context and aborts.
+    global _jdtls_capabilities_registered
+    server._skip_jdtls = False
+    server._skip_jdtls_registration = False
+    server._init_generation += 1
+    _jdtls_capabilities_registered = False
+
+    jdtls_override = os.environ.get("JAVA_FUNCTIONAL_LSP_JDTLS", "").strip().lower()
+    if jdtls_override == "off":
+        server._skip_jdtls = True
+        logger.info("jdtls proxy disabled via JAVA_FUNCTIONAL_LSP_JDTLS=off")
+    elif jdtls_override == "on":
+        logger.info("jdtls proxy force-enabled via JAVA_FUNCTIONAL_LSP_JDTLS=on")
+    elif jdtls_override == "no-register":
+        server._skip_jdtls_registration = True
+        logger.info("jdtls dynamic registration disabled via JAVA_FUNCTIONAL_LSP_JDTLS=no-register")
+    elif jdtls_override:
+        logger.warning("Unknown JAVA_FUNCTIONAL_LSP_JDTLS value %r; expected off/on/no-register", jdtls_override)
+    elif any(token in client_name for token in _JDTLS_SKIP_CLIENTS):
+        server._skip_jdtls = True
+        logger.info(
+            "JetBrains IDE detected (%s) — skipping jdtls proxy "
+            "(IDE provides native Java support; override with JAVA_FUNCTIONAL_LSP_JDTLS=on)",
+            client_name,
+        )
 
     return lsp.InitializeResult(
         capabilities=lsp.ServerCapabilities(
@@ -284,6 +348,9 @@ async def on_initialized(params: lsp.InitializedParams) -> None:
         "java-functional-lsp initialized (rules: %s)",
         list(server._config.get("rules", {}).keys()) or "all defaults",
     )
+    if server._skip_jdtls:
+        logger.info("jdtls proxy disabled — custom rules only")
+        return
     if server._proxy.check_available():
         logger.info("jdtls found on PATH — will start lazily on first file open")
     else:
@@ -331,11 +398,15 @@ async def _register_jdtls_capabilities() -> None:
     ready, which suppresses the IDE's built-in diagnostic tooltips.
 
     Idempotent: safe to call multiple times (e.g., proxy restart).
+    Uses a generation counter to detect stale registrations from a prior
+    initialize cycle (defensive against non-standard re-initialization).
     """
     global _jdtls_capabilities_registered
     if _jdtls_capabilities_registered:
         return
 
+    generation = server._init_generation
+
     try:
         # Register handlers so pygls dispatches incoming requests to them.
         for method, handler in _JDTLS_HANDLERS.items():
@@ -344,6 +415,12 @@ async def _register_jdtls_capabilities() -> None:
         # Tell the client we now support these capabilities.
         registrations = _build_jdtls_registrations()
         await server.client_register_capability_async(lsp.RegistrationParams(registrations=registrations))
+
+        # Bail if a re-initialize happened while we were awaiting.
+        if generation != server._init_generation:
+            logger.info("Discarding stale jdtls capability registration (re-initialize detected)")
+            return
+
         _jdtls_capabilities_registered = True
         logger.info("Dynamically registered jdtls capabilities (hover, definition, references, completion, symbol)")
     except Exception:
@@ -363,11 +440,16 @@ 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:
     """Forward a notification to jdtls if available, or queue it if starting."""
+    if server._skip_jdtls:
+        return
     if server._proxy.is_available:
         task = asyncio.create_task(server._proxy.send_notification(method, serialized))
         _bg_tasks.add(task)
@@ -385,14 +467,18 @@ async def on_did_open(params: lsp.DidOpenTextDocumentParams) -> None:
     didOpen response isn't delayed by jdtls cold-start.
     """
     uri = params.text_document.uri
-    serialized = _serialize_params(params)
 
-    if server._proxy.is_available:
+    if server._skip_jdtls:
+        # Skip all jdtls forwarding — custom diagnostics only.
+        pass
+    elif server._proxy.is_available:
         # Fast path: jdtls running. Forward didOpen + add module if new.
+        serialized = _serialize_params(params)
         await server._proxy.send_notification("textDocument/didOpen", serialized)
         await server._proxy.add_module_if_new(uri)
     elif server._proxy._jdtls_on_path and not server._proxy._start_failed:
         # Queue the didOpen (whether this is the first file or a subsequent one during startup).
+        serialized = _serialize_params(params)
         server._proxy.queue_notification("textDocument/didOpen", serialized)
         if not server._proxy._lazy_start_fired:
             # First file: kick off lazy start in background.
@@ -402,7 +488,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 +509,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)
@@ -447,7 +539,10 @@ async def _lazy_start_jdtls(file_uri: str) -> None:
         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")
-            await _register_jdtls_capabilities()
+            if server._skip_jdtls_registration:
+                logger.info("Skipping dynamic capability registration (no-register mode)")
+            else:
+                await _register_jdtls_capabilities()
             await server._proxy.flush_queued_notifications()
     except Exception:
         logger.warning("jdtls lazy start failed", exc_info=True)

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

@@ -647,55 +647,201 @@ 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
+
+        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 TestJdtlsSkipDetection:
+    """Tests for auto-detecting JetBrains IDEs and skipping jdtls."""
+
+    def _make_init_params(self, client_name: str | None = None) -> Any:
+        """Create minimal InitializeParams with optional client_info."""
+        return lsp.InitializeParams(
+            capabilities=lsp.ClientCapabilities(),
+            root_uri="file:///tmp/test",
+            client_info=lsp.ClientInfo(name=client_name) if client_name else None,
+        )
+
+    def _run_init(self, monkeypatch: Any, client_name: str | None, env_value: str | None = None) -> None:
+        """Run on_initialize with controlled env and client_info."""
+        from java_functional_lsp.server import on_initialize, server
+
+        server._skip_jdtls = False
+        server._skip_jdtls_registration = False
+        if env_value is not None:
+            monkeypatch.setenv("JAVA_FUNCTIONAL_LSP_JDTLS", env_value)
+        else:
+            monkeypatch.delenv("JAVA_FUNCTIONAL_LSP_JDTLS", raising=False)
+        on_initialize(self._make_init_params(client_name))
+
+    def test_intellij_client_info_skips_jdtls(self, monkeypatch: Any) -> None:
+        """IntelliJ IDEA detected → _skip_jdtls = True."""
+        from java_functional_lsp.server import server
+
+        self._run_init(monkeypatch, "IntelliJ IDEA")
+        assert server._skip_jdtls is True
+
+    def test_jetbrains_product_skips_jdtls(self, monkeypatch: Any) -> None:
+        """Any JetBrains product detected → _skip_jdtls = True."""
+        from java_functional_lsp.server import server
+
+        self._run_init(monkeypatch, "JetBrains Rider 2025.2")
+        assert server._skip_jdtls is True
+
+    def test_vscode_allows_jdtls(self, monkeypatch: Any) -> None:
+        """VS Code → _skip_jdtls = False (jdtls needed)."""
+        from java_functional_lsp.server import server
+
+        self._run_init(monkeypatch, "Visual Studio Code")
+        assert server._skip_jdtls is False
 
-        diag = {"code": "33554513", "message": "The blank final field name may not have been initialized"}
-        assert _is_lombok_false_positive(diag) is True
+    def test_no_client_info_allows_jdtls(self, monkeypatch: Any) -> None:
+        """No client_info → _skip_jdtls = False (safe default)."""
+        from java_functional_lsp.server import server
+
+        self._run_init(monkeypatch, None)
+        assert server._skip_jdtls is False
+
+    def test_env_var_off_overrides_detection(self, monkeypatch: Any) -> None:
+        """JAVA_FUNCTIONAL_LSP_JDTLS=off disables jdtls even for non-JetBrains client."""
+        from java_functional_lsp.server import server
+
+        self._run_init(monkeypatch, "Visual Studio Code", env_value="off")
+        assert server._skip_jdtls is True
+
+    def test_env_var_on_overrides_intellij_detection(self, monkeypatch: Any) -> None:
+        """JAVA_FUNCTIONAL_LSP_JDTLS=on force-enables jdtls even for IntelliJ."""
+        from java_functional_lsp.server import server
+
+        self._run_init(monkeypatch, "IntelliJ IDEA", env_value="on")
+        assert server._skip_jdtls is False
+
+    def test_env_var_no_register(self, monkeypatch: Any) -> None:
+        """JAVA_FUNCTIONAL_LSP_JDTLS=no-register keeps jdtls but skips registration."""
+        from java_functional_lsp.server import server
+
+        self._run_init(monkeypatch, "Visual Studio Code", env_value="no-register")
+        assert server._skip_jdtls is False
+        assert server._skip_jdtls_registration is True
+
+    def test_custom_diagnostics_publish_when_jdtls_skipped(self) -> None:
+        """Tree-sitter analysis works normally when jdtls is skipped."""
+        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._skip_jdtls = True
+            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 when jdtls is skipped"
+        assert any(d.code == "null-return" for d in custom_diags), "null-return diagnostic expected"
 
 
 class TestFindLombokJar:
@@ -761,6 +907,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.1}/uv.lock

@@ -184,7 +184,7 @@ wheels = [
 
 [[package]]
 name = "java-functional-lsp"
-version = "0.7.9"
+version = "0.8.1"
 source = { editable = "." }
 dependencies = [
     { name = "pygls" },
@@ -426,7 +426,7 @@ wheels = [
 
 [[package]]
 name = "pytest"
-version = "9.0.2"
+version = "9.0.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
@@ -437,9 +437,9 @@ dependencies = [
     { name = "pygments" },
     { name = "tomli", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
 ]
 
 [[package]]