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

{java_functional_lsp-0.3.1 → java_functional_lsp-0.3.2}/.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.3.2"
 }

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.3.1
+Version: 0.3.2
 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
 

{java_functional_lsp-0.3.1 → java_functional_lsp-0.3.2}/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
 

{java_functional_lsp-0.3.1 → java_functional_lsp-0.3.2}/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.3.2",
   "publisher": "aviadshiber",
   "license": "MIT",
   "engines": {

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

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

{java_functional_lsp-0.3.1 → java_functional_lsp-0.3.2}/src/java_functional_lsp/analyzers/base.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from collections.abc import Generator
 from dataclasses import dataclass
 from enum import IntEnum
-from typing import Any, Protocol
+from typing import Any, Protocol, cast
 
 import tree_sitter_java as tsjava
 from tree_sitter import Language, Node, Parser
@@ -60,20 +60,57 @@ def get_language() -> Language:
     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_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:

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

@@ -43,10 +43,8 @@ class ExceptionChecker:
                 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")
-                ]
+                # Check if the block has exactly one named statement and it's a throw
+                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.3.2}/src/java_functional_lsp/analyzers/mutation_checker.py

@@ -111,10 +111,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.3.2}/src/java_functional_lsp/server.py

@@ -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,13 @@ 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."""
     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 +147,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.3.2/tests/test_base.py

@@ -0,0 +1,122 @@
+"""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,
+)
+
+
+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

{java_functional_lsp-0.3.1 → java_functional_lsp-0.3.2}/tests/test_exception_checker.py

@@ -33,6 +33,22 @@ class TestCatchRethrow:
         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 {

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

@@ -94,3 +94,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