java-functional-lsp 0.6.3__tar.gz → 0.7.0__tar.gz

java_functional_lsp-0.7.0/.githooks/pre-commit

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# Pre-commit: run lint, format check, type check, and tests.
+# Bypass with: git commit --no-verify
+
+set -e
+
+echo "Running pre-commit checks..."
+
+echo "  Lint..."
+uv run ruff check src/ tests/
+
+echo "  Format..."
+uv run ruff format --check src/ tests/
+
+echo "  Type check..."
+uv run mypy src/
+
+echo "  Version bump check..."
+# If source files changed, version must be bumped compared to the base branch.
+# Compares the actual version value (not just file presence) so it works with --amend.
+src_changed=$(git diff --cached --name-only -- 'src/' | grep -v '__pycache__' | head -1)
+if [ -n "$src_changed" ]; then
+    # Resolve base branch: try remote main, then local main, then parent commit.
+    base_branch=$(git rev-parse --verify origin/main 2>/dev/null || git rev-parse --verify main 2>/dev/null || echo "HEAD~1")
+    # Extract the quoted version value (e.g., "0.6.4") from pyproject.toml
+    base_version=$(git show "$base_branch":pyproject.toml 2>/dev/null | grep -o 'version = "[^"]*"' | head -1)
+    staged_version=$(git show :pyproject.toml 2>/dev/null | grep -o 'version = "[^"]*"' | head -1)
+    # Skip check if either version is unresolvable (new project, missing file)
+    if [ -n "$base_version" ] && [ -n "$staged_version" ] && [ "$base_version" = "$staged_version" ]; then
+        echo "ERROR: Source files changed but version was not bumped."
+        echo "Update the version in both pyproject.toml and src/java_functional_lsp/__init__.py"
+        echo ""
+        echo "To bypass (docs/tests-only changes): git commit --no-verify"
+        exit 1
+    fi
+fi
+
+echo "  Tests..."
+uv run pytest -q
+
+echo "All checks passed."

{java_functional_lsp-0.6.3 → java_functional_lsp-0.7.0}/PKG-INFO

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

{java_functional_lsp-0.6.3 → java_functional_lsp-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "java-functional-lsp"
-version = "0.6.3"
+version = "0.7.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.6.3 → java_functional_lsp-0.7.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.6.3"
+__version__ = "0.7.0"

{java_functional_lsp-0.6.3 → java_functional_lsp-0.7.0}/src/java_functional_lsp/analyzers/base.py

@@ -49,6 +49,10 @@ class Analyzer(Protocol):
         ...
 
 
+#: Tree-sitter child node types that should be skipped when iterating named_children.
+#: Shared across analyzers and fix generators so comment-filtering stays consistent.
+IGNORED_CHILDREN = ("line_comment", "block_comment")
+
 _parser: Parser | None = None
 _language: Language | None = None
 
@@ -144,6 +148,54 @@ def has_ancestor(node: Node, type_names: set[str]) -> bool:
     return False
 
 
+def references_var(node: Node, var_name: bytes) -> bool:
+    """Return True if any identifier descendant of ``node`` has text equal to ``var_name``.
+
+    Used to detect whether an expression references a given variable (e.g. an
+    exception variable inside a catch-return expression). Uses a TreeCursor walk
+    for performance — no recursion, no allocation per node.
+    """
+    cursor = node.walk()
+    visited_children = False
+    while True:
+        if not visited_children:
+            cur = cursor.node
+            if cur is not None and cur.type == "identifier" and cur.text == var_name:
+                return True
+            if not cursor.goto_first_child():
+                visited_children = True
+        elif cursor.goto_next_sibling():
+            visited_children = False
+        elif not cursor.goto_parent():
+            break
+    return False
+
+
+def has_error_or_missing(node: Node) -> bool:
+    """Return True if the subtree rooted at ``node`` contains any ERROR or MISSING nodes.
+
+    Used by fix generators as a defensive gate: tree-sitter's error recovery
+    produces partial trees for malformed input (common during incremental typing
+    in editors), and emitting a rewrite from such input can produce invalid edits.
+    """
+    if node.has_error or node.is_missing:
+        return True
+    cursor = node.walk()
+    visited_children = False
+    while True:
+        if not visited_children:
+            cur = cursor.node
+            if cur is not None and (cur.type == "ERROR" or cur.is_missing):
+                return True
+            if not cursor.goto_first_child():
+                visited_children = True
+        elif cursor.goto_next_sibling():
+            visited_children = False
+        elif not cursor.goto_parent():
+            break
+    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", {})

java_functional_lsp-0.7.0/src/java_functional_lsp/analyzers/exception_checker.py

@@ -0,0 +1,218 @@
+"""Exception handling rules: detect throw statements and catch-rethrow patterns."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .base import (
+    IGNORED_CHILDREN,
+    Diagnostic,
+    DiagnosticData,
+    Severity,
+    collect_nodes_by_type,
+    has_sibling_annotation,
+    severity_from_config,
+)
+
+_MESSAGES = {
+    "throw-statement": ("Avoid throwing exceptions. Use Either.left(error) or Try.of(() -> ...).toEither()."),
+    "catch-rethrow": (
+        "Avoid catching and rethrowing. Use Try.of(() -> ...).toEither() to convert exceptions to values."
+    ),
+    "try-catch-to-monadic": ("Imperative try/catch: use Try.of(() -> ...) for monadic error handling."),
+}
+
+_DATA = {
+    "throw-statement": DiagnosticData(
+        fix_type="USE_EITHER_OR_TRY",
+        target_library="io.vavr.control.Either",
+        rationale=(
+            "Throwing exceptions breaks referential transparency."
+            " Use Either.left(error) to represent failures as values."
+        ),
+    ),
+    "catch-rethrow": DiagnosticData(
+        fix_type="USE_TRY_TO_EITHER",
+        target_library="io.vavr.control.Try",
+        rationale=(
+            "Catching and rethrowing adds noise. Use Try.of(() -> ...).toEither() to convert exceptions to values."
+        ),
+    ),
+    "try-catch-to-monadic": DiagnosticData(
+        fix_type="WRAP_IN_TRY",
+        target_library="io.vavr.control.Try",
+        rationale=(
+            "try/catch mixes control flow with value handling."
+            " Use Try.of(...) for composable, value-based failure handling."
+        ),
+    ),
+}
+
+
+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
+
+
+def _matches_try_catch_monadic_shape(try_node: Any) -> bool:  # noqa: PLR0911, PLR0912
+    """Verify a try_statement has a shape the try-catch-to-monadic fix can rewrite.
+
+    Requirements:
+    - No ``resource_specification`` child (try-with-resources would lose auto-close semantics)
+    - No ``finally_clause`` child
+    - Exactly one ``catch_clause`` child
+    - Catch clause must use a single exception type (no union-catch ``A | B e``)
+    - Try body is a block with a single ``return_statement`` that has an expression
+    - Catch body is a block whose last named child is a ``return_statement`` with an expression,
+      and any prior named children are ``expression_statement`` (for the Pattern 2 logging case)
+
+    Guard-clause returns are preferred for readability; noqa silences the
+    "too many returns" rule since each branch fails a distinct shape check.
+
+    Note: This analyzer-side check must stay in sync with
+    ``_validate_and_extract_try_catch_parts`` in fixes.py — any shape the
+    analyzer accepts must also be rewritable by the fix, otherwise users
+    see a diagnostic with no working code action.
+    """
+    # Single pass over try_node.children: detect finally, resource_specification, and catches
+    has_finally = False
+    has_resources = False
+    catches: list[Any] = []
+    for c in try_node.children:
+        if c.type == "finally_clause":
+            has_finally = True
+        elif c.type == "resource_specification":
+            has_resources = True
+        elif c.type == "catch_clause":
+            catches.append(c)
+
+    if has_finally or has_resources:
+        return False
+    if len(catches) != 1:
+        return False
+
+    # Reject union-catch (A | B e). Tree-sitter encodes the type in catch_formal_parameter
+    # as either a single type node or a catch_type node containing multiple type_identifier children.
+    catch = catches[0]
+    param = next((c for c in catch.children if c.type == "catch_formal_parameter"), None)
+    if param is None:
+        return False
+    catch_type_node = next((c for c in param.children if c.type == "catch_type"), None)
+    if catch_type_node is not None and catch_type_node.text and b"|" in catch_type_node.text:
+        return False
+
+    # Try body must be a block with a single return_statement with an expression
+    body = try_node.child_by_field_name("body")
+    if body is None or body.type != "block":
+        return False
+    body_stmts = [c for c in body.named_children if c.type not in IGNORED_CHILDREN]
+    if len(body_stmts) != 1 or body_stmts[0].type != "return_statement":
+        return False
+    # Return must have an expression (not bare `return;`)
+    ret_children = [c for c in body_stmts[0].named_children if c.type not in IGNORED_CHILDREN]
+    if not ret_children:
+        return False
+
+    # Catch body must end with a return_statement; prior stmts must be expression_statements
+    catch_body = catch.child_by_field_name("body")
+    if catch_body is None or catch_body.type != "block":
+        return False
+    catch_stmts = [c for c in catch_body.named_children if c.type not in IGNORED_CHILDREN]
+    if not catch_stmts or catch_stmts[-1].type != "return_statement":
+        return False
+    if any(s.type != "expression_statement" for s in catch_stmts[:-1]):
+        return False
+    # The catch return must have an expression (not bare `return;`)
+    catch_ret_children = [c for c in catch_stmts[-1].named_children if c.type not in IGNORED_CHILDREN]
+    if not catch_ret_children:
+        return False
+
+    return True
+
+
+class ExceptionChecker:
+    """Detects throw statements and catch-rethrow anti-patterns."""
+
+    def analyze(self, tree: Any, source: bytes, config: dict[str, Any]) -> list[Diagnostic]:
+        diagnostics: list[Diagnostic] = []
+
+        # Single tree walk collecting all three node types we care about.
+        # Previously this method did three separate find_nodes walks, which is 3x the traversal
+        # cost on every analysis pass (LSP re-runs on every document change).
+        buckets = collect_nodes_by_type(tree.root_node, {"throw_statement", "catch_clause", "try_statement"})
+
+        # Rule: throw-statement
+        severity = severity_from_config(config, "throw-statement")
+        if severity is not None:
+            for node in buckets["throw_statement"]:
+                if _is_in_bean_method(node):
+                    continue
+                diagnostics.append(
+                    Diagnostic(
+                        line=node.start_point[0],
+                        col=node.start_point[1],
+                        end_line=node.end_point[0],
+                        end_col=node.end_point[1],
+                        severity=severity,
+                        code="throw-statement",
+                        message=_MESSAGES["throw-statement"],
+                        data=_DATA["throw-statement"],
+                    )
+                )
+
+        # Rule: catch-rethrow
+        severity = severity_from_config(config, "catch-rethrow")
+        if severity is not None:
+            for node in buckets["catch_clause"]:
+                if _is_in_bean_method(node):
+                    continue
+                body = node.child_by_field_name("body")
+                if body is None:
+                    continue
+                statements = [c for c in body.named_children if c.type not in IGNORED_CHILDREN]
+                if len(statements) == 1 and statements[0].type == "throw_statement":
+                    diagnostics.append(
+                        Diagnostic(
+                            line=node.start_point[0],
+                            col=node.start_point[1],
+                            end_line=node.end_point[0],
+                            end_col=node.end_point[1],
+                            severity=severity,
+                            code="catch-rethrow",
+                            message=_MESSAGES["catch-rethrow"],
+                            data=_DATA["catch-rethrow"],
+                        )
+                    )
+
+        # Rule: try-catch-to-monadic
+        severity = severity_from_config(config, "try-catch-to-monadic", default=Severity.HINT)
+        if severity is not None:
+            for try_node in buckets["try_statement"]:
+                if _is_in_bean_method(try_node):
+                    continue
+                if not _matches_try_catch_monadic_shape(try_node):
+                    continue
+                # Position the diagnostic on the `try` keyword only (narrow range).
+                try_kw = next((c for c in try_node.children if c.type == "try"), try_node)
+                diagnostics.append(
+                    Diagnostic(
+                        line=try_kw.start_point[0],
+                        col=try_kw.start_point[1],
+                        end_line=try_kw.end_point[0],
+                        end_col=try_kw.end_point[1],
+                        severity=severity,
+                        code="try-catch-to-monadic",
+                        message=_MESSAGES["try-catch-to-monadic"],
+                        data=_DATA["try-catch-to-monadic"],
+                    )
+                )
+
+        return diagnostics

{java_functional_lsp-0.6.3 → java_functional_lsp-0.7.0}/src/java_functional_lsp/analyzers/functional_checker.py

@@ -130,6 +130,37 @@ _SIDE_EFFECT_METHODS = {
 _METHOD_SCOPES = {"method_declaration", "constructor_declaration", "lambda_expression"}
 
 
+def is_side_effect_invocation(invocation: Node) -> bool:
+    """Check if a method_invocation node is a side-effect call.
+
+    Recognizes patterns like:
+    - ``System.out.println(...)`` / ``System.err.println(...)``
+    - ``logger.info(...)`` / ``log.debug(...)`` / ``LOG.warn(...)``
+    - Bare side-effect method names (e.g. ``println(...)``)
+    """
+    obj_node = invocation.child_by_field_name("object")
+    method_name = invocation.child_by_field_name("name")
+    if method_name is None:
+        return False
+
+    if obj_node is not None:
+        # System.out.println / System.err.println
+        if obj_node.type == "field_access":
+            receiver = obj_node.child_by_field_name("object")
+            if receiver is not None and receiver.text in _SIDE_EFFECT_RECEIVERS:
+                return True
+        # logger.info, log.debug, etc.
+        if obj_node.type == "identifier" and obj_node.text in _SIDE_EFFECT_RECEIVERS:
+            if method_name.text in _SIDE_EFFECT_METHODS:
+                return True
+
+    # Standalone side-effect method names
+    if method_name.text in _SIDE_EFFECT_METHODS and obj_node is None:
+        return True
+
+    return False
+
+
 class FunctionalChecker:
     """Detects frozen mutation traps, imperative null checks, and impure methods."""
 
@@ -357,25 +388,10 @@ class FunctionalChecker:
 
     @staticmethod
     def _is_side_effect_invocation(invocation: Node) -> bool:
-        """Check if a method_invocation node is a side-effect call."""
-        obj_node = invocation.child_by_field_name("object")
-        method_name = invocation.child_by_field_name("name")
-        if method_name is None:
-            return False
-
-        if obj_node is not None:
-            # System.out.println / System.err.println
-            if obj_node.type == "field_access":
-                receiver = obj_node.child_by_field_name("object")
-                if receiver is not None and receiver.text in _SIDE_EFFECT_RECEIVERS:
-                    return True
-            # logger.info, log.debug, etc.
-            if obj_node.type == "identifier" and obj_node.text in _SIDE_EFFECT_RECEIVERS:
-                if method_name.text in _SIDE_EFFECT_METHODS:
-                    return True
-
-        # Standalone side-effect method names
-        if method_name.text in _SIDE_EFFECT_METHODS and obj_node is None:
-            return True
+        """Check if a method_invocation node is a side-effect call.
 
-        return False
+        Thin delegator kept for backward compatibility; the real logic lives in
+        the module-level ``is_side_effect_invocation`` so other modules (e.g.
+        ``fixes.py``) can reuse it without importing the class.
+        """
+        return is_side_effect_invocation(invocation)