java-functional-lsp 0.3.1__tar.gz → 0.4.0__tar.gz

{java_functional_lsp-0.3.1 → java_functional_lsp-0.4.0}/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "java-functional-lsp",
   "description": "Java LSP with functional programming rules enforcement — null safety, immutability, no exceptions, Spring best practices. Wraps jdtls for full Java language support.",
-  "version": "0.3.1"
+  "version": "0.4.0"
 }

{java_functional_lsp-0.3.1 → java_functional_lsp-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.3.1
+Version: 0.4.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
@@ -63,13 +63,28 @@ pip install java-functional-lsp
 
 # From source
 pip install git+https://github.com/aviadshiber/java-functional-lsp.git
+
+# Optional: install jdtls for full Java language support (completions, hover, go-to-def)
+brew install jdtls
 ```
 
+**Requirements:**
+- Python 3.10+ (for the LSP server)
+- JDK 21+ (only if using jdtls — jdtls 1.57+ requires JDK 21 as its runtime, but can analyze Java 8+ source code)
+
 ## IDE Setup
 
 ### VS Code
 
-Install the extension from a `.vsix` file ([download from releases](https://github.com/aviadshiber/java-functional-lsp/releases)) or build it:
+Install the extension from a `.vsix` file ([download from releases](https://github.com/aviadshiber/java-functional-lsp/releases)):
+
+```bash
+# Download and install
+gh release download --repo aviadshiber/java-functional-lsp --pattern "*.vsix" --dir /tmp
+code --install-extension /tmp/java-functional-lsp-*.vsix
+```
+
+Or build from source:
 
 ```bash
 cd editors/vscode
@@ -78,7 +93,9 @@ npx vsce package
 code --install-extension java-functional-lsp-*.vsix
 ```
 
-The extension launches the LSP server automatically for `.java` files. Configure the binary path in settings if needed (`javaFunctionalLsp.serverPath`). See [editors/vscode/README.md](editors/vscode/README.md) for details.
+The extension is a thin launcher — it just starts the `java-functional-lsp` binary for `.java` files. **Updating rules only requires upgrading the LSP binary** (`brew upgrade java-functional-lsp` or `pip install --upgrade java-functional-lsp`). The VSIX itself rarely needs updating.
+
+Configure the binary path in settings if needed (`javaFunctionalLsp.serverPath`). See [editors/vscode/README.md](editors/vscode/README.md) for details.
 
 ### IntelliJ IDEA
 
@@ -129,6 +146,7 @@ Create `.java-functional-lsp.json` in your project root to customize rules:
 
 ```json
 {
+  "excludes": ["**/generated/**", "**/vendor/**"],
   "rules": {
     "null-literal-arg": "warning",
     "throw-statement": "info",
@@ -138,8 +156,13 @@ Create `.java-functional-lsp.json` in your project root to customize rules:
 }
 ```
 
-Severity levels: `error`, `warning`, `info`, `hint`, `off`.
-All rules default to `warning` when not configured.
+**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`
+
+**Spring-aware behavior:**
+- `throw-statement` and `catch-rethrow` are automatically suppressed inside `@Bean` methods
+- `mutable-dto` suggests `@ConstructorBinding` instead of `@Value` when the class has `@ConfigurationProperties`
 
 ## How it works
 

{java_functional_lsp-0.3.1 → java_functional_lsp-0.4.0}/README.md

@@ -35,13 +35,28 @@ pip install java-functional-lsp
 
 # From source
 pip install git+https://github.com/aviadshiber/java-functional-lsp.git
+
+# Optional: install jdtls for full Java language support (completions, hover, go-to-def)
+brew install jdtls
 ```
 
+**Requirements:**
+- Python 3.10+ (for the LSP server)
+- JDK 21+ (only if using jdtls — jdtls 1.57+ requires JDK 21 as its runtime, but can analyze Java 8+ source code)
+
 ## IDE Setup
 
 ### VS Code
 
-Install the extension from a `.vsix` file ([download from releases](https://github.com/aviadshiber/java-functional-lsp/releases)) or build it:
+Install the extension from a `.vsix` file ([download from releases](https://github.com/aviadshiber/java-functional-lsp/releases)):
+
+```bash
+# Download and install
+gh release download --repo aviadshiber/java-functional-lsp --pattern "*.vsix" --dir /tmp
+code --install-extension /tmp/java-functional-lsp-*.vsix
+```
+
+Or build from source:
 
 ```bash
 cd editors/vscode
@@ -50,7 +65,9 @@ npx vsce package
 code --install-extension java-functional-lsp-*.vsix
 ```
 
-The extension launches the LSP server automatically for `.java` files. Configure the binary path in settings if needed (`javaFunctionalLsp.serverPath`). See [editors/vscode/README.md](editors/vscode/README.md) for details.
+The extension is a thin launcher — it just starts the `java-functional-lsp` binary for `.java` files. **Updating rules only requires upgrading the LSP binary** (`brew upgrade java-functional-lsp` or `pip install --upgrade java-functional-lsp`). The VSIX itself rarely needs updating.
+
+Configure the binary path in settings if needed (`javaFunctionalLsp.serverPath`). See [editors/vscode/README.md](editors/vscode/README.md) for details.
 
 ### IntelliJ IDEA
 
@@ -101,6 +118,7 @@ Create `.java-functional-lsp.json` in your project root to customize rules:
 
 ```json
 {
+  "excludes": ["**/generated/**", "**/vendor/**"],
   "rules": {
     "null-literal-arg": "warning",
     "throw-statement": "info",
@@ -110,8 +128,13 @@ Create `.java-functional-lsp.json` in your project root to customize rules:
 }
 ```
 
-Severity levels: `error`, `warning`, `info`, `hint`, `off`.
-All rules default to `warning` when not configured.
+**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`
+
+**Spring-aware behavior:**
+- `throw-statement` and `catch-rethrow` are automatically suppressed inside `@Bean` methods
+- `mutable-dto` suggests `@ConstructorBinding` instead of `@Value` when the class has `@ConfigurationProperties`
 
 ## How it works
 

{java_functional_lsp-0.3.1 → java_functional_lsp-0.4.0}/SKILL.md

@@ -45,6 +45,7 @@ Create `.java-functional-lsp.json` in your project root:
 
 ```json
 {
+  "excludes": ["**/generated/**", "**/vendor/**"],
   "rules": {
     "imperative-loop": "hint",
     "mutable-variable": "info",
@@ -53,7 +54,10 @@ Create `.java-functional-lsp.json` in your project root:
 }
 ```
 
-Severity levels: `error`, `warning` (default), `info`, `hint`, `off`.
+- `excludes` — glob patterns to skip files/directories entirely
+- `rules` — per-rule severity: `error`, `warning` (default), `info`, `hint`, `off`
+- `throw-statement`/`catch-rethrow` auto-suppressed in `@Bean` methods
+- `mutable-dto` suggests `@ConstructorBinding` for `@ConfigurationProperties` classes
 
 ## On-Demand Linting
 

{java_functional_lsp-0.3.1 → java_functional_lsp-0.4.0}/editors/vscode/package.json

@@ -2,7 +2,7 @@
   "name": "java-functional-lsp",
   "displayName": "Java Functional LSP",
   "description": "Java LSP server enforcing functional programming best practices — null safety, immutability, no exceptions",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "publisher": "aviadshiber",
   "license": "MIT",
   "engines": {

{java_functional_lsp-0.3.1 → java_functional_lsp-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "java-functional-lsp"
-version = "0.3.1"
+version = "0.4.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.3.1 → java_functional_lsp-0.4.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.3.1"
+__version__ = "0.4.0"

java_functional_lsp-0.4.0/src/java_functional_lsp/analyzers/base.py

@@ -0,0 +1,173 @@
+"""Base analyzer class and diagnostic types."""
+
+from __future__ import annotations
+
+import fnmatch
+from collections.abc import Generator
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import Any, Protocol, cast
+
+import tree_sitter_java as tsjava
+from tree_sitter import Language, Node, Parser
+
+
+class Severity(IntEnum):
+    ERROR = 1
+    WARNING = 2
+    INFO = 3
+    HINT = 4
+
+
+@dataclass(frozen=True)
+class Diagnostic:
+    line: int  # 0-based
+    col: int
+    end_line: int
+    end_col: int
+    severity: Severity
+    code: str  # rule ID
+    message: str
+    source: str = "java-functional-lsp"
+
+
+class Analyzer(Protocol):
+    """Protocol for all analyzers."""
+
+    def analyze(self, tree: Any, source: bytes, config: dict[str, Any]) -> list[Diagnostic]:
+        """Analyze a parsed tree and return diagnostics."""
+        ...
+
+
+_parser: Parser | None = None
+_language: Language | None = None
+
+
+def get_parser() -> Parser:
+    """Get or create a reusable tree-sitter Java parser."""
+    global _parser, _language
+    if _parser is None:
+        _language = Language(tsjava.language())
+        _parser = Parser(_language)
+    return _parser
+
+
+def get_language() -> Language:
+    """Get the Java language for queries."""
+    global _language
+    if _language is None:
+        get_parser()
+    assert _language is not None
+    return _language
+
+
+def find_nodes(root: Node, type_name: str) -> Generator[Node, None, None]:
+    """Find all descendant nodes of a given type using TreeCursor for performance."""
+    cursor = root.walk()
+    visited_children = False
+    while True:
+        if not visited_children:
+            current = cast(Node, cursor.node)
+            if current.type == type_name:
+                yield current
+            if not cursor.goto_first_child():
+                visited_children = True
+        elif cursor.goto_next_sibling():
+            visited_children = False
+        elif not cursor.goto_parent():
+            break
+
+
+def find_nodes_multi(root: Node, type_names: set[str]) -> Generator[Node, None, None]:
+    """Find all descendant nodes matching any of the given types using TreeCursor."""
+    cursor = root.walk()
+    visited_children = False
+    while True:
+        if not visited_children:
+            current = cast(Node, cursor.node)
+            if current.type in type_names:
+                yield current
+            if not cursor.goto_first_child():
+                visited_children = True
+        elif cursor.goto_next_sibling():
+            visited_children = False
+        elif not cursor.goto_parent():
+            break
+
+
+def collect_nodes_by_type(root: Node, type_names: set[str]) -> dict[str, list[Node]]:
+    """Walk tree once, bucket nodes by type. Avoids multiple full traversals."""
+    buckets: dict[str, list[Node]] = {t: [] for t in type_names}
+    cursor = root.walk()
+    visited_children = False
+    while True:
+        if not visited_children:
+            current = cast(Node, cursor.node)
+            if current.type in buckets:
+                buckets[current.type].append(current)
+            if not cursor.goto_first_child():
+                visited_children = True
+        elif cursor.goto_next_sibling():
+            visited_children = False
+        elif not cursor.goto_parent():
+            break
+    return buckets
+
+
+def find_ancestor(node: Node, type_name: str) -> Node | None:
+    """Walk up the tree to find the nearest ancestor of a given type."""
+    parent = node.parent
+    while parent:
+        if parent.type == type_name:
+            return parent
+        parent = parent.parent
+    return None
+
+
+def has_ancestor(node: Node, type_names: set[str]) -> bool:
+    """Check if any ancestor matches one of the given types."""
+    parent = node.parent
+    while parent:
+        if parent.type in type_names:
+            return True
+        parent = parent.parent
+    return False
+
+
+def severity_from_config(config: dict[str, Any], rule_id: str, default: Severity = Severity.WARNING) -> Severity | None:
+    """Get severity for a rule from config. Returns None if rule is disabled."""
+    rules: dict[str, str] = config.get("rules", {})
+    level = rules.get(rule_id)
+    if level is None:
+        return default
+    if level == "off":
+        return None
+    return {
+        "error": Severity.ERROR,
+        "warning": Severity.WARNING,
+        "info": Severity.INFO,
+        "hint": Severity.HINT,
+    }.get(level, default)
+
+
+def is_excluded(path_str: str, patterns: list[str]) -> bool:
+    """Return True if path matches any exclude glob pattern.
+
+    Patterns support ** for multi-segment wildcards (e.g. **/generated/**).
+    Uses fnmatch which handles ** correctly across Python 3.10+.
+    """
+    normalized = path_str.replace("\\", "/")
+    return any(fnmatch.fnmatch(normalized, pattern) for pattern in patterns)
+
+
+def has_sibling_annotation(modifiers_node: Node, annotation_name: bytes) -> bool:
+    """Check if a modifiers node contains an annotation with the given name.
+
+    Checks both marker_annotation (@Foo) and annotation (@Foo(...)) forms.
+    """
+    for child in modifiers_node.named_children:
+        if child.type in ("marker_annotation", "annotation"):
+            name_node = child.child_by_field_name("name")
+            if name_node is not None and name_node.text == annotation_name:
+                return True
+    return False

{java_functional_lsp-0.3.1 → java_functional_lsp-0.4.0}/src/java_functional_lsp/analyzers/exception_checker.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from .base import Diagnostic, find_nodes, severity_from_config
+from .base import Diagnostic, find_nodes, has_sibling_annotation, severity_from_config
 
 _MESSAGES = {
     "throw-statement": ("Avoid throwing exceptions. Use Either.left(error) or Try.of(() -> ...).toEither()."),
@@ -14,6 +14,19 @@ _MESSAGES = {
 }
 
 
+def _is_in_bean_method(node: Any) -> bool:
+    """Check if node is inside a method annotated with @Bean."""
+    parent = node.parent
+    while parent:
+        if parent.type == "method_declaration":
+            modifiers = next((c for c in parent.children if c.type == "modifiers"), None)
+            if modifiers and has_sibling_annotation(modifiers, b"Bean"):
+                return True
+            return False
+        parent = parent.parent
+    return False
+
+
 class ExceptionChecker:
     """Detects throw statements and catch-rethrow anti-patterns."""
 
@@ -24,6 +37,8 @@ class ExceptionChecker:
         severity = severity_from_config(config, "throw-statement")
         if severity is not None:
             for node in find_nodes(tree.root_node, "throw_statement"):
+                if _is_in_bean_method(node):
+                    continue
                 diagnostics.append(
                     Diagnostic(
                         line=node.start_point[0],
@@ -40,13 +55,12 @@ class ExceptionChecker:
         severity = severity_from_config(config, "catch-rethrow")
         if severity is not None:
             for node in find_nodes(tree.root_node, "catch_clause"):
+                if _is_in_bean_method(node):
+                    continue
                 body = node.child_by_field_name("body")
                 if body is None:
                     continue
-                # Check if the block has exactly one statement and it's a throw
-                statements = [
-                    c for c in body.children if c.type not in ("{", "}", "comment", "line_comment", "block_comment")
-                ]
+                statements = [c for c in body.named_children if c.type not in ("line_comment", "block_comment")]
                 if len(statements) == 1 and statements[0].type == "throw_statement":
                     diagnostics.append(
                         Diagnostic(

{java_functional_lsp-0.3.1 → java_functional_lsp-0.4.0}/src/java_functional_lsp/analyzers/mutation_checker.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from .base import Diagnostic, find_nodes, find_nodes_multi, has_ancestor, severity_from_config
+from .base import Diagnostic, find_nodes, find_nodes_multi, has_ancestor, has_sibling_annotation, severity_from_config
 
 _MESSAGES = {
     "mutable-variable": "Avoid reassigning variables. Use final + functional transforms (map, flatMap, fold).",
@@ -45,8 +45,15 @@ class MutationChecker:
             if ann_text in (b"Data", b"Setter"):
                 # Verify it's on a class declaration
                 if node.parent and node.parent.type == "modifiers":
-                    grandparent = node.parent.parent
+                    modifiers = node.parent
+                    grandparent = modifiers.parent
                     if grandparent and grandparent.type == "class_declaration":
+                        if has_sibling_annotation(modifiers, b"ConfigurationProperties"):
+                            message = (
+                                "Use @ConstructorBinding instead of @Data/@Setter for @ConfigurationProperties classes."
+                            )
+                        else:
+                            message = _MESSAGES["mutable-dto"]
                         diagnostics.append(
                             Diagnostic(
                                 line=name_node.start_point[0],
@@ -55,7 +62,7 @@ class MutationChecker:
                                 end_col=name_node.end_point[1],
                                 severity=severity,
                                 code="mutable-dto",
-                                message=_MESSAGES["mutable-dto"],
+                                message=message,
                             )
                         )
 
@@ -111,10 +118,19 @@ class MutationChecker:
                 if name_node.text not in _CHECK_METHODS:
                     continue
 
-                # Check if the body contains .get() on the same object
+                # Check if the if-body contains .get() on the same object (AST-based)
                 obj_name = obj_node.text
-                body_text = if_node.text
-                if obj_name is not None and body_text is not None and obj_name + b".get()" in body_text:
+                consequence = if_node.child_by_field_name("consequence")
+                if consequence is None or obj_name is None:
+                    continue
+                found_get = False
+                for call in find_nodes(consequence, "method_invocation"):
+                    call_name = call.child_by_field_name("name")
+                    call_obj = call.child_by_field_name("object")
+                    if call_name and call_name.text == b"get" and call_obj and call_obj.text == obj_name:
+                        found_get = True
+                        break
+                if found_get:
                     diagnostics.append(
                         Diagnostic(
                             line=if_node.start_point[0],

{java_functional_lsp-0.3.1 → java_functional_lsp-0.4.0}/src/java_functional_lsp/cli.py

@@ -7,7 +7,7 @@ import sys
 from pathlib import Path
 from typing import Any
 
-from .analyzers.base import Analyzer, Diagnostic, Severity, get_parser
+from .analyzers.base import Analyzer, Diagnostic, Severity, get_parser, is_excluded
 from .analyzers.exception_checker import ExceptionChecker
 from .analyzers.mutation_checker import MutationChecker
 from .analyzers.null_checker import NullChecker
@@ -107,7 +107,10 @@ def main() -> None:
     config = load_config(files[0])
 
     total_diags = 0
+    excludes: list[str] = config.get("excludes", [])
     for path in files:
+        if excludes and is_excluded(path.as_posix(), excludes):
+            continue
         diags = check_file(path, config)
         for d in diags:
             print(format_diagnostic(path, d))

{java_functional_lsp-0.3.1 → java_functional_lsp-0.4.0}/src/java_functional_lsp/server.py

@@ -16,7 +16,7 @@ import cattrs
 from lsprotocol import types as lsp
 from pygls.lsp.server import LanguageServer
 
-from .analyzers.base import Analyzer, Severity, get_parser
+from .analyzers.base import Analyzer, Severity, get_parser, is_excluded
 from .analyzers.base import Diagnostic as LintDiagnostic
 from .analyzers.exception_checker import ExceptionChecker
 from .analyzers.mutation_checker import MutationChecker
@@ -46,6 +46,7 @@ class JavaFunctionalLspServer(LanguageServer):
         self._parser = get_parser()
         self._config: dict[str, Any] = {}
         self._init_params: dict[str, Any] = {}
+        self._trees: dict[str, Any] = {}  # URI -> last parsed tree for incremental parsing
         self._proxy = JdtlsProxy(on_diagnostics=self._on_jdtls_diagnostics)
 
     def _on_jdtls_diagnostics(self, uri: str, diagnostics: list[Any]) -> None:
@@ -93,10 +94,20 @@ def _to_lsp_diagnostic(diag: LintDiagnostic) -> lsp.Diagnostic:
     )
 
 
-def _analyze_document(source_text: str) -> list[lsp.Diagnostic]:
-    """Run all custom analyzers on the given source text."""
+def _analyze_document(source_text: str, uri: str = "") -> list[lsp.Diagnostic]:
+    """Run all custom analyzers on the given source text. Uses incremental parsing when possible."""
+    # Check excludes before parsing
+    if uri:
+        excludes: list[str] = server._config.get("excludes", [])
+        if excludes:
+            path_str = _uri_to_path(uri)
+            if is_excluded(path_str, excludes):
+                return []
     source_bytes = source_text.encode("utf-8")
-    tree = server._parser.parse(source_bytes)
+    old_tree = server._trees.get(uri) if uri else None
+    tree = server._parser.parse(source_bytes, old_tree) if old_tree else server._parser.parse(source_bytes)
+    if uri:
+        server._trees[uri] = tree
     config = server._config
 
     all_diagnostics: list[LintDiagnostic] = []
@@ -143,7 +154,7 @@ def _jdtls_raw_to_lsp_diagnostics(raw_diagnostics: list[Any]) -> list[lsp.Diagno
 def _publish_diagnostics(uri: str) -> None:
     """Merge custom + jdtls diagnostics and publish to client."""
     doc = server.workspace.get_text_document(uri)
-    custom_diags = _analyze_document(doc.source)
+    custom_diags = _analyze_document(doc.source, uri)
 
     # Get cached jdtls diagnostics
     jdtls_diags: list[lsp.Diagnostic] = []

java_functional_lsp-0.4.0/tests/test_base.py

@@ -0,0 +1,157 @@
+"""Tests for base.py tree traversal helper functions."""
+
+from java_functional_lsp.analyzers.base import (
+    collect_nodes_by_type,
+    find_ancestor,
+    find_nodes,
+    find_nodes_multi,
+    get_parser,
+    has_ancestor,
+    has_sibling_annotation,
+    is_excluded,
+)
+
+
+def _parse(source: str):
+    parser = get_parser()
+    return parser.parse(source.encode())
+
+
+class TestFindNodes:
+    def test_finds_null_literal(self):
+        tree = _parse("class T { void f() { return null; } }")
+        nodes = list(find_nodes(tree.root_node, "null_literal"))
+        assert len(nodes) == 1
+        assert nodes[0].text == b"null"
+
+    def test_finds_multiple_matches(self):
+        tree = _parse("class T { void f() { return null; } void g() { return null; } }")
+        nodes = list(find_nodes(tree.root_node, "null_literal"))
+        assert len(nodes) == 2
+
+    def test_finds_nested_nodes(self):
+        tree = _parse("""
+            class Outer {
+                class Inner {
+                    void f() { return null; }
+                }
+            }
+        """)
+        nodes = list(find_nodes(tree.root_node, "null_literal"))
+        assert len(nodes) == 1
+
+    def test_no_match_returns_empty(self):
+        tree = _parse("class T { void f() { return 42; } }")
+        nodes = list(find_nodes(tree.root_node, "null_literal"))
+        assert len(nodes) == 0
+
+    def test_empty_class(self):
+        tree = _parse("class T { }")
+        nodes = list(find_nodes(tree.root_node, "method_declaration"))
+        assert len(nodes) == 0
+
+
+class TestFindNodesMulti:
+    def test_finds_multiple_types(self):
+        tree = _parse("""
+            class T {
+                void f() {
+                    for (int i = 0; i < 10; i++) {}
+                    while (true) {}
+                }
+            }
+        """)
+        nodes = list(find_nodes_multi(tree.root_node, {"for_statement", "while_statement"}))
+        assert len(nodes) == 2
+
+    def test_empty_set_returns_nothing(self):
+        tree = _parse("class T { void f() { return null; } }")
+        nodes = list(find_nodes_multi(tree.root_node, set()))
+        assert len(nodes) == 0
+
+
+class TestHasAncestor:
+    def test_has_method_ancestor(self):
+        tree = _parse("class T { void f() { return null; } }")
+        null_nodes = list(find_nodes(tree.root_node, "null_literal"))
+        assert len(null_nodes) == 1
+        assert has_ancestor(null_nodes[0], {"method_declaration"})
+
+    def test_no_matching_ancestor(self):
+        tree = _parse("class T { void f() { return null; } }")
+        null_nodes = list(find_nodes(tree.root_node, "null_literal"))
+        assert not has_ancestor(null_nodes[0], {"constructor_declaration"})
+
+    def test_multiple_ancestor_types(self):
+        tree = _parse("class T { void f() { return null; } }")
+        null_nodes = list(find_nodes(tree.root_node, "null_literal"))
+        assert has_ancestor(null_nodes[0], {"method_declaration", "constructor_declaration"})
+
+
+class TestFindAncestor:
+    def test_finds_nearest_ancestor(self):
+        tree = _parse("class T { void f() { return null; } }")
+        null_nodes = list(find_nodes(tree.root_node, "null_literal"))
+        ancestor = find_ancestor(null_nodes[0], "method_declaration")
+        assert ancestor is not None
+        assert ancestor.type == "method_declaration"
+
+    def test_returns_none_when_not_found(self):
+        tree = _parse("class T { void f() { return null; } }")
+        null_nodes = list(find_nodes(tree.root_node, "null_literal"))
+        assert find_ancestor(null_nodes[0], "constructor_declaration") is None
+
+
+class TestCollectNodesByType:
+    def test_collects_multiple_types_single_pass(self):
+        tree = _parse("""
+            class T {
+                void f() {
+                    return null;
+                    throw new Exception();
+                }
+            }
+        """)
+        buckets = collect_nodes_by_type(tree.root_node, {"null_literal", "throw_statement", "method_declaration"})
+        assert len(buckets["null_literal"]) == 1
+        assert len(buckets["throw_statement"]) == 1
+        assert len(buckets["method_declaration"]) == 1
+
+    def test_empty_buckets_for_missing_types(self):
+        tree = _parse("class T { }")
+        buckets = collect_nodes_by_type(tree.root_node, {"null_literal", "throw_statement"})
+        assert len(buckets["null_literal"]) == 0
+        assert len(buckets["throw_statement"]) == 0
+
+
+class TestIsExcluded:
+    def test_matches_double_star_pattern(self):
+        assert is_excluded("/home/user/project/nlu-trs-client-shaded/Foo.java", ["**/nlu-trs-client-shaded/**"])
+
+    def test_no_match(self):
+        assert not is_excluded("/home/user/project/src/Foo.java", ["**/nlu-trs-client-shaded/**"])
+
+    def test_empty_patterns(self):
+        assert not is_excluded("/any/path/Foo.java", [])
+
+    def test_multiple_patterns(self):
+        assert is_excluded("/project/generated/Model.java", ["**/shaded/**", "**/generated/**"])
+
+    def test_windows_backslashes_normalized(self):
+        assert is_excluded("C:\\project\\generated\\Model.java", ["**/generated/**"])
+
+
+class TestHasSiblingAnnotation:
+    def test_finds_sibling_annotation(self):
+        tree = _parse("@ConfigurationProperties @Setter class Props { String name; }")
+        for node in find_nodes(tree.root_node, "marker_annotation"):
+            name = node.child_by_field_name("name")
+            if name and name.text == b"Setter" and node.parent:
+                assert has_sibling_annotation(node.parent, b"ConfigurationProperties")
+
+    def test_no_sibling(self):
+        tree = _parse("@Setter class Props { String name; }")
+        for node in find_nodes(tree.root_node, "marker_annotation"):
+            name = node.child_by_field_name("name")
+            if name and name.text == b"Setter" and node.parent:
+                assert not has_sibling_annotation(node.parent, b"ConfigurationProperties")

java_functional_lsp-0.4.0/tests/test_exception_checker.py

@@ -0,0 +1,104 @@
+"""Tests for exception handling rules."""
+
+from __future__ import annotations
+
+from java_functional_lsp.analyzers.exception_checker import ExceptionChecker
+from tests.conftest import parse_and_analyze
+
+
+class TestThrowStatement:
+    def test_detects_throw(self) -> None:
+        source = b"class T { void f() { throw new RuntimeException(); } }"
+        diags = parse_and_analyze(ExceptionChecker(), source)
+        codes = [d.code for d in diags]
+        assert "throw-statement" in codes
+
+    def test_ignores_no_throw(self) -> None:
+        source = b"class T { void f() { System.out.println(); } }"
+        diags = parse_and_analyze(ExceptionChecker(), source)
+        assert not any(d.code == "throw-statement" for d in diags)
+
+
+class TestCatchRethrow:
+    def test_detects_catch_rethrow(self) -> None:
+        source = b"""
+        class T {
+            void f() {
+                try { foo(); }
+                catch (Exception e) { throw new RuntimeException(e); }
+            }
+        }
+        """
+        diags = parse_and_analyze(ExceptionChecker(), source)
+        codes = [d.code for d in diags]
+        assert "catch-rethrow" in codes
+
+    def test_catch_with_comment_and_throw_still_flagged(self) -> None:
+        """A catch with only a comment + throw is still a rethrow — comments are ignored."""
+        source = b"""
+        class T {
+            void f() {
+                try { foo(); }
+                catch (Exception e) {
+                    // log the error
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+        """
+        diags = parse_and_analyze(ExceptionChecker(), source)
+        assert any(d.code == "catch-rethrow" for d in diags)
+
+    def test_ignores_catch_with_logic(self) -> None:
+        source = b"""
+        class T {
+            void f() {
+                try { foo(); }
+                catch (Exception e) { log.error(e); return; }
+            }
+        }
+        """
+        diags = parse_and_analyze(ExceptionChecker(), source)
+        assert not any(d.code == "catch-rethrow" for d in diags)
+
+
+class TestBeanSuppression:
+    def test_ignores_throw_in_bean_method(self) -> None:
+        source = b"""
+        class Config {
+            @Bean
+            DataSource dataSource() {
+                if (url == null) {
+                    throw new IllegalStateException("url required");
+                }
+                return new DataSource(url);
+            }
+        }
+        """
+        diags = parse_and_analyze(ExceptionChecker(), source)
+        assert not any(d.code == "throw-statement" for d in diags)
+
+    def test_flags_throw_in_regular_method(self) -> None:
+        source = b"""
+        class Service {
+            void process() {
+                throw new RuntimeException("error");
+            }
+        }
+        """
+        diags = parse_and_analyze(ExceptionChecker(), source)
+        assert any(d.code == "throw-statement" for d in diags)
+
+    def test_ignores_catch_rethrow_in_bean_method(self) -> None:
+        source = b"""
+        class Config {
+            @Bean
+            DataSource dataSource() {
+                try { return connect(); }
+                catch (Exception e) { throw new RuntimeException(e); }
+            }
+        }
+        """
+        diags = parse_and_analyze(ExceptionChecker(), source)
+        assert not any(d.code == "catch-rethrow" for d in diags)
+        assert not any(d.code == "throw-statement" for d in diags)

{java_functional_lsp-0.3.1 → java_functional_lsp-0.4.0}/tests/test_mutation_checker.py

@@ -58,6 +58,20 @@ class TestMutableDto:
         diags = parse_and_analyze(MutationChecker(), source)
         assert not any(d.code == "mutable-dto" for d in diags)
 
+    def test_config_properties_suggests_constructor_binding(self) -> None:
+        source = b"@ConfigurationProperties @Setter class Props { String name; }"
+        diags = parse_and_analyze(MutationChecker(), source)
+        dto_diags = [d for d in diags if d.code == "mutable-dto"]
+        assert len(dto_diags) == 1
+        assert "@ConstructorBinding" in dto_diags[0].message
+
+    def test_regular_setter_suggests_value(self) -> None:
+        source = b"@Setter class Foo { String name; }"
+        diags = parse_and_analyze(MutationChecker(), source)
+        dto_diags = [d for d in diags if d.code == "mutable-dto"]
+        assert len(dto_diags) == 1
+        assert "@Value" in dto_diags[0].message
+
 
 class TestImperativeOptionUnwrap:
     def test_detects_is_defined_get(self) -> None:
@@ -94,3 +108,41 @@ class TestImperativeOptionUnwrap:
         """
         diags = parse_and_analyze(MutationChecker(), source)
         assert not any(d.code == "imperative-option-unwrap" for d in diags)
+
+    def test_ignores_unrelated_get(self) -> None:
+        """Different object's .get() should not trigger the rule."""
+        source = b"""
+        class T {
+            void f() {
+                if (opt.isDefined()) { other.get(); }
+            }
+        }
+        """
+        diags = parse_and_analyze(MutationChecker(), source)
+        assert not any(d.code == "imperative-option-unwrap" for d in diags)
+
+
+class TestConstructorAssignment:
+    def test_ignores_this_field_in_constructor(self) -> None:
+        source = b"class T { final int x; T(int x) { this.x = x; } }"
+        diags = parse_and_analyze(MutationChecker(), source)
+        assert not any(d.code == "mutable-variable" for d in diags)
+
+    def test_ignores_computed_field_in_constructor(self) -> None:
+        """this.x = computeValue() in constructor should not be flagged."""
+        source = b"class T { final int x; T() { this.x = compute(); } }"
+        diags = parse_and_analyze(MutationChecker(), source)
+        assert not any(d.code == "mutable-variable" for d in diags)
+
+    def test_detects_other_object_field_in_constructor(self) -> None:
+        """other.field = x in a constructor IS a mutation and should be flagged."""
+        source = b"class T { T() { other.field = 42; } }"
+        diags = parse_and_analyze(MutationChecker(), source)
+        assert any(d.code == "mutable-variable" for d in diags)
+
+    def test_detects_reassignment_in_method(self) -> None:
+        """this.x = ... in a regular method IS a mutation."""
+        source = b"class T { int x; void f() { this.x = 42; } }"
+        diags = parse_and_analyze(MutationChecker(), source)
+        codes = [d.code for d in diags]
+        assert "mutable-variable" in codes

java_functional_lsp-0.3.1/src/java_functional_lsp/analyzers/base.py

@@ -1,112 +0,0 @@
-"""Base analyzer class and diagnostic types."""
-
-from __future__ import annotations
-
-from collections.abc import Generator
-from dataclasses import dataclass
-from enum import IntEnum
-from typing import Any, Protocol
-
-import tree_sitter_java as tsjava
-from tree_sitter import Language, Node, Parser
-
-
-class Severity(IntEnum):
-    ERROR = 1
-    WARNING = 2
-    INFO = 3
-    HINT = 4
-
-
-@dataclass(frozen=True)
-class Diagnostic:
-    line: int  # 0-based
-    col: int
-    end_line: int
-    end_col: int
-    severity: Severity
-    code: str  # rule ID
-    message: str
-    source: str = "java-functional-lsp"
-
-
-class Analyzer(Protocol):
-    """Protocol for all analyzers."""
-
-    def analyze(self, tree: Any, source: bytes, config: dict[str, Any]) -> list[Diagnostic]:
-        """Analyze a parsed tree and return diagnostics."""
-        ...
-
-
-_parser: Parser | None = None
-_language: Language | None = None
-
-
-def get_parser() -> Parser:
-    """Get or create a reusable tree-sitter Java parser."""
-    global _parser, _language
-    if _parser is None:
-        _language = Language(tsjava.language())
-        _parser = Parser(_language)
-    return _parser
-
-
-def get_language() -> Language:
-    """Get the Java language for queries."""
-    global _language
-    if _language is None:
-        get_parser()
-    assert _language is not None
-    return _language
-
-
-def find_nodes(node: Node, type_name: str) -> Generator[Node, None, None]:
-    """Recursively find all descendant nodes of a given type."""
-    if node.type == type_name:
-        yield node
-    for child in node.children:
-        yield from find_nodes(child, type_name)
-
-
-def find_nodes_multi(node: Node, type_names: set[str]) -> Generator[Node, None, None]:
-    """Recursively find all descendant nodes matching any of the given types."""
-    if node.type in type_names:
-        yield node
-    for child in node.children:
-        yield from find_nodes_multi(child, type_names)
-
-
-def find_ancestor(node: Node, type_name: str) -> Node | None:
-    """Walk up the tree to find the nearest ancestor of a given type."""
-    parent = node.parent
-    while parent:
-        if parent.type == type_name:
-            return parent
-        parent = parent.parent
-    return None
-
-
-def has_ancestor(node: Node, type_names: set[str]) -> bool:
-    """Check if any ancestor matches one of the given types."""
-    parent = node.parent
-    while parent:
-        if parent.type in type_names:
-            return True
-        parent = parent.parent
-    return False
-
-
-def severity_from_config(config: dict[str, Any], rule_id: str, default: Severity = Severity.WARNING) -> Severity | None:
-    """Get severity for a rule from config. Returns None if rule is disabled."""
-    rules: dict[str, str] = config.get("rules", {})
-    level = rules.get(rule_id)
-    if level is None:
-        return default
-    if level == "off":
-        return None
-    return {
-        "error": Severity.ERROR,
-        "warning": Severity.WARNING,
-        "info": Severity.INFO,
-        "hint": Severity.HINT,
-    }.get(level, default)

java_functional_lsp-0.3.1/tests/test_exception_checker.py

@@ -1,46 +0,0 @@
-"""Tests for exception handling rules."""
-
-from __future__ import annotations
-
-from java_functional_lsp.analyzers.exception_checker import ExceptionChecker
-from tests.conftest import parse_and_analyze
-
-
-class TestThrowStatement:
-    def test_detects_throw(self) -> None:
-        source = b"class T { void f() { throw new RuntimeException(); } }"
-        diags = parse_and_analyze(ExceptionChecker(), source)
-        codes = [d.code for d in diags]
-        assert "throw-statement" in codes
-
-    def test_ignores_no_throw(self) -> None:
-        source = b"class T { void f() { System.out.println(); } }"
-        diags = parse_and_analyze(ExceptionChecker(), source)
-        assert not any(d.code == "throw-statement" for d in diags)
-
-
-class TestCatchRethrow:
-    def test_detects_catch_rethrow(self) -> None:
-        source = b"""
-        class T {
-            void f() {
-                try { foo(); }
-                catch (Exception e) { throw new RuntimeException(e); }
-            }
-        }
-        """
-        diags = parse_and_analyze(ExceptionChecker(), source)
-        codes = [d.code for d in diags]
-        assert "catch-rethrow" in codes
-
-    def test_ignores_catch_with_logic(self) -> None:
-        source = b"""
-        class T {
-            void f() {
-                try { foo(); }
-                catch (Exception e) { log.error(e); return; }
-            }
-        }
-        """
-        diags = parse_and_analyze(ExceptionChecker(), source)
-        assert not any(d.code == "catch-rethrow" for d in diags)