adl-toolkit 0.0.0-stage → 0.1.1

package/adl_drift/lang/java/resolution/scopes.py

@@ -0,0 +1,1111 @@
+"""Lexical scope collection and local type propagation for Java calls."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from adl_drift.graph.node import NodeType
+from adl_drift.lang.java.ids import erased_type
+from adl_drift.lang.java.resolution.constants import (
+    JAVA_OPTIONAL_ELEMENT_LAMBDA_METHODS,
+    JAVA_STREAM_ELEMENT_LAMBDA_METHODS,
+    _ENCLOSING_TYPE_CST_TYPES,
+    _METHOD_CST_TYPES,
+    _MOCK_ALLOCATION_TYPE,
+    _NESTED_SCOPE_BOUNDARY,
+    argument_nodes,
+)
+from adl_drift.lang.java.resolution.model import (
+    ImportContext as _ImportContext,
+    LocalScopes as _LocalScopes,
+)
+
+_PRIMITIVE_STREAM_ELEMENT = {"IntStream": "int", "LongStream": "long", "DoubleStream": "double"}
+
+class ScopeInferenceMixin:
+    @staticmethod
+    def _enclosing_scope_end(node, scope_types: Tuple[str, ...], fallback: int) -> int:
+        """End byte of the nearest ancestor of `node` whose type is in
+        `scope_types` — the byte offset a declaration made in that scope stops
+        being visible at. `fallback` (the method body's end) is used if no such
+        ancestor is found."""
+        cur = node.parent
+        while cur is not None:
+            if cur.type in scope_types:
+                return cur.end_byte
+            cur = cur.parent
+        return fallback
+
+    @staticmethod
+    def _enclosing_scope_start(node, scope_types: Tuple[str, ...], fallback: int) -> int:
+        cur = node.parent
+        while cur is not None:
+            if cur.type in scope_types:
+                return cur.start_byte
+            cur = cur.parent
+        return fallback
+
+    def _build_field_allocation_index(
+        self, parses: Dict[Path, ParseResult],
+        func_id_by_position: Dict[Tuple[str, int, int], str],
+        class_id_by_position: Dict[Tuple[str, int, int], str],
+    ) -> Dict[str, Dict[str, str]]:
+        """Return exact field types only when all own-class assignments agree."""
+        evidence: Dict[Tuple[str, str], Set[str]] = defaultdict(set)
+        invalid: Set[Tuple[str, str]] = set()
+        for file_path, parse in parses.items():
+            ctx = self._file_ctx.get(str(file_path))
+            if ctx is None:
+                continue
+            source = parse.source_bytes
+            # A field's own declaration-site initializer (`Type field =
+            # mock();`), as opposed to a later `this.field = ...`
+            # assignment inside a method body (the only shape the walk
+            # below covers). Scoped to the Mockito `mock()`/`spy()` sentinel
+            # only — not a general declaration-site allocation pass — since
+            # that is the one fact this index needs to support
+            # (`_abstract_fan_out`'s mock/spy fan-out suppression, P5
+            # finding #2); a general `Type field = new Impl();` pass would
+            # be a separate, broader enhancement.
+            for node in self._field_declarations(parse.tree.root_node, str(file_path)):
+                owner_node = node.parent
+                while owner_node is not None and owner_node.type not in _ENCLOSING_TYPE_CST_TYPES:
+                    owner_node = owner_node.parent
+                if owner_node is None:
+                    continue
+                owner_id = class_id_by_position.get(
+                    (str(file_path), owner_node.start_point[0] + 1, owner_node.start_point[1]),
+                )
+                if owner_id is None:
+                    continue
+                for declarator in [c for c in node.children if c.type == "variable_declarator"]:
+                    name_node = declarator.child_by_field_name("name")
+                    value_node = declarator.child_by_field_name("value")
+                    if (
+                        name_node is not None and value_node is not None
+                        and self._is_mockito_factory_call(value_node, source)
+                    ):
+                        key = (owner_id, self._text(name_node, source))
+                        if key not in invalid:
+                            evidence[key].add(_MOCK_ALLOCATION_TYPE)
+            for func_cst, caller_id in self._iter_method_cst(
+                parse.tree.root_node, str(file_path), func_id_by_position,
+            ):
+                class_id = self._declaring_class_id(caller_id)
+                body = func_cst.child_by_field_name("body")
+                if class_id is None or body is None:
+                    continue
+                field_types = self._all_field_types(class_id)
+                local_types = self._collect_local_scopes(body, source)
+                param_types = dict(zip(
+                    self._param_names(func_cst, source),
+                    self._param_type_lists.get(caller_id, []),
+                ))
+                type_bounds = self._collect_type_param_bounds(func_cst, source)
+                # Assignment facts already exclude nested method/type bodies,
+                # exactly as the former per-method walk did.
+                for node in self._method_facts(body).assignment_expressions:
+                    if node.type == "assignment_expression":
+                        children = [c for c in node.children if not c.is_extra]
+                        if len(children) >= 3 and children[1].type == "=":
+                            lhs, rhs = children[0], children[2]
+                            field_name = self._this_field_name(lhs, source)
+                            if lhs.type == "identifier":
+                                candidate = self._text(lhs, source)
+                                if (
+                                    candidate in field_types
+                                    and candidate not in param_types
+                                    and local_types.type_at(candidate, lhs.start_byte) is None
+                                ):
+                                    field_name = candidate
+                            if field_name in field_types:
+                                type_text: Optional[str] = None
+                                if rhs.type == "object_creation_expression":
+                                    type_text = self._var_initializer_type(rhs, source)
+                                elif rhs.type == "method_invocation":
+                                    type_text = self._generic_method_invocation_return_type(
+                                        rhs, source, ctx.module, class_id,
+                                        ctx.import_map, ctx.wildcard_packages,
+                                        local_types, field_types, param_types, type_bounds,
+                                    )
+                                key = (class_id, field_name)
+                                allocation_id = (
+                                    self._resolve_declared_type(
+                                        type_text, ctx.module, ctx.import_map,
+                                        ctx.wildcard_packages, class_id,
+                                    )
+                                    if type_text is not None else None
+                                )
+                                if allocation_id is None or not self._is_concrete_class(allocation_id):
+                                    invalid.add(key)
+                                else:
+                                    evidence[key].add(allocation_id)
+        out: Dict[str, Dict[str, str]] = defaultdict(dict)
+        for (class_id, field_name), allocation_ids in evidence.items():
+            if (class_id, field_name) not in invalid and len(allocation_ids) == 1:
+                out[class_id][field_name] = next(iter(allocation_ids))
+        return dict(out)
+
+    def _collect_local_scopes(
+        self, body, source: bytes, *, field_types: Optional[Dict[str, str]] = None,
+        param_types: Optional[Dict[str, str]] = None,
+    ) -> "_LocalScopes":
+        # Three index-building passes ask for the plain (no field/param
+        # types) scopes of every method body and only read the result; the
+        # call-site pass asks with types and then mutates its copy (lambda
+        # params, var inference) — so only the plain form is memoized, per
+        # run, keyed on the source buffer and the body node (`Node.id` is
+        # unique within a tree, `source_bytes` lives as long as the parse).
+        if field_types is None and param_types is None:
+            cache = self._local_scopes_cache
+            if cache is not None:
+                key = (id(source), body.id)
+                hit = cache.get(key)
+                if hit is None:
+                    hit = cache[key] = self._collect_local_scopes_uncached(body, source)
+                return hit
+        return self._collect_local_scopes_uncached(
+            body, source, field_types=field_types, param_types=param_types,
+        )
+
+    def _collect_local_scopes_uncached(
+        self, body, source: bytes, *, field_types: Optional[Dict[str, str]] = None,
+        param_types: Optional[Dict[str, str]] = None,
+    ) -> "_LocalScopes":
+        """Lexically-scoped local-variable types for `body` (see
+        `_LocalScopes`). Covers, besides the plain `local_variable_declaration`
+        (scoped to its enclosing `block` — or, when the declaration is a
+        classic `for (Type v = ...; ...; ...) { ... }` loop's init clause, to
+        the enclosing `for_statement` instead: that declaration's direct
+        parent is the `for_statement`, not a `block`, so without this case
+        `_enclosing_scope_end` would keep climbing to whatever `block`
+        *contains* the loop — often the whole method body — silently
+        extending `v`'s visibility past the loop's closing brace and letting
+        it shadow a same-named field/parameter used afterward; C-01 fix,
+        `enhanced_for_statement`/`resource`/`catch_formal_parameter` below
+        never had this gap since each already names its own enclosing
+        statement type as the boundary), the three other statement forms
+        that introduce a *typed* local by declaration:
+        `enhanced_for_statement`'s loop variable (`for (User u : users)`,
+        scoped to the loop *body* only — not the iterable expression, per
+        JLS 14.14.2; a receiver in `users` there still resolves against the
+        enclosing scope, e.g. a same-named field), `catch_formal_parameter`'s exception
+        variable (`catch (Ex e)`, scoped to its `catch_clause`), and a
+        try-with-resources `resource`'s variable (`try (Res r = open())`,
+        scoped to its `try_statement`) — each declares its type inline exactly
+        like a local var (P4.4 recall fix). A multi-catch (`catch (A | B e)`)
+        takes its *first* alternative's type (best-effort: the exact effective
+        type is the alternatives' least upper bound, which this resolver has
+        no JDK hierarchy to compute — a method on the first alternative still
+        resolves, the same precision-first approximation used elsewhere here).
+        A resource that reuses an already-declared variable (`try (existing)`,
+        no inline type) declares nothing new and is skipped."""
+        scopes = _LocalScopes()
+        field_types = field_types or {}
+        param_types = param_types or {}
+        body_end = body.end_byte
+        facts = self._method_facts(body)
+        assignments: Dict[str, List[Tuple[int, Optional[str], int]]] = defaultdict(list)
+        for assignment in facts.assignment_expressions:
+            children = [c for c in assignment.children if not c.is_extra]
+            if len(children) >= 3 and children[1].type == "=":
+                lhs = children[0]
+                if lhs.type == "identifier":
+                    statement = assignment.parent
+                    direct_scope = statement.parent if statement is not None else None
+                    # Only a direct statement in one lexical scope creates
+                    # a linear exact-allocation interval. Assignments under
+                    # branch/loop nodes remain conservative.
+                    if (
+                        statement is not None
+                        and statement.type == "expression_statement"
+                        and direct_scope is not None
+                        and direct_scope.type in ("block", "for_statement", "switch_block")
+                    ):
+                        rhs = children[2]
+                        allocation_type = (
+                            self._var_initializer_type(rhs, source)
+                            if rhs.type == "object_creation_expression" else None
+                        )
+                        assignments[self._text(lhs, source)].append(
+                            (assignment.start_byte, allocation_type, direct_scope.start_byte)
+                        )
+        for node in facts.local_scope_nodes:
+            if node.type == "local_variable_declaration":
+                type_node = node.child_by_field_name("type")
+                if type_node is not None:
+                    declared_type_text = self._text(type_node, source)
+                    # S-01 fix: `"switch_block"` added to the boundary set —
+                    # a `local_variable_declaration` written directly inside a
+                    # colon-style `switch` case (`case 1: Item cursor = ...;`)
+                    # is a child of `switch_block_statement_group`, not of a
+                    # `block`, so without this the search climbed straight
+                    # past the whole `switch` to whatever `block` contains
+                    # it (often the entire method body), letting the
+                    # case-local's declared type silently leak into, and
+                    # shadow same-named receivers used in, code that runs
+                    # after the switch closes. `switch_block` (not the
+                    # narrower `switch_block_statement_group`) is used
+                    # deliberately: per JLS 6.3 a switch-block-scoped local's
+                    # scope runs to the end of the *whole* switch block, not
+                    # just its own case group, so a same-named receiver in a
+                    # later case reached via fallthrough (no `break`) must
+                    # still see it.
+                    scope_end = self._enclosing_scope_end(
+                        node, ("block", "for_statement", "switch_block"), body_end,
+                    )
+                    scope_start = self._enclosing_scope_start(
+                        node, ("block", "for_statement", "switch_block"), body.start_byte,
+                    )
+                    for child in node.children:
+                        if child.type != "variable_declarator":
+                            continue
+                        name_node = child.child_by_field_name("name")
+                        if name_node is None:
+                            continue
+                        name = self._text(name_node, source)
+                        assignment_events = sorted(
+                            (
+                                (offset, allocation_type)
+                                for offset, allocation_type, assignment_scope_start
+                                in assignments.get(name, ())
+                                if (
+                                    child.end_byte < offset <= scope_end
+                                    and assignment_scope_start == scope_start
+                                )
+                            ),
+                            key=lambda event: event[0],
+                        )
+                        type_text = declared_type_text
+                        value_node = child.child_by_field_name("value")
+                        if type_text == "var":
+                            # V-01 fix: JLS 14.4 local-variable type
+                            # inference (`var x = ...;`). tree-sitter-java
+                            # parses `var` as an ordinary `type_identifier`
+                            # (its text is literally `"var"`), indistinguishable
+                            # at the grammar level from a real type name in
+                            # that position — without this branch,
+                            # `_resolve_declared_type("var", ...)` always
+                            # failed (no project class is ever legally named
+                            # `var`, a reserved type name per JLS 3.9), so
+                            # every `var`-typed receiver silently dropped its
+                            # CALLS edges. Best-effort only, mirroring the
+                            # exact two initializer forms `_infer_arg_type`
+                            # already reads a type off of directly
+                            # (`new Foo()` / `(Foo) x`) — a `var` initialized
+                            # from a method call, literal, or other
+                            # expression stays unresolved rather than
+                            # guessed, same "missing edge over wrong edge"
+                            # stance as everywhere else in this file. `var`
+                            # in an `enhanced_for_statement` header
+                            # (`for (var x : list)`) or a try-with-resources
+                            # `resource` is a separate, harder case — the
+                            # element/resource type there would need the
+                            # iterable/resource expression's own generic
+                            # argument, not just an initializer's own type
+                            # token — and is deliberately left as a known,
+                            # documented gap, not folded into this fix.
+                            type_text = self._var_initializer_type(
+                                value_node, source, scopes, param_types, field_types,
+                            )
+                            # A bare field is another exact, bounded source
+                            # of a `var` declaration's type: `var alias =
+                            # gateway`.  A same-named parameter shadows the
+                            # field, and is itself an exact alias source.
+                            if (
+                                type_text is None
+                                and value_node is not None
+                                and value_node.type == "identifier"
+                            ):
+                                initializer_name = self._text(value_node, source)
+                                type_text = (
+                                    param_types.get(initializer_name)
+                                    or field_types.get(initializer_name)
+                                )
+                            if type_text is None:
+                                # Type stays unknown ("missing edge over wrong
+                                # edge") but the name is still a genuine local
+                                # declaration in this scope — record it apart
+                                # from `add()` so shadow checks that only need
+                                # "is this name locally declared here" (not
+                                # its type) still see it.
+                                scopes.add_declared(name, node.start_byte, scope_end)
+                                continue
+                        elif value_node is not None and value_node.type == "object_creation_expression":
+                            allocation_type = self._var_initializer_type(value_node, source)
+                            if allocation_type is not None:
+                                first_reassignment = next(
+                                    (offset for offset, _ in assignment_events),
+                                    None,
+                                )
+                                scopes.add_allocation(
+                                    name, allocation_type, node.start_byte,
+                                    first_reassignment - 1
+                                    if first_reassignment is not None else scope_end,
+                                )
+                        elif value_node is not None and self._is_mockito_factory_call(value_node, source):
+                            first_reassignment = next(
+                                (offset for offset, _ in assignment_events),
+                                None,
+                            )
+                            scopes.add_allocation(
+                                name, _MOCK_ALLOCATION_TYPE, node.start_byte,
+                                first_reassignment - 1
+                                if first_reassignment is not None else scope_end,
+                            )
+                        for index, (offset, allocation_type) in enumerate(assignment_events):
+                            if allocation_type is None:
+                                continue
+                            next_offset = (
+                                assignment_events[index + 1][0]
+                                if index + 1 < len(assignment_events) else None
+                            )
+                            scopes.add_allocation(
+                                name, allocation_type, offset,
+                                next_offset - 1 if next_offset is not None else scope_end,
+                            )
+                        scopes.add(
+                            name, type_text,
+                            node.start_byte, scope_end,
+                        )
+            elif node.type == "enhanced_for_statement":
+                type_node = node.child_by_field_name("type")
+                name_node = node.child_by_field_name("name")
+                body_node = node.child_by_field_name("body")
+                if type_node is not None and name_node is not None and body_node is not None:
+                    # loop variable is visible only inside the loop body
+                    # (JLS 14.14.2) — NOT the iterable expression, which
+                    # resolves in the enclosing scope (F-01 fix: this used
+                    # to start at the whole statement's start_byte, so a
+                    # loop var shadowed a same-named field/local inside its
+                    # own iterable expression, e.g. `for (A x : x.items())`
+                    # where `x` before `:` must stay the outer `x`).
+                    scopes.add(
+                        self._text(name_node, source), self._text(type_node, source),
+                        body_node.start_byte, node.end_byte,
+                    )
+            elif node.type == "resource":
+                type_node = node.child_by_field_name("type")
+                name_node = node.child_by_field_name("name")
+                if type_node is not None and name_node is not None:
+                    type_text: Optional[str] = self._text(type_node, source)
+                    if type_text == "var":
+                        # `try (var ctx = new Context(...))`: the resource's
+                        # type is exactly its initializer's type token; a
+                        # source-call initializer is typed by the context-
+                        # aware second pass, and anything else stays unknown
+                        # (the literal token `var` is never a class name).
+                        type_text = self._var_initializer_type(
+                            node.child_by_field_name("value"), source,
+                        )
+                    if type_text is not None:
+                        scope_end = self._enclosing_scope_end(
+                            node, ("try_with_resources_statement",), node.end_byte,
+                        )
+                        scopes.add(
+                            self._text(name_node, source), type_text,
+                            node.start_byte, scope_end,
+                        )
+            elif node.type == "catch_formal_parameter":
+                name_node = node.child_by_field_name("name")
+                catch_type = next(
+                    (c for c in node.children if c.type == "catch_type"), None
+                )
+                type_node = (
+                    next((c for c in catch_type.children if c.is_named), None)
+                    if catch_type is not None else None
+                )
+                if type_node is not None and name_node is not None:
+                    scope_end = self._enclosing_scope_end(
+                        node, ("catch_clause",), node.end_byte,
+                    )
+                    scopes.add(
+                        self._text(name_node, source), self._text(type_node, source),
+                        node.start_byte, scope_end,
+                    )
+            elif node.type == "instanceof_expression":
+                # JLS 6.3 flow scoping for a type pattern.  The grammar keeps
+                # the matched type in `right` and the introduced identifier
+                # in `name` (`value instanceof Item item`).  Add the binding
+                # only where the condition proves the match:
+                #
+                # * the RHS of `pattern && rhs`;
+                # * a positive `if` consequence; or
+                # * after a negated guard whose consequence exits directly.
+                #
+                # Other boolean shapes deliberately remain unresolved rather
+                # than leaking a pattern variable into a path where it may not
+                # exist.
+                type_node = node.child_by_field_name("right")
+                name_node = node.child_by_field_name("name")
+                if type_node is not None and name_node is not None:
+                    pattern_type = self._text(type_node, source)
+                    pattern_name = self._text(name_node, source)
+                    ancestor = node.parent
+                    while ancestor is not None and ancestor != body:
+                        if ancestor.type == "binary_expression":
+                            operator = ancestor.child_by_field_name("operator")
+                            left = ancestor.child_by_field_name("left")
+                            right = ancestor.child_by_field_name("right")
+                            if (
+                                operator is not None
+                                and self._text(operator, source) == "&&"
+                                and left is not None and right is not None
+                                and left.start_byte <= node.start_byte
+                                and node.end_byte <= left.end_byte
+                            ):
+                                scopes.add(
+                                    pattern_name, pattern_type,
+                                    right.start_byte, right.end_byte,
+                                )
+                                break
+                        if ancestor.type == "if_statement":
+                            condition = ancestor.child_by_field_name("condition")
+                            consequence = ancestor.child_by_field_name("consequence")
+                            alternative = ancestor.child_by_field_name("alternative")
+                            if condition is None or consequence is None:
+                                break
+                            condition_text = self._text(condition, source).strip()
+                            if condition_text.lstrip("(").startswith("!"):
+                                abrupt_consequence = consequence.type in {
+                                    "return_statement", "throw_statement",
+                                    "break_statement", "continue_statement",
+                                }
+                                if consequence.type == "block":
+                                    statements = [
+                                        child for child in consequence.children
+                                        if child.is_named
+                                    ]
+                                    abrupt_consequence = bool(
+                                        statements
+                                        and statements[-1].type in {
+                                            "return_statement", "throw_statement",
+                                            "break_statement", "continue_statement",
+                                        }
+                                    )
+                                if (
+                                    alternative is None
+                                    and abrupt_consequence
+                                ):
+                                    scope_end = self._enclosing_scope_end(
+                                        ancestor, ("block",), body.end_byte,
+                                    )
+                                    scopes.add(
+                                        pattern_name, pattern_type,
+                                        ancestor.end_byte, scope_end,
+                                    )
+                            else:
+                                scopes.add(
+                                    pattern_name, pattern_type,
+                                    consequence.start_byte, consequence.end_byte,
+                                )
+                            break
+                        ancestor = ancestor.parent
+        return scopes
+
+    def _collect_lambda_parameter_scopes(
+        self, body, source: bytes, module_name: str,
+        enclosing_class_id: Optional[str], import_map: Dict[str, str],
+        wildcard_packages: List[str], local_types: "_LocalScopes",
+        param_types: Dict[str, str], type_param_bounds: Dict[str, str],
+        static_wildcard_classes: List[str],
+    ) -> None:
+        """Add contextually typed lambda parameters to lexical locals.
+
+        Covers source functional-interface parameters (for example
+        ``Comparator<Option>``) and the common ``Stream<T>.map`` pipeline.
+        Unknown or multiply-resolved contexts add nothing.
+        """
+        for node in self._method_facts(body).lambda_expressions:
+            params_node = node.child_by_field_name("parameters")
+            lambda_body = node.child_by_field_name("body")
+            args_node = node.parent
+            call_node = args_node.parent if args_node is not None else None
+            inferred: Optional[str] = None
+            # Assignment context: `Consumer<Scenario> consumer = it -> ...`.
+            # For the single implicit parameter shape, the functional
+            # interface's first generic argument is its contextual type.
+            declarator = node.parent
+            declaration = declarator.parent if declarator is not None else None
+            if (
+                params_node is not None
+                and params_node.type == "identifier"
+                and declarator is not None
+                and declarator.type == "variable_declarator"
+                and declaration is not None
+                and declaration.type == "local_variable_declaration"
+            ):
+                declared_type = declaration.child_by_field_name("type")
+                generic_args = (
+                    self._generic_type_arguments(self._text(declared_type, source))
+                    if declared_type is not None else []
+                )
+                inferred = generic_args[0] if generic_args else None
+            # Return context: `Predicate<Bean> factory() { return bean ->
+            # ...; }` and `Function<P, R> f() { return p -> ...; }`.
+            # The enclosing method's declared functional type provides
+            # the implicit lambda parameter even though there is no
+            # assignment or call-argument target at the lambda node.
+            if inferred is None and params_node is not None:
+                ancestor = node.parent
+                returned = False
+                while ancestor is not None and ancestor.type not in _METHOD_CST_TYPES:
+                    if ancestor.type == "return_statement":
+                        returned = True
+                    ancestor = ancestor.parent
+                if returned and ancestor is not None:
+                    return_type_node = ancestor.child_by_field_name("type")
+                    generic_args = (
+                        self._generic_type_arguments(
+                            self._text(return_type_node, source),
+                        )
+                        if return_type_node is not None else []
+                    )
+                    inferred = generic_args[0] if generic_args else None
+                    if inferred is None and return_type_node is not None:
+                        functional_type = self._text(return_type_node, source)
+                        functional_id = self._resolve_declared_type(
+                            functional_type, module_name, import_map,
+                            wildcard_packages, enclosing_class_id,
+                        )
+                        if functional_id is not None:
+                            abstract_methods = [
+                                child for child in self._contains_children(functional_id)
+                                if self.builder._nodes[child].node_type == NodeType.FUNCTION
+                                and self.builder._nodes[child].metadata.get("java_is_abstract")
+                                and not self.builder._nodes[child].metadata.get("java_is_static")
+                            ]
+                            if len(abstract_methods) == 1:
+                                sam_params = self._param_type_lists.get(
+                                    abstract_methods[0], [],
+                                )
+                                inferred = sam_params[0] if sam_params else None
+            if (
+                params_node is not None and lambda_body is not None
+                and args_node is not None and args_node.type == "argument_list"
+                and call_node is not None and call_node.type == "method_invocation"
+            ):
+                args = argument_nodes(args_node)
+                arg_index = next((i for i, c in enumerate(args) if c == node), -1)
+                name_node = call_node.child_by_field_name("name")
+                receiver_node = call_node.child_by_field_name("object")
+                if arg_index >= 0 and name_node is not None:
+                    method_name = self._text(name_node, source)
+                    receiver_text = (
+                        self._declared_receiver_type_text(
+                            receiver_node, source, module_name, enclosing_class_id,
+                            import_map, wildcard_packages, local_types,
+                            self._all_field_types(enclosing_class_id)
+                            if enclosing_class_id else {},
+                            param_types, type_param_bounds,
+                        )
+                        if receiver_node is not None else None
+                    )
+                    receiver_simple = (
+                        erased_type(receiver_text).strip().split(".")[-1]
+                        if receiver_text is not None else None
+                    )
+                    external_element_lambda = (
+                        receiver_simple == "Stream"
+                        and method_name in JAVA_STREAM_ELEMENT_LAMBDA_METHODS
+                    ) or (
+                        receiver_simple == "Optional"
+                        and method_name in JAVA_OPTIONAL_ELEMENT_LAMBDA_METHODS
+                    )
+                    primitive_element = _PRIMITIVE_STREAM_ELEMENT.get(receiver_simple or "")
+                    if (
+                        arg_index == 0 and primitive_element is not None
+                        and method_name in JAVA_STREAM_ELEMENT_LAMBDA_METHODS
+                    ):
+                        # `IntStream.iterate(0, n -> n + 2).mapToObj(n ->
+                        # ...)`: a primitive stream's element-consuming
+                        # lambda parameter is exactly `int`/`long`/
+                        # `double` (batch 26) — no type argument to read.
+                        inferred = primitive_element
+                    elif arg_index == 0 and external_element_lambda:
+                        generic_args = self._generic_type_arguments(receiver_text)
+                        inferred = generic_args[0] if generic_args else None
+                    elif (
+                        params_node.type == "identifier"
+                        and arg_index == 0
+                        and method_name == "groupingBy"
+                        and "java.util.stream.Collectors" in static_wildcard_classes
+                    ):
+                        # `Stream<T>.collect(groupingBy(t -> ...))` gives
+                        # the static-imported collector's first Function
+                        # argument the stream element type.  Require the
+                        # exact JDK static wildcard plus the enclosing
+                        # `collect` call, so a project-local `groupingBy`
+                        # cannot acquire a guessed lambda type.
+                        outer_args = call_node.parent
+                        outer_call = (
+                            outer_args.parent if outer_args is not None
+                            and outer_args.type == "argument_list" else None
+                        )
+                        outer_name = (
+                            outer_call.child_by_field_name("name")
+                            if outer_call is not None
+                            and outer_call.type == "method_invocation" else None
+                        )
+                        outer_receiver = (
+                            outer_call.child_by_field_name("object")
+                            if outer_call is not None else None
+                        )
+                        if (
+                            outer_name is not None
+                            and self._text(outer_name, source) == "collect"
+                            and outer_receiver is not None
+                        ):
+                            outer_type = self._declared_receiver_type_text(
+                                outer_receiver, source, module_name,
+                                enclosing_class_id, import_map,
+                                wildcard_packages, local_types,
+                                self._all_field_types(enclosing_class_id)
+                                if enclosing_class_id else {},
+                                param_types, type_param_bounds,
+                            )
+                            if (
+                                outer_type is not None
+                                and erased_type(outer_type).strip().split(".")[-1] == "Stream"
+                            ):
+                                generic_args = self._generic_type_arguments(outer_type)
+                                inferred = generic_args[0] if generic_args else None
+                    elif (
+                        params_node.type == "identifier"
+                        and arg_index == 0
+                        and receiver_simple == "Function"
+                        and method_name in {"andThen", "compose"}
+                    ):
+                        generic_args = self._generic_type_arguments(receiver_text)
+                        if len(generic_args) == 2:
+                            inferred = generic_args[1 if method_name == "andThen" else 0]
+                    elif (
+                        params_node.type == "identifier"
+                        and arg_index == 1
+                        and method_name == "computeIfAbsent"
+                        and receiver_simple in {
+                            "Map", "HashMap", "LinkedHashMap", "TreeMap",
+                            "ConcurrentHashMap",
+                        }
+                    ):
+                        # JDK Map.computeIfAbsent(K, Function<K,V>) gives
+                        # its second argument an exact key type.  This is
+                        # deliberately not generalized to compute/merge:
+                        # their BiFunction parameters have distinct K/V
+                        # positions and need a multi-parameter model.
+                        generic_args = self._generic_type_arguments(receiver_text)
+                        inferred = generic_args[0] if len(generic_args) == 2 else None
+                    else:
+                        receiver_id = enclosing_class_id if receiver_node is None else None
+                        if receiver_node is not None:
+                            receiver_id, _ = self._resolve_receiver(
+                                receiver_node, source, module_name, enclosing_class_id,
+                                import_map, wildcard_packages, local_types,
+                                self._all_field_types(enclosing_class_id)
+                                if enclosing_class_id else {},
+                                param_types, type_param_bounds,
+                            )
+                        if receiver_id is not None:
+                            candidates = self._members_named(
+                                receiver_id, method_name, search_ancestors=True,
+                            )
+                            arity = self._count_args(args_node)
+                            argument_types = self._infer_arg_types(
+                                args_node, source, local_types, param_types,
+                                self._all_field_types(enclosing_class_id)
+                                if enclosing_class_id else {},
+                            )
+                            target, _ = self._select_overload(
+                                candidates, arity, argument_types,
+                                lambda _candidate: 0.9,
+                                _ImportContext(
+                                    module_name, import_map, wildcard_packages,
+                                    enclosing_class_id,
+                                ),
+                            )
+                            if isinstance(target, str):
+                                # A lambda past the fixed-arity prefix of a
+                                # varargs overload (`run(a -> .., b -> ..)`
+                                # into `run(Consumer<T>... steps)`) has no
+                                # positional parameter of its own: it is
+                                # typed by the vararg component, never by
+                                # a raw index that would overrun the list.
+                                params = self._param_type_lists.get(target, [])
+                                if arg_index < len(params):
+                                    declared = params[arg_index]
+                                elif params and self._is_vararg_param(params[-1]):
+                                    declared = params[-1]
+                                else:
+                                    declared = ""
+                                generic_args = self._generic_type_arguments(declared)
+                                inferred = generic_args[0] if generic_args else None
+                            elif params_node.type == "identifier":
+                                # Overloaded functional factories often
+                                # cannot be selected until the lambda is
+                                # typed, while typing previously required
+                                # selecting the overload—a cycle. Break it
+                                # only when every arity-compatible source
+                                # candidate declares the same functional
+                                # input type at this argument position.
+                                contextual: Set[str] = set()
+                                for candidate in candidates:
+                                    if not self._arity_matches(candidate, arity):
+                                        continue
+                                    declared_params = self._param_type_lists.get(
+                                        candidate, [],
+                                    )
+                                    if arg_index >= len(declared_params):
+                                        continue
+                                    generic_args = self._generic_type_arguments(
+                                        declared_params[arg_index],
+                                    )
+                                    if generic_args:
+                                        contextual.add(generic_args[0])
+                                if len(contextual) == 1:
+                                    inferred = next(iter(contextual))
+            if inferred:
+                names = (
+                    [self._text(params_node, source)]
+                    if params_node.type == "identifier"
+                    else [self._text(c, source) for c in params_node.children if c.type == "identifier"]
+                )
+                for name in names:
+                    local_types.add(name, inferred, lambda_body.start_byte, lambda_body.end_byte)
+            elif params_node is not None and lambda_body is not None:
+                # The lambda genuinely has parameters, but every
+                # inference path above failed — most commonly a lambda
+                # passed to a JDK method outside the small allow-lists
+                # above (`List<T>.forEach`, etc.), whose declaring type
+                # isn't in source so its SAM parameter type can't be
+                # read. The parameter name is still a real declaration
+                # that shadows any same-named outer local/param/field
+                # for the lambda body's extent, even though its type
+                # stays unknown ("missing edge over wrong edge") — record
+                # it the same way an unresolvable `var` local is (P4.4
+                # shadow-detection fix), so callers checking
+                # `declared_at` don't fall through to the outer scope.
+                names = (
+                    [self._text(params_node, source)]
+                    if params_node.type == "identifier"
+                    else [self._text(c, source) for c in params_node.children if c.type == "identifier"]
+                )
+                for name in names:
+                    local_types.add_declared(name, lambda_body.start_byte, lambda_body.end_byte)
+
+    def _var_initializer_type(
+        self, value_node, source: bytes,
+        local_types: Optional["_LocalScopes"] = None,
+        param_types: Optional[Dict[str, str]] = None,
+        field_types: Optional[Dict[str, str]] = None,
+    ) -> Optional[str]:
+        """Best-effort declared type for a `var` local's initializer (JLS
+        14.4), used only by `_collect_local_scopes`'s `var` branch (V-01
+        fix). Limited to the initializer forms that already carry an
+        explicit type token the same way `_infer_arg_type` reads them for a
+        method-call argument — `new Foo()` (`object_creation_expression`),
+        `(Foo) x` (`cast_expression`), both exposing a `type` CST field
+        directly, and `arr[i]` (`array_access`), delegated to
+        `_infer_arg_type`'s own array-element-type peeling so `var first =
+        args[0]` off a `String[] args` parameter resolves the same way
+        `save(args[0])` already does (9c77bb7's direct-argument case, one
+        assignment hop further). The `array_access` branch is a no-op unless
+        a caller supplies at least one of `local_types`/`param_types`/
+        `field_types` — every other `_var_initializer_type` call site keeps
+        passing none of them, since none can ever reach an `array_access`
+        value (each already gates on `object_creation_expression`
+        specifically). Anything else (a method call's declared return type,
+        a literal, a binary/ternary expression, a chained call, ...) returns
+        None — deliberately not a general type-inference pass; the caller
+        then leaves the local out of the scope map entirely rather than
+        guessing, so it resolves the same "unknown, no edge" way an
+        already-unresolvable receiver does elsewhere in this file."""
+        if value_node is None:
+            return None
+        if value_node.type in ("true", "false"):
+            # JLS 3.10.3: the two boolean literals have type `boolean`.
+            # This is as declaration-backed as a typed local and lets a
+            # `var enabled = false` argument select a boolean overload.
+            return "boolean"
+        if value_node.type in ("object_creation_expression", "cast_expression"):
+            type_node = value_node.child_by_field_name("type")
+            return (
+                source[type_node.start_byte:type_node.end_byte].decode("utf8")
+                if type_node is not None else None
+            )
+        if value_node.type == "array_access" and (
+            local_types is not None or param_types is not None or field_types is not None
+        ):
+            return self._infer_arg_type(
+                value_node, source, local_types or _LocalScopes(),
+                param_types or {}, field_types or {},
+            )
+        return None
+
+    @staticmethod
+    def _is_mockito_factory_call(value_node, source: bytes) -> bool:
+        """True iff `value_node` is a call to Mockito's `mock(...)`/
+        `spy(...)` factory (bare, statically imported, or qualified
+        `Mockito.mock(...)`/`BDDMockito.mock(...)`). A mock/spy receiver has
+        no real declared implementation to dispatch to at runtime — this is
+        an exact fact about a ubiquitous, unambiguous third-party API, not a
+        guess, so `_abstract_fan_out` can safely treat it as "no concrete
+        target" instead of fanning out across unrelated project code that
+        happens to implement the same interface."""
+        if value_node.type != "method_invocation":
+            return False
+        name_node = value_node.child_by_field_name("name")
+        if name_node is None or source[name_node.start_byte:name_node.end_byte].decode(
+            "utf8", errors="replace",
+        ) not in ("mock", "spy"):
+            return False
+        receiver = value_node.child_by_field_name("object")
+        if receiver is None:
+            return True  # bare call: `mock(...)`, statically imported.
+        return receiver.type == "identifier" and source[
+            receiver.start_byte:receiver.end_byte
+        ].decode("utf8", errors="replace") in ("Mockito", "BDDMockito")
+
+    def _name_reassigned_in_range(
+        self, assignments, source: bytes, name: str, after: int, before: int,
+    ) -> bool:
+        """True iff a plain `name = ...;` assignment appears anywhere in
+        one of the already-collected assignment expressions strictly after
+        byte `after` and at/before `before`. Method facts exclude nested
+        method/type bodies, so a same-named local or field there cannot be a
+        reassignment of this one. Used to keep a declaration-site allocation fact (a typed
+        local's method-call initializer) from silently outliving a later,
+        different assignment to the same name in the same scope."""
+        for node in assignments:
+            children = [c for c in node.children if not c.is_extra]
+            if (
+                len(children) >= 3 and children[1].type == "="
+                and children[0].type == "identifier"
+                and after < children[0].start_byte <= before
+                and self._text(children[0], source) == name
+            ):
+                return True
+        return False
+
+    def _collect_var_method_call_scopes(
+        self, body, source: bytes, module_name: str,
+        enclosing_class_id: Optional[str], import_map: Dict[str, str],
+        wildcard_packages: List[str], local_types: "_LocalScopes",
+        param_types: Dict[str, str], type_param_bounds: Dict[str, str],
+    ) -> None:
+        """Infer context-dependent ``var`` locals from resolvable source types.
+
+        The first local-scope pass intentionally handles syntax-only types.
+        This context-aware second pass can reuse source method selection and
+        its declared return type without introducing a name guess.  It also
+        covers enhanced-for variables when the iterable has an exact array or
+        single-element generic type (for example ``Status.values()`` yielding
+        ``Status[]``); the variable remains scoped to the loop body.
+        """
+        field_types = (
+            self._all_field_types(enclosing_class_id) if enclosing_class_id else {}
+        )
+        facts = self._method_facts(body)
+        # `_method_facts` collects its DFS in reverse source order (a LIFO
+        # stack pushes natural-order children).  This pass depends on earlier
+        # declarations, so reverse the immutable subset to retain the old
+        # source-order traversal exactly.
+        for node in reversed(facts.local_scope_nodes):
+            if node.type == "local_variable_declaration":
+                type_node = node.child_by_field_name("type")
+                if type_node is not None and self._text(type_node, source) == "var":
+                    scope_end = self._enclosing_scope_end(
+                        node, ("block", "for_statement", "switch_block"), body.end_byte,
+                    )
+                    for child in node.children:
+                        if child.type != "variable_declarator":
+                            continue
+                        name_node = child.child_by_field_name("name")
+                        value_node = child.child_by_field_name("value")
+                        if name_node is None or value_node is None:
+                            continue
+                        inferred: Optional[str] = None
+                        if value_node.type == "method_invocation":
+                            inferred = self._generic_method_invocation_return_type(
+                                value_node, source, module_name, enclosing_class_id,
+                                import_map, wildcard_packages, local_types, field_types,
+                                param_types, type_param_bounds,
+                            )
+                        elif value_node.type == "field_access":
+                            # `var folder = options.outputFolder` has no
+                            # explicit type token, but the selected receiver
+                            # class owns an exact declared field type.  This
+                            # is a bounded local propagation step, not a
+                            # global name fallback: unresolved receivers or
+                            # fields still leave the `var` unknown.
+                            receiver = value_node.child_by_field_name("object")
+                            field = value_node.child_by_field_name("field")
+                            if receiver is not None and field is not None:
+                                receiver_id, _ = self._resolve_receiver(
+                                    receiver, source, module_name, enclosing_class_id,
+                                    import_map, wildcard_packages, local_types,
+                                    field_types, param_types, type_param_bounds,
+                                )
+                                if receiver_id is not None:
+                                    inferred = self._all_field_types(receiver_id).get(
+                                        self._text(field, source)
+                                    )
+                        elif value_node.type == "ternary_expression":
+                            inferred = self._declared_receiver_type_text(
+                                value_node, source, module_name,
+                                enclosing_class_id, import_map,
+                                wildcard_packages, local_types, field_types,
+                                param_types, type_param_bounds,
+                            )
+                        if inferred is not None:
+                            local_types.add(
+                                self._text(name_node, source), inferred,
+                                node.start_byte, scope_end,
+                            )
+                elif type_node is not None:
+                    # A typed (non-`var`) local's initializer may be a
+                    # source method call whose *declared* return type is
+                    # more concrete than the local's own declared type
+                    # reveals -- e.g. `ConfigurationParameters configParams
+                    # = fromMapAndParent(...)`, where `fromMapAndParent` is
+                    # declared to return the concrete
+                    # `LauncherConfigurationParameters`, not the interface
+                    # `configParams` is declared as. Dispatch on
+                    # `configParams` still uses its *declared* interface
+                    # type (Java static-dispatch semantics, preserved
+                    # elsewhere in this file), but `_abstract_fan_out` can
+                    # use this as allocation evidence the same way a direct
+                    # `new Impl()` initializer already narrows it (P5
+                    # finding #2) -- reusing the exact return-type
+                    # propagation this pass already trusts for `var`
+                    # locals, never a new inference. Skipped when the local
+                    # is reassigned anywhere later in its own scope, since a
+                    # stale allocation recorded only at the declaration site
+                    # would otherwise silently outlive a later, different
+                    # assignment.
+                    scope_end = self._enclosing_scope_end(
+                        node, ("block", "for_statement", "switch_block"), body.end_byte,
+                    )
+                    for child in node.children:
+                        if child.type != "variable_declarator":
+                            continue
+                        name_node = child.child_by_field_name("name")
+                        value_node = child.child_by_field_name("value")
+                        if (
+                            name_node is None or value_node is None
+                            or value_node.type != "method_invocation"
+                        ):
+                            continue
+                        inferred = self._generic_method_invocation_return_type(
+                            value_node, source, module_name, enclosing_class_id,
+                            import_map, wildcard_packages, local_types,
+                            field_types, param_types, type_param_bounds,
+                        )
+                        if inferred is None:
+                            continue
+                        allocation_id = self._resolve_declared_type(
+                            inferred, module_name, import_map,
+                            wildcard_packages, enclosing_class_id,
+                        )
+                        if (
+                            allocation_id is None
+                            or not self._is_concrete_class(allocation_id)
+                        ):
+                            continue
+                        name = self._text(name_node, source)
+                        if self._name_reassigned_in_range(
+                            facts.assignment_expressions, source, name,
+                            node.end_byte, scope_end,
+                        ):
+                            continue
+                        local_types.add_allocation(
+                            name, inferred, node.start_byte, scope_end,
+                        )
+            elif node.type == "resource":
+                type_node = node.child_by_field_name("type")
+                name_node = node.child_by_field_name("name")
+                value_node = node.child_by_field_name("value")
+                if (
+                    type_node is not None
+                    and self._text(type_node, source) == "var"
+                    and name_node is not None
+                    and value_node is not None
+                    and value_node.type == "method_invocation"
+                ):
+                    # `try (var ctx = factory.open())`: same bounded source
+                    # return propagation as a `var` local initializer.
+                    inferred = self._generic_method_invocation_return_type(
+                        value_node, source, module_name, enclosing_class_id,
+                        import_map, wildcard_packages, local_types, field_types,
+                        param_types, type_param_bounds,
+                    )
+                    if inferred is not None:
+                        local_types.add(
+                            self._text(name_node, source), inferred, node.start_byte,
+                            self._enclosing_scope_end(
+                                node, ("try_with_resources_statement",), node.end_byte,
+                            ),
+                        )
+            elif node.type == "enhanced_for_statement":
+                type_node = node.child_by_field_name("type")
+                name_node = node.child_by_field_name("name")
+                value_node = node.child_by_field_name("value")
+                body_node = node.child_by_field_name("body")
+                if (
+                    type_node is not None
+                    and self._text(type_node, source) == "var"
+                    and name_node is not None
+                    and value_node is not None
+                    and body_node is not None
+                ):
+                    iterable_type = self._declared_receiver_type_text(
+                        value_node, source, module_name, enclosing_class_id,
+                        import_map, wildcard_packages, local_types, field_types,
+                        param_types, type_param_bounds,
+                    )
+                    element_type: Optional[str] = None
+                    if iterable_type is not None:
+                        erased_iterable = erased_type(iterable_type).strip()
+                        if erased_iterable.endswith("[]"):
+                            element_type = erased_iterable[:-2].strip() or None
+                        else:
+                            generic_args = self._generic_type_arguments(iterable_type)
+                            if len(generic_args) == 1:
+                                element_type = generic_args[0]
+                    if element_type is not None:
+                        local_types.add(
+                            self._text(name_node, source), element_type,
+                            body_node.start_byte, node.end_byte,
+                        )
+
+    @staticmethod
+    def _param_names(func_cst, source: bytes) -> List[str]:
+        """Ordered parameter names of a method/constructor CST node —
+        zipped against `_param_type_lists` (built from `Symbol.param_types`,
+        which preserves declaration order) to get a `{name: type}` map for
+        the *current* method's own parameters."""
+        params_node = func_cst.child_by_field_name("parameters")
+        if params_node is None:
+            return []
+        names: List[str] = []
+        for child in params_node.children:
+            if child.type == "formal_parameter":
+                name_node = child.child_by_field_name("name")
+                if name_node is not None:
+                    names.append(
+                        source[name_node.start_byte:name_node.end_byte].decode(
+                            "utf-8", errors="replace"
+                        )
+                    )
+            elif child.type == "spread_parameter":
+                for sub in child.children:
+                    if sub.type == "variable_declarator":
+                        name_node = sub.child_by_field_name("name")
+                        if name_node is not None:
+                            names.append(
+                                source[name_node.start_byte:name_node.end_byte].decode(
+                                    "utf-8", errors="replace"
+                                )
+                            )
+        return names