java-functional-lsp 0.10.0__tar.gz → 0.11.0__tar.gz

{java_functional_lsp-0.10.0 → java_functional_lsp-0.11.0}/CONTRIBUTING.md

@@ -45,10 +45,12 @@ uv run pytest
 1. Choose the appropriate analyzer in `src/java_functional_lsp/analyzers/`
 2. Add the detection logic using tree-sitter node walking (see `base.py` helpers)
 3. Add the rule ID and message to the module's `_MESSAGES` dict
-4. Add a `DiagnosticData` entry to the module's `_DATA` dict with `fix_type`, `target_library`, and `rationale`
-5. Pass `data=_DATA["rule-id"]` when creating the `Diagnostic`
-6. Add tests in `tests/test_<analyzer>.py` (including a test verifying the `data` field)
-7. Optionally add a quick fix generator in `src/java_functional_lsp/fixes.py` and register it in `_FIX_REGISTRY` + add its title to `_FIX_TITLES` in `server.py` (an import-time assertion catches mismatches)
+4. Add a `DiagnosticData` entry to the module's `_DATA` dict with `fix_type`, `target_library`, and `rationale`. Where helpful for AI agents, also set:
+   - `recommended_api` — a library-agnostic API hint paired with `target_library` (e.g. `"forEach (NOT ifPresent — Vavr Option uses forEach)"`, `"@Value"`, `"Try.of(() -> ...).getOrElse(...)"`). Prevents agents from picking the wrong API surface.
+   - `suggested_snippet` — a concrete, paste-able snippet built per-instance from AST node text (real variable names, real return expressions). Pattern: define a `_build_<rule>_data(node)` helper that reads the AST and produces the snippet, then pass `data=_build_<rule>_data(node)` instead of `data=_DATA["rule-id"]`. Leave the field `None` rather than fabricating a misleading placeholder when the AST shape isn't trivially templatable.
+5. Pass `data=_DATA["rule-id"]` (or the builder result) when creating the `Diagnostic`
+6. Add tests in `tests/test_<analyzer>.py` (including a test verifying the `data` field — both `fix_type` and, when set, `recommended_api` / `suggested_snippet` with real AST-derived text)
+7. Optionally add a quick fix generator in `src/java_functional_lsp/fixes.py` and register it in `_FIX_REGISTRY` + add its title to `_FIX_TITLES` in `server.py` (an import-time assertion catches mismatches). Skip the registry if the rewrite needs class-wide analysis you can't safely automate; the diagnostic + `suggested_snippet` are usually enough for an AI agent to apply the change.
 8. Update the rules table in `README.md`
 
 ## Test Architecture

{java_functional_lsp-0.10.0 → java_functional_lsp-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: java-functional-lsp
-Version: 0.10.0
+Version: 0.11.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.10.0 → java_functional_lsp-0.11.0}/editors/vscode/package-lock.json

@@ -2094,9 +2094,9 @@
       }
     },
     "node_modules/fast-uri": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.0.tgz",
-      "integrity": "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==",
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.2.tgz",
+      "integrity": "sha512-rVjf7ArG3LTk+FS6Yw81V1DLuZl1bRbNrev6Tmd/9RaroeeRRJhAt7jg/6YFxbvAQXUCavSoZhPPj6oOx+5KjQ==",
       "dev": true,
       "funding": [
         {

{java_functional_lsp-0.10.0 → java_functional_lsp-0.11.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "java-functional-lsp"
-version = "0.10.0"
+version = "0.11.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.11.0/src/java_functional_lsp/analyzers/__init__.py

@@ -0,0 +1,29 @@
+"""Java code quality analyzers using tree-sitter.
+
+This module exposes ``KNOWN_RULES`` — the union of every rule code emitted by any analyzer
+in this package. The server uses it as a guardrail: ``_FIX_TITLES`` keys must be a subset of
+``KNOWN_RULES`` so a typo in a fix registration is caught at import time rather than as a
+silently-missing code action at runtime.
+"""
+
+from __future__ import annotations
+
+from .exception_checker import _MESSAGES as _EXCEPTION_MESSAGES
+from .functional_checker import _MESSAGES as _FUNCTIONAL_MESSAGES
+from .mutation_checker import _MESSAGES as _MUTATION_MESSAGES
+from .null_checker import _MESSAGES as _NULL_MESSAGES
+from .spring_checker import _MESSAGES as _SPRING_MESSAGES
+
+# ``impure-method-io`` / ``impure-method-throw`` are internal data-payload keys; the rule
+# code emitted on the wire is ``impure-method`` regardless of variant, so we register only
+# the wire-visible name here.
+_IMPURE_METHOD_INTERNAL_KEYS = {"impure-method-io", "impure-method-throw"}
+
+_ALL_MESSAGE_KEYS: set[str] = (
+    set(_FUNCTIONAL_MESSAGES.keys())
+    | set(_MUTATION_MESSAGES.keys())
+    | set(_EXCEPTION_MESSAGES.keys())
+    | set(_SPRING_MESSAGES.keys())
+    | set(_NULL_MESSAGES.keys())
+)
+KNOWN_RULES: frozenset[str] = frozenset((_ALL_MESSAGE_KEYS - _IMPURE_METHOD_INTERNAL_KEYS) | {"impure-method"})

{java_functional_lsp-0.10.0 → java_functional_lsp-0.11.0}/src/java_functional_lsp/analyzers/base.py

@@ -26,6 +26,14 @@ class DiagnosticData:
     fix_type: str  # e.g. "REPLACE_WITH_VAVR_LIST", "WRAP_IN_OPTION"
     target_library: str  # e.g. "io.vavr.collection.List"
     rationale: str  # human+machine readable explanation
+    # Library-agnostic API hint that pairs with target_library. Examples:
+    # "forEach (NOT ifPresent — Vavr Option)", "@Value", "Try.of(...).getOrElse(...)".
+    # Lets agents pick the right method without re-reading docs.
+    recommended_api: str | None = None
+    # Concrete fix snippet built from the offending AST node — uses real variable
+    # names so an agent can paste it directly. None when the shape is too complex
+    # to synthesise safely.
+    suggested_snippet: str | None = None
 
 
 @dataclass(frozen=True)

{java_functional_lsp-0.10.0 → java_functional_lsp-0.11.0}/src/java_functional_lsp/analyzers/exception_checker.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import dataclasses
 from typing import Any
 
 from .base import (
@@ -30,6 +31,7 @@ _DATA = {
             "Throwing exceptions breaks referential transparency."
             " Use Either.left(error) to represent failures as values."
         ),
+        recommended_api="Either.left(...) / Try.failure(...)",
     ),
     "catch-rethrow": DiagnosticData(
         fix_type="USE_TRY_TO_EITHER",
@@ -37,6 +39,7 @@ _DATA = {
         rationale=(
             "Catching and rethrowing adds noise. Use Try.of(() -> ...).toEither() to convert exceptions to values."
         ),
+        recommended_api="Try.of(() -> ...).toEither()",
     ),
     "try-catch-to-monadic": DiagnosticData(
         fix_type="WRAP_IN_TRY",
@@ -45,10 +48,69 @@ _DATA = {
             "try/catch mixes control flow with value handling."
             " Use Try.of(...) for composable, value-based failure handling."
         ),
+        recommended_api="Try.of(() -> ...).getOrElse(...) / .recover(Type.class, e -> ...).get()",
     ),
 }
 
 
+def _build_throw_statement_data(throw_node: Any) -> DiagnosticData:
+    """Build a DiagnosticData with a concrete ``Either.left(...)`` snippet.
+
+    Reads the throw expression from the first non-comment named child. tree-sitter-java
+    doesn't expose a field name for `throw_statement`'s expression, so we filter
+    `named_children` to skip comments and take the first remaining node.
+
+    We commit to ``Either.left`` here (rather than offering both ``Either.left`` and
+    ``Try.failure`` in a comment) so the snippet is paste-able without manual cleanup;
+    the `recommended_api` mentions both alternatives.
+    """
+    base = _DATA["throw-statement"]
+    expr_text = "error"
+    for child in throw_node.named_children:
+        if child.type in IGNORED_CHILDREN:
+            continue
+        if child.text:
+            expr_text = child.text.decode("utf-8")
+        break
+    snippet = f"return Either.left({expr_text});"
+    return dataclasses.replace(base, suggested_snippet=snippet)
+
+
+def _extract_return_expr(block_node: Any) -> str | None:
+    """Return the text of the (last) return-statement expression in a block, or None."""
+    if block_node is None:
+        return None
+    stmts = [c for c in block_node.named_children if c.type not in IGNORED_CHILDREN]
+    if not stmts or stmts[-1].type != "return_statement":
+        return None
+    ret_children = [c for c in stmts[-1].named_children if c.type not in IGNORED_CHILDREN]
+    if not ret_children or not ret_children[0].text:
+        return None
+    decoded: str = ret_children[0].text.decode("utf-8")
+    return decoded
+
+
+def _build_try_catch_to_monadic_data(try_node: Any) -> DiagnosticData:
+    """Build a DiagnosticData with a Try.of(...).getOrElse(...) snippet drawn from the AST.
+
+    Best-effort: when the try/catch shape isn't a clean single-return-each pair, the
+    base data is returned without a snippet rather than synthesising garbage.
+    """
+    base = _DATA["try-catch-to-monadic"]
+    body = try_node.child_by_field_name("body")
+    catches = [c for c in try_node.children if c.type == "catch_clause"]
+    if body is None or not catches:
+        return base
+
+    try_expr = _extract_return_expr(body)
+    catch_expr = _extract_return_expr(catches[0].child_by_field_name("body"))
+    if try_expr is None or catch_expr is None:
+        return base
+
+    snippet = f"return Try.of(() -> {try_expr}).getOrElse({catch_expr});"
+    return dataclasses.replace(base, suggested_snippet=snippet)
+
+
 def _is_in_bean_method(node: Any) -> bool:
     """Check if node is inside a method annotated with @Bean."""
     parent = node.parent
@@ -164,7 +226,7 @@ class ExceptionChecker:
                         severity=severity,
                         code="throw-statement",
                         message=_MESSAGES["throw-statement"],
-                        data=_DATA["throw-statement"],
+                        data=_build_throw_statement_data(node),
                     )
                 )
 
@@ -211,7 +273,7 @@ class ExceptionChecker:
                         severity=severity,
                         code="try-catch-to-monadic",
                         message=_MESSAGES["try-catch-to-monadic"],
-                        data=_DATA["try-catch-to-monadic"],
+                        data=_build_try_catch_to_monadic_data(try_node),
                     )
                 )
 

{java_functional_lsp-0.10.0 → java_functional_lsp-0.11.0}/src/java_functional_lsp/analyzers/functional_checker.py

@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 
-from typing import Any
+import dataclasses
+import re
+from typing import Any, Literal
 
 from tree_sitter import Node, Tree
 
@@ -22,10 +24,14 @@ _MESSAGES = {
         "Use io.vavr.collection.List for safe persistent immutability."
     ),
     "null-check-to-monadic": ("Imperative null handling: Consider monadic flow with Option.of().map().getOrElse()."),
-    "impure-method": (
+    "impure-method-io": (
         "Hidden side-effect: Method mixes pure logic with IO/state mutations. "
         "Extract pure logic to a separate method; wrap side-effects in Try."
     ),
+    "impure-method-throw": (
+        "Hidden side-effect: Method mixes pure logic with exceptions. "
+        "Extract pure logic; return Either.left(...) or Try.failure(...) instead of throwing."
+    ),
 }
 
 _DATA = {
@@ -36,6 +42,7 @@ _DATA = {
             "Runtime mutation of List.of() causes UnsupportedOperationException. "
             "Use Vavr for safe, persistent immutability."
         ),
+        recommended_api=".append / .appendAll / .update / .remove (returns a new persistent collection)",
     ),
     "null-check-to-monadic": DiagnosticData(
         fix_type="WRAP_IN_OPTION_MAP",
@@ -44,17 +51,147 @@ _DATA = {
             "Imperative null checks create nested branching. "
             "Use Option.of().map() for composable, null-safe monadic flow."
         ),
+        recommended_api="Option.of(...).map(...).getOrElse(...)",
     ),
-    "impure-method": DiagnosticData(
-        fix_type="EXTRACT_PURE_LOGIC",
+    # impure-method has two variants (IO and throw) that share the rule code "impure-method"
+    # but carry distinct fix_type values so AI agents can filter on the variant without
+    # parsing target_library or message text. Splitting the rule code itself would break
+    # existing user severity-overrides like `rules: { "impure-method": "off" }`.
+    "impure-method-io": DiagnosticData(
+        fix_type="EXTRACT_PURE_LOGIC_IO",
         target_library="io.vavr.control.Try",
         rationale=(
-            "Mixing pure logic with side-effects breaks referential transparency. "
+            "Mixing pure logic with IO/state mutations breaks referential transparency. "
             "Extract pure logic; wrap IO/state mutations in Try."
         ),
+        recommended_api="Try.of(() -> sideEffect()).onFailure(...)",
+    ),
+    "impure-method-throw": DiagnosticData(
+        fix_type="EXTRACT_PURE_LOGIC_THROW",
+        target_library="io.vavr.control.Either",
+        rationale=(
+            "Mixing pure logic with exceptions breaks referential transparency. "
+            "Extract pure logic; return Either.left(...) or Try.failure(...) instead of throwing."
+        ),
+        recommended_api="Either.left(...) / Try.of(() -> ...)",
     ),
 }
 
+
+def _build_null_check_to_monadic_data(
+    var_name: bytes, consequence: Node | None, alternative: Node | None, if_node: Node | None = None
+) -> DiagnosticData:
+    """Build an Option snippet using the real var name + real return expressions.
+
+    Inspects the if-then return expression (the body of ``if (x != null) return X.something();``)
+    and rewrites references to ``var_name`` as ``it`` in a ``.map(it -> ...)`` lambda. The else
+    branch's return expression — either nested in the if as an alternative or following the if
+    as a fallthrough — becomes the ``.getOrElse(...)`` argument. Falls back to the base data
+    (no snippet) when the then-branch isn't a single return.
+    """
+    base = _DATA["null-check-to-monadic"]
+    if not var_name:
+        return base
+    var = var_name.decode("utf-8")
+
+    then_expr = _single_return_expr_text(consequence)
+    if then_expr is None:
+        return base
+    # Rewrite references to the checked variable as `it` in the lambda body. Use a word-boundary
+    # regex so a short var name like `s` doesn't match `s.toString()` inside another identifier.
+    # Skip the map when the body is exactly the variable itself (identity case).
+    if then_expr == var:
+        chain_body = f"Option.of({var})"
+    else:
+        lambda_body = re.sub(rf"\b{re.escape(var)}\b", "it", then_expr)
+        chain_body = f"Option.of({var}).map(it -> {lambda_body})"
+
+    # Prefer the nested else-branch; otherwise look at the statement immediately following the if
+    # (a common fallthrough pattern: `if (x != null) return ...; return fallback;`).
+    else_expr = _single_return_expr_text(alternative)
+    if else_expr is None and if_node is not None:
+        else_expr = _next_statement_return_expr(if_node)
+
+    if else_expr is None or else_expr == "null":
+        # No else (or else returns null) — return Option<T> directly; don't fabricate a default.
+        snippet = f"return {chain_body};"
+    else:
+        snippet = f"return {chain_body}.getOrElse({else_expr});"
+
+    return dataclasses.replace(base, suggested_snippet=snippet)
+
+
+def _next_statement_return_expr(if_node: Node) -> str | None:
+    """If the statement immediately after ``if_node`` (in its enclosing block) is a single
+    `return <expr>;`, return that expression's text. Otherwise None."""
+    parent = if_node.parent
+    if parent is None or parent.type != "block":
+        return None
+    siblings = [c for c in parent.named_children if c.type not in ("line_comment", "block_comment")]
+    try:
+        idx = siblings.index(if_node)
+    except ValueError:
+        return None
+    if idx + 1 >= len(siblings):
+        return None
+    next_stmt = siblings[idx + 1]
+    return _single_return_expr_text(next_stmt)
+
+
+def _single_return_expr_text(block_or_stmt: Node | None) -> str | None:
+    """Return the text of a single ``return <expr>;`` statement in a block (or the statement
+    itself). Returns None for anything else (multiple statements, no return, bare return)."""
+    if block_or_stmt is None:
+        return None
+    if block_or_stmt.type == "block":
+        stmts = [c for c in block_or_stmt.named_children if c.type not in ("line_comment", "block_comment")]
+    else:
+        stmts = [block_or_stmt]
+    if len(stmts) != 1 or stmts[0].type != "return_statement":
+        return None
+    ret_children = [c for c in stmts[0].named_children if c.type not in ("line_comment", "block_comment")]
+    if not ret_children or not ret_children[0].text:
+        return None
+    decoded: str = ret_children[0].text.decode("utf-8")
+    return decoded
+
+
+# Module-scope so it's allocated once at import rather than per diagnostic.
+_VAVR_MUTATION_METHODS: dict[bytes, str] = {
+    b"add": "append",
+    b"addAll": "appendAll",
+    b"remove": "remove",
+    b"set": "update",
+    b"sort": "sorted",
+}
+
+# Identifier syntax: bare identifiers only (not `this.x`, `foo.bar()`, etc.) — used to gate
+# whether the assignment-style snippet `x = x.append(...)` is safe to suggest.
+_PLAIN_IDENTIFIER_RE = re.compile(r"^[A-Za-z_$][A-Za-z0-9_$]*$")
+
+
+def _build_frozen_mutation_data(method_name: bytes, var_name: bytes) -> DiagnosticData:
+    """Build a Vavr-persistent snippet using the real var name and migration hint.
+
+    Returns the base data (no snippet) when ``var_name`` is anything other than a plain
+    identifier — chained LHS like ``foo.getList()`` or ``this.items`` would produce invalid
+    Java if used as the left-hand side of an assignment.
+    """
+    base = _DATA["frozen-mutation"]
+    decoded_var = var_name.decode("utf-8") if var_name else ""
+    if not _PLAIN_IDENTIFIER_RE.match(decoded_var):
+        return base
+    vavr_method = _VAVR_MUTATION_METHODS.get(method_name, "append") if method_name else "append"
+    # Spell out that the *variable's type* must move to Vavr — pasting the assignment alone
+    # won't compile when the variable is still a java.util.List.
+    snippet = (
+        f"// Migrate `{decoded_var}` to io.vavr.collection.List:\n"
+        f"io.vavr.collection.List<...> {decoded_var} = io.vavr.collection.List.ofAll(...);\n"
+        f"{decoded_var} = {decoded_var}.{vavr_method}(...);  // returns a new persistent collection"
+    )
+    return dataclasses.replace(base, suggested_snippet=snippet)
+
+
 # Factory methods that produce frozen (unmodifiable) collections
 _FROZEN_FACTORIES = {
     b"of",  # List.of(), Set.of(), Map.of()
@@ -211,7 +348,10 @@ class FunctionalChecker:
                             severity=severity,
                             code="frozen-mutation",
                             message=_MESSAGES["frozen-mutation"],
-                            data=_DATA["frozen-mutation"],
+                            data=_build_frozen_mutation_data(
+                                method_name.text or b"",
+                                obj_node.text or b"",
+                            ),
                         )
                     )
 
@@ -288,7 +428,12 @@ class FunctionalChecker:
                     severity=severity,
                     code="null-check-to-monadic",
                     message=_MESSAGES["null-check-to-monadic"],
-                    data=_DATA["null-check-to-monadic"],
+                    data=_build_null_check_to_monadic_data(
+                        checked_var,
+                        consequence,
+                        if_node.child_by_field_name("alternative"),
+                        if_node,
+                    ),
                 )
             )
 
@@ -320,7 +465,13 @@ class FunctionalChecker:
         return False
 
     def _check_impure_method(self, tree: Tree, diagnostics: list[Diagnostic], config: dict[str, Any]) -> None:
-        """Detect methods mixing pure logic with side-effects."""
+        """Detect methods mixing pure logic with side-effects.
+
+        Points the diagnostic at the first offending statement (throw or IO call) rather
+        than the method declaration, so the user immediately sees what to extract.
+        The message + data payload differ based on whether the side-effect is a throw
+        or an IO call — agents need to suggest the right Vavr type (Either vs Try).
+        """
         default = Severity.WARNING if config.get("strictPurity", False) else Severity.HINT
         severity = severity_from_config(config, "impure-method", default=default)
         if severity is None:
@@ -331,41 +482,66 @@ class FunctionalChecker:
             if body is None:
                 continue
 
-            has_side_effect = False
-            has_pure_logic = False
-
             statements = [c for c in body.named_children if c.type not in ("line_comment", "block_comment")]
             if len(statements) < 2:  # noqa: PLR2004
                 continue  # Need at least 2 statements to have a mix
 
+            offender: Node | None = None
+            offender_kind: Literal["throw", "io"] | None = None
+            has_pure_logic = False
+
             for stmt in statements:
-                if self._is_side_effect_statement(stmt):
-                    has_side_effect = True
-                else:
+                kind, node = self._classify_side_effect(stmt)
+                if kind is None:
                     has_pure_logic = True
+                elif offender is None:
+                    offender = node
+                    offender_kind = kind
 
-            if has_side_effect and has_pure_logic:
-                name_node = method.child_by_field_name("name")
-                if name_node is None:
-                    continue
-                diagnostics.append(
-                    Diagnostic(
-                        line=name_node.start_point[0],
-                        col=name_node.start_point[1],
-                        end_line=name_node.end_point[0],
-                        end_col=name_node.end_point[1],
-                        severity=severity,
-                        code="impure-method",
-                        message=_MESSAGES["impure-method"],
-                        data=_DATA["impure-method"],
-                    )
+            if offender is None or not has_pure_logic:
+                continue
+
+            name_node = method.child_by_field_name("name")
+            # Range = the offending statement itself, not the method declaration.
+            range_node = offender if offender is not None else name_node
+            if range_node is None:
+                continue
+
+            if offender_kind == "throw":
+                message = _MESSAGES["impure-method-throw"]
+                data = _DATA["impure-method-throw"]
+            else:
+                message = _MESSAGES["impure-method-io"]
+                data = _DATA["impure-method-io"]
+
+            diagnostics.append(
+                Diagnostic(
+                    line=range_node.start_point[0],
+                    col=range_node.start_point[1],
+                    end_line=range_node.end_point[0],
+                    end_col=range_node.end_point[1],
+                    severity=severity,
+                    code="impure-method",
+                    message=message,
+                    data=data,
                 )
+            )
+
+    def _classify_side_effect(self, stmt: Node) -> tuple[Literal["throw", "io"] | None, Node | None]:
+        """Find the first side-effect node within a statement subtree.
+
+        Returns (kind, node) where kind is "throw", "io", or None (if the statement
+        contains no side-effects). The node is the offending throw_statement or
+        method_invocation — used to position the diagnostic. The Literal annotation
+        catches typos in the discriminator at type-check time.
 
-    def _is_side_effect_statement(self, stmt: Node) -> bool:
-        """Check if a statement contains side-effect calls or throw statements.
+        Single TreeCursor traversal to detect both throws and IO calls in one pass.
 
-        Single TreeCursor traversal to detect both method_invocation side-effects
-        and throw_statement nodes (avoids two separate find_nodes walks).
+        Note: When a single statement contains *both* a throw and an IO call (rare —
+        e.g. ``log(x); throw new …;`` collapsed onto one line), the kind chosen reflects
+        AST traversal order rather than a semantic precedence. In practice the diagnostic
+        is still actionable because both side-effects need extracting; the choice only
+        affects which message variant fires.
         """
         cursor = stmt.walk()
         visited_children = False
@@ -374,24 +550,13 @@ class FunctionalChecker:
                 current: Node | None = cursor.node
                 if current is not None:
                     if current.type == "throw_statement":
-                        return True
-                    if current.type == "method_invocation":
-                        if self._is_side_effect_invocation(current):
-                            return True
+                        return "throw", current
+                    if current.type == "method_invocation" and is_side_effect_invocation(current):
+                        return "io", 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 False
-
-    @staticmethod
-    def _is_side_effect_invocation(invocation: Node) -> bool:
-        """Check if a method_invocation node is a side-effect call.
-
-        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)
+        return None, None