adl-toolkit 0.0.0-stage → 0.1.3

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

@@ -0,0 +1,1318 @@
+"""SAM target typing, lambdas, method references, and callable containers."""
+
+from __future__ import annotations
+
+import re
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Optional, Set, Tuple, Union
+
+from adl_drift.graph.edges import EdgeType, GraphEdge
+from adl_drift.graph.node import NodeType
+from adl_drift.lang.base import ParseResult
+from adl_drift.lang.java.ids import erased_type
+from adl_drift.lang.java.resolution.constants import (
+    ASSERTJ_CONSUMER_SATISFIES_METHODS,
+    ASSERTJ_PREDICATE_METHODS,
+    EXTERNAL_SAM_PARAMS,
+    EXTERNAL_SAM_RETURNS,
+    SPRING_CONTEXT_RUNNER_ASSERTABLE_CONTEXT,
+    _ENCLOSING_TYPE_CST_TYPES,
+    _JDK_SAM_PARAMS,
+    _JDK_SAM_RETURNS,
+    _METHOD_CST_TYPES,
+    _NESTED_SCOPE_BOUNDARY,
+    argument_nodes,
+)
+from adl_drift.lang.java.resolution.model import (
+    ImportContext as _ImportContext,
+    LocalScopes as _LocalScopes,
+    SAMDescriptor as _SAMDescriptor,
+)
+from adl_drift.utils.types import AnalysisResult
+
+
+# Arity of the single functional-interface argument of common JDK Stream and
+# Optional methods, used only as a method-reference fallback when the receiver's
+# generic element type is unavailable (external declaration).
+_JDK_FUNCTIONAL_ARGUMENT_ARITY: Dict[str, int] = {
+    "allMatch": 1, "anyMatch": 1, "filter": 1, "flatMap": 1, "forEach": 1,
+    "forEachOrdered": 1, "map": 1, "mapMulti": 1, "noneMatch": 1, "peek": 1,
+    "orElseGet": 0, "orElseThrow": 0, "or": 0,
+}
+
+# Per-argument-index arity of `java.util.stream.Collectors` map-collecting
+# factories' functional parameters: keyMapper/valueMapper are one-arg
+# `Function`s, the optional mergeFunction is a two-arg `BinaryOperator`, and
+# the optional mapSupplier is a zero-arg `Supplier`. Used only as a
+# method/constructor-reference fallback when the collected stream's element
+# type is unavailable to compute a full SAM descriptor by type.
+_JDK_INDEXED_FUNCTIONAL_ARITY: Dict[str, List[int]] = {
+    "toMap": [1, 1, 2, 0],
+    "toConcurrentMap": [1, 1, 2, 0],
+    "toUnmodifiableMap": [1, 1, 2],
+}
+
+
+class FunctionalResolutionMixin:
+    @classmethod
+    def _functional_value_type(cls, type_text: str) -> str:
+        """Peel common callable containers (`Map<K, Runnable>`, arrays)."""
+        text = type_text.strip()
+        while text.endswith("[]"):
+            text = text[:-2].strip()
+        for _ in range(4):
+            raw = erased_type(text).rsplit(".", 1)[-1]
+            if raw not in {"Map", "HashMap", "ConcurrentMap", "List", "Set", "Collection", "Optional"}:
+                break
+            args = cls._generic_type_arguments(text)
+            if not args:
+                break
+            text = args[-1]
+        return text
+
+    def _functional_target_type(
+        self, expression, source: bytes, local_types: "_LocalScopes",
+        param_types: Dict[str, str], field_types: Dict[str, str], caller_node,
+    ) -> Optional[str]:
+        """Target type supplied by assignment/cast/return/container context."""
+        cur = expression
+        while cur.parent is not None and cur.parent.type not in _METHOD_CST_TYPES:
+            parent = cur.parent
+            # A callable expression nested in another lambda must not inherit
+            # the outer lambda's functional type (e.g. an inner
+            # `Predicate<Event>` being mistaken for `Consumer<Scenario>`).
+            # Its own target comes from its consuming invocation.
+            if parent.type == "lambda_expression" and parent is not expression:
+                break
+            if parent.type == "cast_expression":
+                type_node = parent.child_by_field_name("type")
+                if type_node is not None:
+                    return self._functional_value_type(self._text(type_node, source))
+            if parent.type == "variable_declarator":
+                declaration = parent.parent
+                type_node = declaration.child_by_field_name("type") if declaration else None
+                if type_node is not None:
+                    return self._functional_value_type(self._text(type_node, source))
+            if parent.type == "assignment_expression":
+                left = parent.child_by_field_name("left")
+                if left is not None and left.type == "identifier":
+                    name = self._text(left, source)
+                    declared = (
+                        local_types.type_at(name, expression.start_byte)
+                        or param_types.get(name) or field_types.get(name)
+                    )
+                    if declared:
+                        return self._functional_value_type(declared)
+            if parent.type == "return_statement":
+                returned = caller_node.metadata.get("java_return_type")
+                if isinstance(returned, str):
+                    return self._functional_value_type(returned)
+            if parent.type == "argument_list" and parent.parent is not None:
+                invocation = parent.parent
+                if invocation.type == "method_invocation":
+                    name_node = invocation.child_by_field_name("name")
+                    obj = invocation.child_by_field_name("object")
+                    if name_node is not None and self._text(name_node, source) in {
+                        "put", "add", "offer",
+                    } and obj is not None and obj.type == "identifier":
+                        name = self._text(obj, source)
+                        declared = (
+                            local_types.type_at(name, expression.start_byte)
+                            or param_types.get(name) or field_types.get(name)
+                        )
+                        if declared:
+                            return self._functional_value_type(declared)
+                    # The callable is consumed by this invocation.  An outer
+                    # assignment/return types the invocation's result, not
+                    # the nested lambda/method reference itself; its SAM type
+                    # is resolved separately by
+                    # `_invocation_functional_target_type`.
+                    break
+            cur = parent
+        return None
+
+    @staticmethod
+    def _normalize_sam_type(type_text: str) -> str:
+        text = type_text.strip()
+        match = re.match(r"^\?\s+(?:extends|super)\s+(.+)$", text)
+        return erased_type(match.group(1) if match else ("Object" if text == "?" else text))
+
+    def _functional_descriptor(
+        self, type_text: Optional[str], module_name: str,
+        import_map: Dict[str, str], wildcard_packages: List[str],
+    ) -> Optional[_SAMDescriptor]:
+        """SAM parameter types for JDK or source-declared functional interfaces."""
+        if not type_text:
+            return None
+        raw = erased_type(type_text).strip()
+        while raw.endswith("[]"):
+            # `erased_type()` normalizes a vararg SAM parameter's `...` to
+            # `[]`; strip it back to the bare interface name so both the
+            # JDK-SAM-table lookup and the project-interface fallback below
+            # (keyed on `simple`, unlike `_resolve_declared_type`, which
+            # already strips this itself) still match `Executable` for
+            # `Executable...` — not the never-declared name `Executable[]`.
+            raw = raw[:-2]
+        simple = raw.rsplit(".", 1)[-1]
+        args = self._generic_type_arguments(type_text)
+        spec = _JDK_SAM_PARAMS.get(simple)
+        if spec is None:
+            # A small, separately-maintained table of well-known *external*
+            # (non-JDK) SAMs — see `EXTERNAL_SAM_PARAMS`'s own docstring for
+            # why this stays out of `_JDK_SAM_PARAMS` itself.
+            spec = EXTERNAL_SAM_PARAMS.get(simple)
+        if spec is not None:
+            params: List[str] = []
+            for item in spec:
+                if isinstance(item, str):
+                    params.append(item)
+                elif item < len(args):
+                    params.append(self._normalize_sam_type(args[item]))
+                else:
+                    return None
+            return_spec = _JDK_SAM_RETURNS.get(simple)
+            if return_spec is None:
+                return_spec = EXTERNAL_SAM_RETURNS.get(simple)
+            if isinstance(return_spec, int):
+                if return_spec >= len(args):
+                    return None
+                return_type = self._normalize_sam_type(args[return_spec])
+            else:
+                return_type = return_spec
+            return _SAMDescriptor(params, return_type)
+
+        interface_id = self._resolve_declared_type(
+            type_text, module_name, import_map, wildcard_packages,
+        )
+        if interface_id is None:
+            # Candidate parameter types are written in the declaring file's
+            # import context, while this helper is called with the caller's
+            # context. Recover a nested/project SAM only when its simple name
+            # is globally unique; ambiguous names remain unresolved.
+            matches = [
+                node.id for node in self.builder._nodes.values()
+                if node.node_type == NodeType.CLASS
+                and node.name == simple
+                and node.metadata.get("java_type_kind") == "interface"
+            ]
+            if len(matches) == 1:
+                interface_id = matches[0]
+        interface = self.builder._nodes.get(interface_id) if interface_id else None
+        if interface is None or interface.metadata.get("java_type_kind") != "interface":
+            return None
+
+        abstract: List[str] = []
+        seen: Set[Tuple[str, Tuple[str, ...]]] = set()
+        for owner in [interface_id, *self._class_ancestors(interface_id)]:
+            for member_id in self._contains_children(owner):
+                member = self.builder._nodes.get(member_id)
+                if member is None or member.node_type != NodeType.FUNCTION:
+                    continue
+                signature = self._erased_signature(member_id)
+                key = (member.name, signature)
+                if key in seen:
+                    continue
+                seen.add(key)
+                if self._is_static_member(member_id) or not member.metadata.get("java_is_abstract"):
+                    continue
+                if key in {("equals", ("Object",)), ("hashCode", ()), ("toString", ())}:
+                    continue
+                abstract.append(member_id)
+        if len(abstract) != 1:
+            if abstract:
+                return None
+            # A project interface that only extends a JDK functional
+            # interface inherits that interface's single abstract method;
+            # describe it through the extends clause's type arguments.
+            external = self._external_functional_super(interface_id)
+            if external is None:
+                return None
+            owner_id, super_text = external
+            owner_node = self.builder._nodes.get(owner_id)
+            owner_ctx = (
+                self._file_ctx.get(owner_node.file_path)
+                if owner_node is not None else None
+            )
+            if owner_ctx is None:
+                return None
+            bindings = self._compose_type_var_bindings(interface_id, args, owner_id)
+            return self._functional_descriptor(
+                self._replace_type_variables(super_text, bindings),
+                owner_ctx.module, owner_ctx.import_map, owner_ctx.wildcard_packages,
+            )
+
+        sam_id = abstract[0]
+        declaring = self._declaring_class_id(sam_id) or interface_id
+        bindings = self._compose_type_var_bindings(interface_id, args, declaring)
+        params = [
+            self._normalize_sam_type(self._replace_type_variables(t, bindings))
+            for t in self._param_type_lists.get(sam_id, [])
+        ]
+        return_type = self.builder._nodes[sam_id].metadata.get("java_return_type")
+        if isinstance(return_type, str):
+            return_type = self._normalize_sam_type(
+                self._replace_type_variables(return_type, bindings)
+            )
+        else:
+            return_type = None
+        return _SAMDescriptor(params, return_type)
+
+    def _method_reference_return_compatible(
+        self, candidate_id: str, expected: Optional[str], expected_ctx: "_ImportContext",
+    ) -> bool:
+        if expected is None or expected == "void":
+            return True
+        # A consuming generic method can leave its result variable open at
+        # this point (`<S> matchingMapped(Function<E,S> extractor, ...)`).
+        # The method reference itself infers `S`; a single conventional Java
+        # type-variable token is therefore a constraint variable, not a
+        # project class that the candidate return must already equal.
+        if re.fullmatch(r"[A-Z]", expected):
+            return True
+        candidate = self.builder._nodes.get(candidate_id)
+        if candidate is None:
+            return False
+        actual = candidate.metadata.get("java_return_type")
+        if not isinstance(actual, str) or actual == "void":
+            return False
+        return self._types_compatible(
+            expected, erased_type(actual), expected_ctx,
+            self._param_ctx_for(candidate_id), allow_boxing=True,
+        )
+
+    def _invocation_functional_target_type(
+        self, expression, source: bytes, module_name: str,
+        import_map: Dict[str, str], wildcard_packages: List[str],
+        local_types: "_LocalScopes", param_types: Dict[str, str],
+        field_types: Dict[str, str], caller_node,
+    ) -> Optional[str]:
+        """Expected parameter type when callable is passed to one resolvable call."""
+        cur = expression
+        while cur.parent is not None and cur.parent.type not in _METHOD_CST_TYPES:
+            parent = cur.parent
+            if parent.type == "argument_list" and parent.parent is not None:
+                args = argument_nodes(parent)
+                try:
+                    index = args.index(cur)
+                except ValueError:
+                    return None
+                invocation = parent.parent
+                candidates: List[str] = []
+                enclosing = self._declaring_class_id(caller_node.id)
+                ctx = _ImportContext(
+                    module_name, import_map, wildcard_packages, enclosing,
+                )
+                receiver_class_id: Optional[str] = None
+                receiver_type: Optional[str] = None
+                receiver_args: List[str] = []
+                if invocation.type == "method_invocation":
+                    target, _, _ = self._resolve_call(
+                        invocation, source, module_name, enclosing, import_map,
+                        wildcard_packages, local_types, param_types,
+                        self._static_wildcard_by_file.get(caller_node.file_path, []), {},
+                    )
+                    candidates = self._target_ids(target)
+                    receiver = invocation.child_by_field_name("object")
+                    if receiver is not None:
+                        receiver_type = self._declared_receiver_type_text(
+                            receiver, source, module_name, enclosing, import_map,
+                            wildcard_packages, local_types, field_types,
+                            param_types, {},
+                        )
+                        if receiver_type is not None:
+                            receiver_class_id = self._resolve_declared_type(
+                                receiver_type, module_name, import_map,
+                                wildcard_packages, enclosing,
+                            )
+                            receiver_args = self._generic_type_arguments(receiver_type)
+                            # `Optional<T>.ifPresent(Consumer<? super T>)`/
+                            # `.ifPresentOrElse` have no source declaration
+                            # for `_resolve_call` to find (`candidates` stays
+                            # empty below), so the callable argument would
+                            # otherwise fall back to a bare per-JDK-method
+                            # arity placeholder -- indistinguishable between
+                            # two same-arity overloads of a method reference
+                            # target (`selectors(List)` vs `selectors
+                            # (DiscoverySelector...)`, both arity-1). The
+                            # receiver's own generic argument (already known
+                            # here, e.g. from a preceding `.map(...)` --
+                            # including its method-reference-argument case
+                            # just above) is the exact `T` the JDK contract
+                            # promises, independent of any candidate lookup.
+                            if (
+                                erased_type(receiver_type).rsplit(".", 1)[-1] == "Optional"
+                                and len(receiver_args) == 1
+                                and index == 0
+                            ):
+                                name_node = invocation.child_by_field_name("name")
+                                jdk_method = (
+                                    self._text(name_node, source)
+                                    if name_node is not None else None
+                                )
+                                if jdk_method in {"ifPresent", "ifPresentOrElse"}:
+                                    return (
+                                        "java.util.function.Consumer<"
+                                        f"{receiver_args[0]}>"
+                                    )
+                            # Spring Boot Test's runner subclasses hard-code
+                            # their own assertable-context type; see
+                            # `SPRING_CONTEXT_RUNNER_ASSERTABLE_CONTEXT`'s
+                            # docstring. Like `Optional.ifPresent` above,
+                            # `run` has no source declaration to find via
+                            # `_resolve_call` (`candidates` stays empty), so
+                            # without this the lambda's own parameter type
+                            # (e.g. `ctxt` in `.run(ctxt -> ...)`) is unknown
+                            # and everything inside its body is unresolvable.
+                            assertable_context = SPRING_CONTEXT_RUNNER_ASSERTABLE_CONTEXT.get(
+                                erased_type(receiver_type).rsplit(".", 1)[-1],
+                            )
+                            if assertable_context is not None and index == 0:
+                                name_node = invocation.child_by_field_name("name")
+                                if (
+                                    name_node is not None
+                                    and self._text(name_node, source) == "run"
+                                ):
+                                    return (
+                                        "org.springframework.boot.test.context.runner."
+                                        f"ContextConsumer<{assertable_context}>"
+                                    )
+                elif invocation.type == "object_creation_expression":
+                    type_node = invocation.child_by_field_name("type")
+                    class_id = self._resolve_declared_type(
+                        self._text(type_node, source) if type_node is not None else "",
+                        module_name, import_map, wildcard_packages,
+                    )
+                    if class_id:
+                        cls = self.builder._nodes[class_id]
+                        ctors = self._members_named(
+                            class_id, cls.name, search_ancestors=False,
+                        )
+                        target, _ = self._select_overload(
+                            ctors, len(args), None, lambda _c: 0.9, ctx,
+                        )
+                        candidates = self._target_ids(target)
+                elif invocation.type == "explicit_constructor_invocation":
+                    # `this(...)`/`super(...)` construct the current class or
+                    # its direct superclass; mirrors
+                    # `_resolve_explicit_constructor`'s target-class lookup so
+                    # a callable argument here (e.g. `this(a, b, Foo::new)`)
+                    # is target-typed against the delegate constructor's
+                    # declared parameter, same as any other constructor call.
+                    keyword_node = next(
+                        (c for c in invocation.named_children), None,
+                    )
+                    keyword = (
+                        self._text(keyword_node, source) if keyword_node is not None else None
+                    )
+                    delegate_class_id: Optional[str] = None
+                    if keyword == "this":
+                        delegate_class_id = enclosing
+                    elif keyword == "super" and enclosing is not None:
+                        parents = self._declared_direct_ancestors.get(
+                            (enclosing, EdgeType.INHERITS), [],
+                        )
+                        delegate_class_id = parents[0] if parents else None
+                    if delegate_class_id:
+                        cls = self.builder._nodes.get(delegate_class_id)
+                        if cls is not None:
+                            ctors = self._members_named(
+                                delegate_class_id, cls.name, search_ancestors=False,
+                            )
+                            target, _ = self._select_overload(
+                                ctors, len(args), None, lambda _c: 0.9, ctx,
+                            )
+                            candidates = self._target_ids(target)
+                expected: Set[str] = set()
+                for candidate in candidates:
+                    params = self._param_type_lists.get(candidate)
+                    if not params or not (
+                        index < len(params) or self._is_vararg_param(params[-1])
+                    ):
+                        continue
+                    parameter = params[min(index, len(params) - 1)]
+                    # A fluent receiver such as `Result<Event>` binds the
+                    # declaring class's `E` before its `Predicate<E>` or
+                    # `Function<E,S>` parameter can target-type a lambda or
+                    # method reference. Candidate parameter texts are stored
+                    # in declaration form, so substitute the receiver's
+                    # exact generic arguments here, at the consuming call.
+                    declaring = self._declaring_class_id(candidate)
+                    if receiver_class_id is not None and declaring is not None:
+                        bindings = self._compose_type_var_bindings(
+                            receiver_class_id, receiver_args, declaring,
+                        )
+                        parameter = self._replace_type_variables(parameter, bindings)
+                    # A sibling class-literal argument can bind a generic
+                    # method variable used by this functional parameter:
+                    # `<T,S> filter(..., Class<T>, Function<T,S>)` with
+                    # `SourceChange.class` target-types the mapper as
+                    # `Function<SourceChange,S>`. Keep unbound result
+                    # variables such as S open for method-reference return
+                    # inference.
+                    method_bindings: Dict[str, str] = {}
+                    method_type_params = self._method_type_param_bounds.get(candidate, {})
+                    for arg_index, arg_node in enumerate(args):
+                        if arg_node.type != "class_literal" or arg_index >= len(params):
+                            continue
+                        declared_args = self._generic_type_arguments(params[arg_index])
+                        variable = declared_args[0] if len(declared_args) == 1 else ""
+                        if variable not in method_type_params:
+                            continue
+                        literal = next((child for child in arg_node.children if child.is_named), None)
+                        if literal is not None:
+                            method_bindings[variable] = self._text(literal, source)
+                    # A sibling unbound source method reference can bind a
+                    # generic result variable consumed by this callable. For
+                    # `where(Descriptor::getUniqueId, uid -> uid.toString())`,
+                    # the first argument proves V is UniqueId, so the second
+                    # argument is exactly Predicate<UniqueId>. Keep this to a
+                    # unique zero-argument source declaration; overloaded,
+                    # bound, static, and external references retain their
+                    # existing unresolved behavior.
+                    for arg_index, arg_node in enumerate(args):
+                        if arg_node.type != "method_reference" or arg_index >= len(params):
+                            continue
+                        declared_args = self._generic_type_arguments(params[arg_index])
+                        variable = None
+                        if declared_args:
+                            variable = self._wildcard_upper_bound(declared_args[-1])
+                            if variable is None:
+                                lower = re.match(
+                                    r"^\?\s+super\s+(.+)$", declared_args[-1].strip(),
+                                )
+                                variable = lower.group(1).strip() if lower else declared_args[-1]
+                        if not variable or variable not in method_type_params:
+                            continue
+                        named = [child for child in arg_node.children if child.is_named]
+                        terminal = next(
+                            (child for child in reversed(arg_node.children)
+                             if child.type in {"identifier", "new"}),
+                            None,
+                        )
+                        if not named or terminal is None or terminal.type == "new":
+                            continue
+                        owner_id = self._resolve_declared_type(
+                            self._text(named[0], source), module_name, import_map,
+                            wildcard_packages, enclosing,
+                        )
+                        if owner_id is None:
+                            continue
+                        referenced = [
+                            candidate for candidate in self._members_named(
+                                owner_id, self._text(terminal, source),
+                                search_ancestors=True,
+                            )
+                            if (
+                                not self._is_static_member(candidate)
+                                and len(self._param_type_lists.get(candidate, [])) == 0
+                                and isinstance(
+                                    self.builder._nodes[candidate].metadata.get("java_return_type"),
+                                    str,
+                                )
+                                and self.builder._nodes[candidate].metadata.get("java_return_type") != "void"
+                            )
+                        ]
+                        if len(referenced) == 1:
+                            method_bindings[variable] = self.builder._nodes[
+                                referenced[0]
+                            ].metadata["java_return_type"]
+                    if method_bindings:
+                        parameter = self._replace_type_variables(parameter, method_bindings)
+                    # The parameter is spelled in the candidate's own file.
+                    # Qualify a source-declared SAM there, so the caller
+                    # neither needs its import nor falls back to a global
+                    # simple-name guess (`Executable` is declared by several
+                    # unrelated project interfaces).
+                    raw_head = erased_type(parameter).strip()
+                    while raw_head.endswith("[]"):
+                        # `erased_type()` normalizes a vararg SAM parameter's
+                        # `...` to `[]` — strip it back to the bare interface
+                        # name so a vararg functional-interface parameter
+                        # (`Executable...`) still gets qualified in its
+                        # declaring file's own import context instead of
+                        # skipping straight to the global simple-name guess,
+                        # which is genuinely ambiguous when — as with
+                        # `Executable` in the real JUnit5 corpus — several
+                        # unrelated project interfaces share that name.
+                        raw_head = raw_head[:-2]
+                    if raw_head and "." not in raw_head:
+                        param_ctx = self._param_ctx_for(candidate)
+                        param_id = self._resolve_declared_type(
+                            raw_head, param_ctx.module, param_ctx.import_map,
+                            param_ctx.wildcard_packages, declaring,
+                        )
+                        if param_id is not None and ":" in param_id:
+                            param_module, param_qualname = param_id.rsplit(":", 1)
+                            generic_args = self._generic_type_arguments(parameter)
+                            suffix = (
+                                "<" + ", ".join(generic_args) + ">"
+                                if generic_args else ""
+                            )
+                            parameter = (
+                                f"{self.builder._display_module(param_module)}."
+                                f"{param_qualname}{suffix}"
+                            )
+                    expected.add(parameter)
+                # JDK fluent methods do not have graph nodes, so `_resolve_call`
+                # cannot supply their declaration parameter.  Their receiver
+                # still carries the exact element type, which is sufficient to
+                # target-type the first callable argument without inventing an
+                # external call edge.
+                if (
+                    not expected
+                    and invocation.type == "method_invocation"
+                    and index == 0
+                    and receiver_type is not None
+                    and receiver_args
+                ):
+                    method_node = invocation.child_by_field_name("name")
+                    method_name = self._text(method_node, source) if method_node is not None else ""
+                    raw_receiver = erased_type(receiver_type).rsplit(".", 1)[-1]
+                    element_type = receiver_args[0]
+                    if raw_receiver == "Stream":
+                        if method_name in {"map", "flatMap"}:
+                            expected.add(f"Function<{element_type},Object>")
+                        elif method_name in {"filter", "allMatch", "anyMatch", "noneMatch"}:
+                            expected.add(f"Predicate<{element_type}>")
+                        elif method_name in {"forEach", "forEachOrdered", "peek"}:
+                            expected.add(f"Consumer<{element_type}>")
+                    elif raw_receiver == "Optional":
+                        if method_name in {"map", "flatMap"}:
+                            expected.add(f"Function<{element_type},Object>")
+                        elif method_name == "filter":
+                            expected.add(f"Predicate<{element_type}>")
+                        elif method_name == "ifPresent":
+                            expected.add(f"Consumer<{element_type}>")
+                    elif raw_receiver in {
+                        "Iterable", "Collection", "List", "Set", "ArrayList",
+                        "LinkedList", "HashSet", "SortedSet",
+                    } and method_name == "forEach":
+                        expected.add(f"Consumer<{element_type}>")
+                    elif (
+                        raw_receiver in {
+                            "Map", "HashMap", "LinkedHashMap", "TreeMap",
+                            "ConcurrentMap",
+                        }
+                        and method_name == "forEach"
+                        and len(receiver_args) >= 2
+                    ):
+                        expected.add(
+                            f"BiConsumer<{receiver_args[0]},{receiver_args[1]}>"
+                        )
+                    elif raw_receiver in {
+                        "ObjectAssert", "OptionalAssert", "ListAssert", "IterableAssert",
+                    }:
+                        # AssertJ assert wrappers derived by
+                        # `_assertj_assertthat_return_type` from a preceding
+                        # `assertThat(actual)` -- external declarations, so
+                        # (like the JDK Stream/Optional/Map cases above) their
+                        # fluent methods have no source parameter to read
+                        # from `_resolve_call`. `hasValueSatisfying`/
+                        # `satisfies`/`allSatisfy`/... take a
+                        # `Consumer<? super element>`; `filteredOn`/
+                        # `allMatch`/... take a `Predicate<? super element>`.
+                        if method_name in ASSERTJ_CONSUMER_SATISFIES_METHODS:
+                            expected.add(f"Consumer<{element_type}>")
+                        elif method_name in ASSERTJ_PREDICATE_METHODS:
+                            expected.add(f"Predicate<{element_type}>")
+                if (
+                    not expected
+                    and invocation.type == "method_invocation"
+                    and index == 1
+                    and receiver_type is not None
+                    and len(receiver_args) >= 2
+                ):
+                    method_node = invocation.child_by_field_name("name")
+                    method_name = self._text(method_node, source) if method_node is not None else ""
+                    raw_receiver = erased_type(receiver_type).rsplit(".", 1)[-1]
+                    if raw_receiver in {
+                        "Map", "HashMap", "LinkedHashMap", "TreeMap",
+                        "ConcurrentMap",
+                    } and method_name == "computeIfAbsent":
+                        expected.add(
+                            f"Function<{receiver_args[0]},{receiver_args[1]}>"
+                        )
+                    elif raw_receiver == "MapAssert" and method_name == "hasEntrySatisfying":
+                        # `MapAssert<K,V>.hasEntrySatisfying(K key, Consumer<?
+                        # super V> valueRequirement)` -- the lambda is the
+                        # value-side requirement, not a key/value pair.
+                        expected.add(f"Consumer<{receiver_args[1]}>")
+                if (
+                    not expected
+                    and invocation.type == "method_invocation"
+                    and index == 0
+                    and receiver_class_id is not None
+                ):
+                    method_node = invocation.child_by_field_name("name")
+                    method_name = self._text(method_node, source) if method_node is not None else ""
+                    receiver_node = self.builder._nodes.get(receiver_class_id)
+                    iterable_elements: Set[str] = set()
+                    if receiver_node is not None and method_name == "forEach":
+                        ancestor_texts = (
+                            *receiver_node.metadata.get("java_superclass_args", ()),
+                            *receiver_node.metadata.get("java_implements_args", ()),
+                        )
+                        for ancestor_text in ancestor_texts:
+                            if erased_type(ancestor_text).rsplit(".", 1)[-1] != "Iterable":
+                                continue
+                            ancestor_args = self._generic_type_arguments(ancestor_text)
+                            if len(ancestor_args) == 1:
+                                iterable_elements.add(ancestor_args[0])
+                    if len(iterable_elements) == 1:
+                        expected.add(f"Consumer<{iterable_elements.pop()}>")
+                if len(expected) > 1:
+                    # Every caller of this helper is target-typing a
+                    # lambda/method-reference expression, which JLS requires
+                    # to be a functional interface — a plain type like
+                    # `String` can never be its real target. When sibling
+                    # overload candidates at this argument position disagree
+                    # (e.g. `assertAll(Executable...)` vs. `assertAll(String,
+                    # Executable...)`, both arity-applicable to a call whose
+                    # own callable arguments aren't yet typed), keep only
+                    # whichever candidate(s) actually resolve to a functional
+                    # interface.
+                    functional_only = {
+                        candidate for candidate in expected
+                        if self._functional_descriptor(
+                            candidate, module_name, import_map, wildcard_packages,
+                        ) is not None
+                    }
+                    if len(functional_only) == 1:
+                        expected = functional_only
+                if len(expected) == 1 and receiver_args:
+                    # A receiver typed by one of the caller's own bounded
+                    # method type variables (`<W extends Wrapper<?>>
+                    # List<W>`) target-types the callable as
+                    # `Function<W,...>`.  Inside this method `W` is exactly
+                    # its declared bound, so substitute it.  Only variables
+                    # that flow from the receiver are rewritten; a callee's
+                    # own `<T,R>` stays open for inference.
+                    bounds = self._method_type_param_bounds.get(caller_node.id, {})
+                    receiver_vars = {
+                        erased_type(self._wildcard_upper_bound(arg) or arg).strip()
+                        for arg in receiver_args
+                    }
+                    bounded = {
+                        name: bound for name, bound in bounds.items()
+                        if bound != "Object" and name in receiver_vars
+                    }
+                    if bounded:
+                        expected = {
+                            self._replace_type_variables(expected.pop(), bounded)
+                        }
+                return self._functional_value_type(expected.pop()) if len(expected) == 1 else None
+            cur = parent
+        return None
+
+    def _add_lambda_param_scopes(
+        self, body, source: bytes, module_name: str, import_map: Dict[str, str],
+        wildcard_packages: List[str], local_types: "_LocalScopes",
+        param_types: Dict[str, str], field_types: Dict[str, str], caller_node,
+    ) -> None:
+        # Method facts use the same nested-scope boundary as the former DFS,
+        # so a lambda owned by a nested method/type cannot leak into this
+        # caller's lexical scopes.
+        for node in self._method_facts(body).lambda_expressions:
+            # Keep the explicit guard as a defensive invariant for a future
+            # expansion of the shared fact set.
+            if node.type == "lambda_expression":
+                target_type = self._functional_target_type(
+                    node, source, local_types, param_types, field_types, caller_node,
+                )
+                invocation_target = self._invocation_functional_target_type(
+                    node, source, module_name, import_map, wildcard_packages,
+                    local_types, param_types, field_types, caller_node,
+                )
+                # An enclosing assignment/return/container can provide a
+                # perfectly real *non-functional* type (for example
+                # ``return new Grouping[] { of(..., bean -> ...) }``).  It
+                # must not mask the parameter type of the consuming factory
+                # invocation.  Prefer an outer functional target when it
+                # actually has a SAM; otherwise try the invocation context.
+                descriptor = None
+                for candidate in (target_type, invocation_target):
+                    if candidate is None:
+                        continue
+                    descriptor = self._functional_descriptor(
+                        candidate, module_name, import_map, wildcard_packages,
+                    )
+                    if descriptor is not None:
+                        break
+                params_node = node.child_by_field_name("parameters")
+                lambda_body = node.child_by_field_name("body")
+                if descriptor is not None and params_node is not None and lambda_body is not None:
+                    names = [
+                        self._text(child.child_by_field_name("name"), source)
+                        if child.type == "formal_parameter" and child.child_by_field_name("name")
+                        else self._text(child, source)
+                        for child in (
+                            [params_node] if params_node.type == "identifier"
+                            else [c for c in params_node.children if c.is_named]
+                        )
+                    ]
+                    for name, type_text in zip(names, descriptor.params):
+                        # JLS 15.27.1 forbids a lambda parameter from reusing
+                        # the name of a local/parameter/field already in scope
+                        # at the lambda's own position — such source is
+                        # invalid but still parses, and an earlier pass
+                        # (`_collect_lambda_parameter_scopes`) may have
+                        # already recorded that outer binding as still in
+                        # effect (typed) or explicitly marked this exact name
+                        # as shadowed-with-unknown-type specifically so it
+                        # would *not* resolve through to that outer
+                        # declaration. Query at `node.start_byte` (the
+                        # lambda's own start, before its parameter list comes
+                        # into scope) rather than `lambda_body.start_byte`
+                        # (already inside the lambda's own scope) to see what
+                        # `name` means just *outside* the lambda; if it means
+                        # anything there, this SAM-derived type must not
+                        # silently override that outer fact with a
+                        # same-named-but-different binding — leave whatever
+                        # the earlier pass decided in place ("missing edge
+                        # over wrong edge").
+                        if (
+                            local_types.type_at(name, node.start_byte) is not None
+                            or local_types.declared_at(name, node.start_byte)
+                        ):
+                            continue
+                        # A returned ``Function<Object, R>`` describes the
+                        # resulting function's input, not an ``andThen``
+                        # lambda's input.  Keep a more precise fluent-call
+                        # fact in that one lossy fallback case; other target
+                        # types may still refine placeholders such as ``E``.
+                        existing = local_types.type_at(name, lambda_body.start_byte)
+                        if existing is not None and type_text == "Object" and existing != "Object":
+                            continue
+                        # SAM descriptors are erased (`Predicate<Map.Entry<K,V>>`
+                        # -> `Map.Entry`). The fluent-receiver pass may already
+                        # hold the parameterized element type; its erasure is
+                        # the same class, so keep the more precise fact.
+                        if (
+                            existing is not None and "<" in existing
+                            and erased_type(existing).strip() == erased_type(type_text).strip()
+                        ):
+                            continue
+                        local_types.add(name, type_text, lambda_body.start_byte, node.end_byte)
+
+    @staticmethod
+    def _target_ids(target: Union[str, List[str], None]) -> List[str]:
+        return target if isinstance(target, list) else [target] if target else []
+
+    def _resolve_method_reference(
+        self, ref_node, 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], field_types: Dict[str, str], caller_node,
+    ) -> Tuple[Union[str, List[str], None], float, EdgeType, Dict[str, object]]:
+        named = [child for child in ref_node.children if child.is_named]
+        if not named:
+            return None, 0.0, EdgeType.CALLABLE_REF, {}
+        qualifier = named[0]
+        terminal = next((c for c in reversed(ref_node.children) if c.type in {"identifier", "new"}), None)
+        if terminal is None:
+            return None, 0.0, EdgeType.CALLABLE_REF, {}
+        name = self._text(terminal, source)
+        target_type = self._functional_target_type(
+            ref_node, source, local_types, param_types, field_types, caller_node,
+        )
+        target_type = target_type or self._invocation_functional_target_type(
+            ref_node, source, module_name, import_map, wildcard_packages,
+            local_types, param_types, field_types, caller_node,
+        )
+        descriptor = self._functional_descriptor(
+            target_type, module_name, import_map, wildcard_packages,
+        )
+        fallback_arity = None
+        if descriptor is None:
+            arity = self._method_reference_context_arity(ref_node, source)
+            if arity is not None:
+                descriptor = _SAMDescriptor(["Object"] * arity, None)
+                fallback_arity = arity
+        ctx = _ImportContext(module_name, import_map, wildcard_packages)
+        meta: Dict[str, object] = {
+            "strategy": "method_reference", "reference_kind": "unknown",
+            **({"functional_type": target_type} if target_type else {}),
+        }
+
+        if name == "new":
+            if qualifier.type == "array_type":
+                # `Type[]::new` allocates an array; it invokes none of
+                # `Type`'s instance constructors (JLS 15.13.3), so it must
+                # not be attributed to any of them.
+                meta["reference_kind"] = "array_constructor"
+                return None, 0.0, EdgeType.CALLABLE_REF, meta
+            class_id = self._resolve_declared_type(
+                self._text(qualifier, source), module_name, import_map, wildcard_packages,
+            )
+            cls = self.builder._nodes.get(class_id) if class_id else None
+            if cls is None or cls.metadata.get("java_type_kind") in {"interface", "enum"}:
+                return None, 0.0, EdgeType.CALLABLE_REF, meta
+            meta["reference_kind"] = "constructor"
+            ctors = self._members_named(class_id, cls.name, search_ancestors=False)
+            expected_return = descriptor.return_type if descriptor else None
+            if expected_return not in (None, "void") and not self._types_compatible(
+                expected_return, cls.name, ctx,
+                self._file_ctx.get(cls.file_path, _ImportContext(cls.module, {}, [])),
+                allow_boxing=True,
+            ):
+                return None, 0.0, EdgeType.CALLABLE_REF, meta
+            if descriptor is None:
+                target: Union[str, List[str], None] = ctors[0] if len(ctors) == 1 else ctors or None
+                conf = 0.7 if len(ctors) == 1 else 0.4
+            elif ctors:
+                target, conf = self._select_overload(
+                    ctors, len(descriptor.params), descriptor.params, lambda _c: 0.95, ctx,
+                )
+                if target is None and fallback_arity is not None:
+                    # The JDK fluent/collector call may not supply the
+                    # referenced constructor's true parameter types either;
+                    # mirror the static/unbound and bound-instance fallbacks
+                    # below instead of rejecting a unique-arity candidate
+                    # because the placeholder Object type is too broad.
+                    fallback = [c for c in ctors if self._arity_matches(c, fallback_arity)]
+                    if len(fallback) == 1:
+                        target, conf = fallback[0], 0.7
+            else:
+                implicit_arity = len(cls.metadata.get("record_component_types", []))
+                valid = len(descriptor.params) == (implicit_arity if cls.metadata.get("java_type_kind") == "record" else 0)
+                return (class_id, 0.85, EdgeType.INSTANTIATES, meta) if valid else (
+                    None, 0.0, EdgeType.INSTANTIATES, meta
+                )
+            if isinstance(target, list):
+                meta["candidate"] = True
+                conf = min(conf, 0.45)
+            return target, conf, EdgeType.CALLABLE_REF, meta
+
+        bound_class: Optional[str] = None
+        reference_kind = "bound"
+        if qualifier.type == "this":
+            bound_class = enclosing_class_id
+        elif qualifier.type == "super":
+            if enclosing_class_id:
+                candidates = self._members_named(
+                    enclosing_class_id, name, search_ancestors=True, search_self=False,
+                )
+                if descriptor:
+                    candidates = [
+                        c for c in candidates
+                        if self._method_reference_return_compatible(c, descriptor.return_type, ctx)
+                    ]
+                target, conf = self._select_overload(
+                    [c for c in candidates if not self._is_static_member(c)],
+                    len(descriptor.params), descriptor.params, lambda _c: 0.85, ctx,
+                ) if descriptor is not None else (
+                    (candidates[0], 0.7) if len(candidates) == 1 else (candidates or None, 0.4)
+                )
+                meta["reference_kind"] = "super"
+                if isinstance(target, list):
+                    meta["candidate"] = True
+                return target, conf, EdgeType.CALLABLE_REF, meta
+        else:
+            qtext = self._text(qualifier, source)
+            is_value = (
+                (qualifier.type == "identifier" and (
+                    local_types.type_at(qtext, qualifier.start_byte) is not None
+                    or qtext in param_types or qtext in field_types
+                ))
+                or qualifier.type in {
+                    "field_access", "object_creation_expression",
+                    "method_invocation", "parenthesized_expression",
+                    "cast_expression", "array_access",
+                }
+            )
+            if qualifier.type == "field_access":
+                # A dotted qualifier is a value only when its leftmost name
+                # is one: `this.delegate::run`, `holder.field::run`.  A
+                # package/outer-type path (`org.acme.Resource::of`,
+                # `Outer.Inner::create`) has the same CST shape but names a
+                # type, whose static and unbound members follow below.
+                head = qualifier
+                while head.type == "field_access":
+                    head = head.child_by_field_name("object")
+                head_is_value = head is None or head.type != "identifier" or (
+                    local_types.type_at(self._text(head, source), head.start_byte) is not None
+                    or self._text(head, source) in param_types
+                    or self._text(head, source) in field_types
+                )
+                if not head_is_value and self._resolve_declared_type(
+                    qtext, module_name, import_map, wildcard_packages,
+                ) is not None:
+                    is_value = False
+            if is_value:
+                bound_class, _ = self._resolve_receiver(
+                    qualifier, source, module_name, enclosing_class_id, import_map,
+                    wildcard_packages, local_types, field_types, param_types,
+                )
+            else:
+                type_class = self._resolve_declared_type(
+                    qtext, module_name, import_map, wildcard_packages,
+                )
+                if type_class is not None:
+                    candidates = self._members_named(type_class, name, search_ancestors=True)
+                    static = [c for c in candidates if self._is_static_member(c)]
+                    instance = [c for c in candidates if not self._is_static_member(c)]
+                    if descriptor:
+                        static = [
+                            c for c in static
+                            if self._method_reference_return_compatible(c, descriptor.return_type, ctx)
+                        ]
+                        instance = [
+                            c for c in instance
+                            if self._method_reference_return_compatible(c, descriptor.return_type, ctx)
+                        ]
+                    if descriptor is None:
+                        all_candidates = static + instance
+                        target = all_candidates[0] if len(all_candidates) == 1 else all_candidates or None
+                        conf = 0.65 if len(all_candidates) == 1 else 0.4
+                    else:
+                        st, st_conf = self._select_overload(
+                            static, len(descriptor.params), descriptor.params, lambda _c: 0.9, ctx,
+                        )
+                        unbound: Union[str, List[str], None] = None
+                        unbound_conf = 0.0
+                        if descriptor.params and (
+                            target_type is None
+                            or re.fullmatch(r"[A-Z]", descriptor.params[0])
+                            or self._types_compatible(
+                                qtext, descriptor.params[0], ctx, ctx,
+                            )
+                        ):
+                            unbound, unbound_conf = self._select_overload(
+                                instance, len(descriptor.params) - 1, descriptor.params[1:],
+                                lambda _c: 0.9, ctx,
+                            )
+                        winners = self._target_ids(st) + self._target_ids(unbound)
+                        winners = list(dict.fromkeys(winners))
+                        if (
+                            not winners
+                            and descriptor.params
+                            and all(re.fullmatch(r"[A-Z]", item) for item in descriptor.params)
+                        ):
+                            # A generic SAM such as `Function<T,R>` can infer
+                            # T from a unique static source reference. Its
+                            # still-open input variable is not an incompatible
+                            # concrete argument; arity plus uniqueness is the
+                            # bounded inference proof at this point.
+                            inferred_static = [
+                                candidate for candidate in static
+                                if self._arity_matches(candidate, len(descriptor.params))
+                            ]
+                            if len(inferred_static) == 1:
+                                winners = inferred_static
+                        if not winners and fallback_arity is not None:
+                            # External Stream/Optional declarations may not
+                            # provide element generic metadata. Preserve the
+                            # method-reference edge when arity identifies a
+                            # unique static/instance candidate; parameter
+                            # compatibility remains enforced when a real SAM
+                            # descriptor is available.
+                            fallback = [
+                                c for c in static + instance
+                                if len(self._param_type_lists.get(c, []))
+                                == (fallback_arity if self._is_static_member(c)
+                                    else fallback_arity - 1)
+                            ]
+                            if len(fallback) == 1:
+                                winners = fallback
+                        target = winners[0] if len(winners) == 1 else winners or None
+                        conf = max(st_conf, unbound_conf) if len(winners) == 1 else 0.45
+                    meta["reference_kind"] = (
+                        "static" if self._target_ids(target) and all(
+                            self._is_static_member(t) for t in self._target_ids(target)
+                        ) else "unbound"
+                    )
+                    if isinstance(target, list):
+                        meta["candidate"] = True
+                    return target, conf, EdgeType.CALLABLE_REF, meta
+
+        if bound_class is None:
+            return None, 0.0, EdgeType.CALLABLE_REF, meta
+        candidates = [
+            c for c in self._members_named(bound_class, name, search_ancestors=True)
+            if not self._is_static_member(c)
+        ]
+        if descriptor:
+            candidates = [
+                c for c in candidates
+                if self._method_reference_return_compatible(c, descriptor.return_type, ctx)
+            ]
+        if descriptor is None:
+            target = candidates[0] if len(candidates) == 1 else candidates or None
+            conf = 0.7 if len(candidates) == 1 else 0.4
+        else:
+            target, conf = self._select_overload(
+                candidates, len(descriptor.params), descriptor.params, lambda _c: 0.9, ctx,
+            )
+            if (
+                target is None
+                and descriptor.params
+                and all(re.fullmatch(r"[A-Z]", item) for item in descriptor.params)
+            ):
+                # Bound `this::method` references passed to `Consumer<T>` or
+                # `Function<T,R>` infer their open input variables from the
+                # referenced method. Keep this to one exact-arity candidate;
+                # overloaded references remain unresolved.
+                inferred = [
+                    candidate for candidate in candidates
+                    if self._arity_matches(candidate, len(descriptor.params))
+                ]
+                if len(inferred) == 1:
+                    target, conf = inferred[0], 0.85
+            if target is None and fallback_arity is not None:
+                # The JDK fluent receiver can be external and therefore
+                # unable to supply its element type. For a proven bound
+                # receiver, a unique same-name instance member with the SAM
+                # arity is still unambiguous (`repository::create`); mirror
+                # the static/unbound fallback above instead of rejecting it
+                # because the placeholder Object type is too broad.
+                fallback = [
+                    candidate for candidate in candidates
+                    if self._arity_matches(candidate, fallback_arity)
+                ]
+                if len(fallback) == 1:
+                    target, conf = fallback[0], 0.7
+        meta["reference_kind"] = reference_kind
+        if isinstance(target, list):
+            meta["candidate"] = True
+            conf = min(conf, 0.45)
+        return target, conf, EdgeType.CALLABLE_REF, meta
+
+    def _method_reference_context_arity(
+        self, node, source: bytes,
+    ) -> Optional[int]:
+        """Narrow fallback for external JDK calls lacking indexed signatures.
+
+        Maps the enclosing JDK Stream/Optional method to the arity of the
+        functional interface its argument must implement: element consumers
+        (`map`, `filter`, ...) take one parameter; `Supplier` consumers
+        (`orElseGet`, `orElseThrow`, `Optional.or`) take none, so a bound
+        reference such as `formattable::getAbbreviatedFullName` passed to
+        `orElseGet` must select the zero-argument overload rather than fan out
+        across every same-name member. Anything else stays unknown."""
+        parent = node.parent
+        if parent is not None and parent.type == "argument_list":
+            invocation = parent.parent
+            if invocation is not None and invocation.type == "method_invocation":
+                name_node = invocation.child_by_field_name("name")
+                if name_node is not None:
+                    name = self._text(name_node, source)
+                    arity = _JDK_FUNCTIONAL_ARGUMENT_ARITY.get(name)
+                    if arity is not None:
+                        return arity
+                    indexed = _JDK_INDEXED_FUNCTIONAL_ARITY.get(name)
+                    if indexed is not None:
+                        args = argument_nodes(parent)
+                        try:
+                            index = args.index(node)
+                        except ValueError:
+                            return None
+                        if index < len(indexed):
+                            return indexed[index]
+        return None
+
+    @staticmethod
+    def _container_name(node, source: bytes) -> Optional[str]:
+        if node is None:
+            return None
+        if node.type == "identifier":
+            return source[node.start_byte:node.end_byte].decode("utf-8", errors="replace")
+        if node.type == "field_access":
+            field = node.child_by_field_name("field")
+            if field is not None:
+                return source[field.start_byte:field.end_byte].decode("utf-8", errors="replace")
+        return None
+
+    def _local_callable_targets(
+        self, body, source: bytes, resolved_refs: Dict[int, Set[str]],
+    ) -> Dict[str, Set[str]]:
+        out: Dict[str, Set[str]] = defaultdict(set)
+        for ref in self._collect_method_references(body):
+            targets = resolved_refs.get(ref.start_byte)
+            if not targets:
+                continue
+            cur = ref
+            while cur.parent is not None and cur.parent is not body:
+                parent = cur.parent
+                if parent.type == "variable_declarator":
+                    name = parent.child_by_field_name("name")
+                    if name is not None:
+                        out[self._text(name, source)].update(targets)
+                    break
+                if parent.type == "assignment_expression":
+                    container = self._container_name(
+                        parent.child_by_field_name("left"), source,
+                    )
+                    if container:
+                        out[container].update(targets)
+                    break
+                if parent.type == "argument_list" and parent.parent is not None:
+                    invocation = parent.parent
+                    name_node = invocation.child_by_field_name("name")
+                    if name_node is not None and self._text(name_node, source) == "put":
+                        container = self._container_name(
+                            invocation.child_by_field_name("object"), source,
+                        )
+                        if container:
+                            out[container].update(targets)
+                        break
+                cur = parent
+        return out
+
+    def _resolve_callable_container_dispatch(
+        self, call_node, source: bytes, enclosing_class_id: Optional[str],
+        local_targets: Dict[str, Set[str]],
+        local_types: "_LocalScopes", own_param_types: Dict[str, str],
+    ) -> Optional[Tuple[List[str], float, Dict[str, object]]]:
+        name_node = call_node.child_by_field_name("name")
+        obj = call_node.child_by_field_name("object")
+        if name_node is None or obj is None or self._text(name_node, source) not in {
+            "run", "call", "apply", "accept", "test",
+        }:
+            return None
+        container_node = obj
+        if obj.type == "method_invocation":
+            inner_name = obj.child_by_field_name("name")
+            if inner_name is None or self._text(inner_name, source) not in {"get", "getOrDefault"}:
+                return None
+            container_node = obj.child_by_field_name("object")
+        container = self._container_name(container_node, source)
+        if not container:
+            return None
+        targets = set(local_targets.get(container, set()))
+        # A local variable or parameter of the same name shadows a
+        # same-named field (Java scoping rules) — the field's callable
+        # table must not be consulted in that case, or a call through an
+        # unrelated locally/parameter-typed receiver gets misattributed to
+        # the shadowed field's bound method reference. Only a *bare*
+        # identifier receiver is subject to shadowing this way — an
+        # explicit field access (`this.task`, or any `x.task`) already
+        # names the field unambiguously and is never shadowed by a
+        # same-named local/parameter.
+        shadowed_by_local = container_node.type == "identifier" and (
+            container in own_param_types
+            or local_types.type_at(container, container_node.start_byte) is not None
+            # A `var` local whose initializer type couldn't be resolved
+            # (e.g. an external factory call) is still a real declaration
+            # that shadows the field — `type_at` alone would miss it
+            # ("missing edge over wrong edge" left it out of `_by_name`).
+            or local_types.declared_at(container, container_node.start_byte)
+        )
+        if enclosing_class_id and not shadowed_by_local:
+            for owner in [enclosing_class_id, *self._class_ancestors(enclosing_class_id)]:
+                targets.update(self._field_callable_targets.get(owner, {}).get(container, set()))
+        if not targets:
+            return None
+        return sorted(targets), (0.8 if len(targets) == 1 else 0.6), {
+            "strategy": "callable_container", "container": container,
+            "candidate": len(targets) > 1,
+        }
+
+    def _index_field_callable_targets(
+        self, parses: Dict[Path, ParseResult],
+        class_id_by_position: Dict[Tuple[str, int, int], str],
+        func_id_by_position: Dict[Tuple[str, int, int], str],
+    ) -> Dict[str, Dict[str, Set[str]]]:
+        out: Dict[str, Dict[str, Set[str]]] = defaultdict(lambda: defaultdict(set))
+        for path, parse in parses.items():
+            fp = str(path)
+            ctx = self._file_ctx.get(fp)
+            if ctx is None:
+                continue
+            source = parse.source_bytes
+            for node in self._field_declarations(parse.tree.root_node, fp):
+                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(
+                    (fp, owner_node.start_point[0] + 1, owner_node.start_point[1]),
+                )
+                owner = self.builder._nodes.get(owner_id) if owner_id else None
+                if owner is None:
+                    continue
+                fields = self._all_field_types(owner_id)
+                for declarator in [c for c in node.children if c.type == "variable_declarator"]:
+                    name_node = declarator.child_by_field_name("name")
+                    value = declarator.child_by_field_name("value")
+                    if name_node is None or value is None:
+                        continue
+                    field_name = self._text(name_node, source)
+                    refs: List[object] = []
+                    ref_stack = [value]
+                    while ref_stack:
+                        child = ref_stack.pop()
+                        if child.type == "method_reference":
+                            refs.append(child)
+                        ref_stack.extend(child.children)
+                    for ref in refs:
+                        target, confidence, etype, meta = self._resolve_method_reference(
+                            ref, source, ctx.module, owner_id, ctx.import_map,
+                            ctx.wildcard_packages, _LocalScopes(), {}, fields, owner,
+                        )
+                        target_ids = self._target_ids(target)
+                        out[owner_id][field_name].update(target_ids)
+                        for tid in target_ids:
+                            if tid not in self.builder._nodes or (owner_id, tid, etype) in self.builder._edge_keys:
+                                continue
+                            self.builder._add_edge(GraphEdge(
+                                source=owner_id, target=tid, edge_type=etype,
+                                file_path=fp, line=ref.start_point[0] + 1,
+                                column=ref.start_point[1], confidence=confidence,
+                                metadata=meta, strategy="java_resolver",
+                            ))
+                            # `field = Type::method;` is a reference, not an
+                            # invocation — see the matching note in
+                            # orchestration.py's _resolve_method_reference_pass.
+                            # Leave .calls/.called_by (true-invocation
+                            # bookkeeping) untouched.
+
+            # Field containers populated in a constructor/setup method must
+            # be available before any dispatch method is visited; method CST
+            # traversal order is intentionally not source-order-dependent.
+            for func_cst, caller_id in self._iter_method_cst(
+                parse.tree.root_node, fp, func_id_by_position,
+            ):
+                owner_id = self._declaring_class_id(caller_id)
+                body = func_cst.child_by_field_name("body")
+                caller = self.builder._nodes.get(caller_id)
+                if owner_id is None or body is None or caller is None:
+                    continue
+                fields = self._all_field_types(owner_id)
+                local_types = self._collect_local_scopes(body, source)
+                params = dict(zip(
+                    self._param_names(func_cst, source),
+                    self._param_type_lists.get(caller_id, []),
+                ))
+                for ref in self._collect_method_references(body):
+                    container: Optional[str] = None
+                    cur = ref
+                    while cur.parent is not None and cur.parent is not body:
+                        parent = cur.parent
+                        if parent.type == "assignment_expression":
+                            container = self._container_name(
+                                parent.child_by_field_name("left"), source,
+                            )
+                            break
+                        if parent.type == "argument_list" and parent.parent is not None:
+                            invocation = parent.parent
+                            called = invocation.child_by_field_name("name")
+                            if called is not None and self._text(called, source) == "put":
+                                container = self._container_name(
+                                    invocation.child_by_field_name("object"), source,
+                                )
+                                break
+                        cur = parent
+                    if (
+                        not container or container not in fields
+                        or container in params
+                        or local_types.type_at(container, ref.start_byte) is not None
+                    ):
+                        continue
+                    target, _, _, _ = self._resolve_method_reference(
+                        ref, source, ctx.module, owner_id, ctx.import_map,
+                        ctx.wildcard_packages, local_types, params, fields, caller,
+                    )
+                    out[owner_id][container].update(self._target_ids(target))
+        return out