adl-toolkit 0.0.0-stage → 0.1.1

package/adl_drift/lang/java/resolver.py

@@ -0,0 +1,1401 @@
+"""Java call-resolution strategy (P4.4, PROBLEMS.md).
+
+Much smaller than Python's `lang/python/resolver.py`: Java declares every
+receiver type, so most Python type-*inference* machinery has no Java
+counterpart — a receiver's class is read straight off the declaration
+(`formal_parameter`/`local_variable_declaration`/`field_declaration` type
+text), while fluent calls propagate source methods' declared return types.
+What Java adds instead is **method overloading**: a class may hold
+several `Symbol`s sharing one name, distinguished only by P4.5's
+`signature_key` id discriminator, so a call site must pick *which* one it
+means. Abstract-type dispatch (interface/DI resolution — "given a declared
+interface type, which concrete implementation runs") is the genuinely hard
+Java problem, deliberately punted to P4.12 — this resolver only walks
+INHERITS/IMPLEMENTS for declared types and their ancestors, it never fans
+out across sibling implementors of an interface.
+
+Owns:
+- `JAVA_BUILTINS` — the P2.7-equivalent deny-list: `java.lang.Object`
+  methods + common `Collection`/`Map`/`Iterator` method names, replacing
+  `PYTHON_BUILTINS`.
+- `JAVA_ANNOTATION_STUB_TABLE` — Lombok-style annotation simple name ->
+  name-*prefixes* it generates on the annotated class (`@Getter` -> `get`/
+  `is`, `@Data` -> `get`/`is`/`set`/`toString`/`hashCode`/`equals`/
+  `canEqual`, ...). Prefixes, not exact names, because Lombok's generated
+  method names are field-dependent (`getName()`) — unlike Python's
+  `DECORATOR_STUB_TABLE`, which lists the exact fixed attribute names a
+  decorator wrapper adds (`delay`, `cache_clear`, ...). Spring AOP/DI
+  dispatch is explicitly **not** here — that is P4.12.
+- `JavaCallResolver` — `this`/`super` receivers, typed-receiver direct
+  dispatch (local var / parameter / field, with recursive `field_access`
+  chains so `this.userService.findById(id)` unwraps through the field's
+  declared type per codegraph-java-deep-dive.md §5.3), overload
+  disambiguation by arg count then statically-known arg types, generic
+  erasure via `lang.java.ids.erased_type()`, and the annotation-stub
+  fallback.
+
+Grammar-agnostic graph-id resolution (`_resolve_name`, `_contains_child`,
+edge dedupe, `_symbol_to_id`) stays on `CallGraphBuilder`, reused unchanged
+from the Python resolver.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from collections import defaultdict, deque
+from pathlib import Path
+from typing import (
+    TYPE_CHECKING, Callable, Dict, FrozenSet, List, Optional, Set, Tuple, Union,
+)
+
+from adl_drift.graph.edges import EdgeType, GraphEdge
+from adl_drift.graph.node import GraphNode, NodeType
+from adl_drift.lang.base import CallResolver, ParseResult, ResolverConfig
+from adl_drift.lang.java.ids import DEFAULT_PACKAGE, erased_type
+from adl_drift.lang.java.resolution.generated import GeneratedMembersMixin
+from adl_drift.lang.java.resolution.functional import FunctionalResolutionMixin
+from adl_drift.lang.java.resolution.scopes import ScopeInferenceMixin
+from adl_drift.lang.java.resolution.types import TypeResolutionMixin
+from adl_drift.lang.java.resolution.overloads import OverloadResolutionMixin
+from adl_drift.lang.java.resolution.constructors import ConstructorResolutionMixin
+from adl_drift.lang.java.resolution.context import ContextResolutionMixin
+from adl_drift.lang.java.resolution.orchestration import ResolutionOrchestrationMixin
+from adl_drift.lang.java.resolution.dispatch import DispatchMixin
+from adl_drift.lang.java.resolution.model import (
+    BeanCandidate as _BeanCandidate,
+    DINarrowResult as _DINarrowResult,
+    ImportContext as _ImportContext,
+    InjectedFieldMetadata as _InjectedFieldMetadata,
+    LocalScopes as _LocalScopes,
+    SAMDescriptor as _SAMDescriptor,
+)
+from adl_drift.utils.types import AnalysisResult
+
+if TYPE_CHECKING:
+    from adl_drift.graph.builder import CallGraphBuilder
+
+__all__ = [
+    "JAVA_BUILTINS",
+    "JAVA_ANNOTATION_STUB_TABLE",
+    "JavaCallResolver",
+    "default_java_resolver_config",
+]
+
+from adl_drift.lang.java.resolution.constants import (
+    JAVA_ANNOTATION_STUB_TABLE,
+    JAVA_BUILTINS,
+    JAVA_COMPONENT_ANNOTATIONS,
+    JAVA_DI_ANNOTATION_FQNS,
+    JAVA_INJECTION_ANNOTATIONS,
+    JAVA_OPTIONAL_ELEMENT_LAMBDA_METHODS,
+    JAVA_STREAM_ELEMENT_LAMBDA_METHODS,
+    _ANNOTATION_STRING_ARG,
+    _CONCRETE_TYPE_KINDS,
+    _CONF_DI_SINGLE_COMPONENT,
+    _CONF_MULTI_IMPLEMENTOR,
+    _CONF_SINGLE_IMPLEMENTOR,
+    _CONF_SPRING_PRIMARY,
+    _CONF_SPRING_QUALIFIER,
+    _DEFAULT_FANOUT_CAP,
+    _DEFAULT_FANOUT_MODE,
+    _ENCLOSING_TYPE_CST_TYPES,
+    _FANOUT_MODES,
+    _JDK_SAM_PARAMS,
+    _JDK_SAM_RETURNS,
+    _LAMBDA_ARG_TYPE,
+    _METHOD_CST_TYPES,
+    _NESTED_SCOPE_BOUNDARY,
+    _NULL_ARG_TYPE,
+    argument_nodes,
+)
+
+
+def default_java_resolver_config() -> ResolverConfig:
+    """The real Java `ResolverConfig` — returned by `JavaBackend.resolver_config()`."""
+    cfg = ResolverConfig(
+        receiver_self_names=("this",),
+        receiver_super_names=("super",),
+        builtins_deny_list=frozenset(JAVA_BUILTINS),
+        annotation_stub_table=dict(JAVA_ANNOTATION_STUB_TABLE),
+    )
+    cfg.resolver_factory = lambda builder, config: JavaCallResolver(builder, config)
+    return cfg
+
+
+class JavaCallResolver(
+    ResolutionOrchestrationMixin, ContextResolutionMixin, ConstructorResolutionMixin, OverloadResolutionMixin, TypeResolutionMixin, GeneratedMembersMixin, FunctionalResolutionMixin, ScopeInferenceMixin,
+    DispatchMixin, CallResolver
+):
+    """Java's `CallResolver` (P4.4)."""
+
+    def __init__(self, builder: "CallGraphBuilder", config: ResolverConfig) -> None:
+        super().__init__(builder, config)
+        # Rebuilt at the start of every resolve_calls() — see there.
+        self._by_module_symbol: Dict[str, Dict[str, str]] = {}
+        self._field_types: Dict[str, Dict[str, str]] = {}
+        self._param_type_lists: Dict[str, List[str]] = {}
+        # function id -> the method's own generic type-parameter bounds.
+        # A formal `A` in `<A extends Appendable> A append(A value)` is an
+        # inference variable, not a project class literally named `A`.
+        self._method_type_param_bounds: Dict[str, Dict[str, str]] = {}
+        # Per-resolution-run caches, (re)set by `_build_resolution_indexes`;
+        # None/empty outside a run so helper calls before/after stay uncached.
+        self._method_cst_cache: Optional[Dict[str, tuple]] = None
+        self._cst_index_cache: Optional[Dict[str, tuple]] = None
+        self._method_facts_cache: Optional[Dict[int, object]] = None
+        self._local_scopes_cache: Optional[Dict[tuple, object]] = None
+        self._declaring_class_cache: Optional[Dict[str, Optional[str]]] = None
+        self._members_by_name_cache: Optional[Dict[str, Dict[str, List[str]]]] = None
+        self._declared_type_memo: Optional[Dict[tuple, Optional[str]]] = None
+        self._file_import_map_ids: frozenset = frozenset()
+        # Keyed by `GraphNode.file_path` (str), *not* module name: Java's
+        # module id is the declared `package` (see `module_name_from_parse`),
+        # so multiple files routinely share one module — caching by module
+        # would pick one arbitrary file's imports for all of them. Every
+        # `GraphNode` (including FUNCTION) carries its own `file_path`, so
+        # this stays precise down to the file that actually declared each
+        # candidate's parameter types.
+        self._file_ctx: Dict[str, _ImportContext] = {}
+        # {file_path: [fully-qualified class path, ...]} for each file's
+        # `import static a.b.C.*;` declarations — the classes a bare call in
+        # that file may resolve a static member against (see `_resolve_call`).
+        self._static_wildcard_by_file: Dict[str, List[str]] = {}
+        # Annotation types (`@interface Foo {}`) declared *in the analyzed
+        # source*, keyed by simple name -> the set of FQNs (declaring
+        # file's package + simple name) that simple name resolves to
+        # somewhere in the project. A real Lombok annotation is always
+        # external, so a locally-declared annotation sharing a stub-table
+        # name (`@interface Getter {}`) is proof *that specific FQN* is not
+        # Lombok — the annotation-stub fallback must skip it (see
+        # `_annotation_stub_match`). Keyed by FQN, not bare simple name
+        # (F-02 fix): a simple-name-only set can't tell a locally-declared
+        # `foo.Getter` from an unrelated `app.Getter` used as
+        # `@lombok.Getter` elsewhere, so *any* package declaring
+        # `@interface Getter` used to blind the stub fallback project-wide.
+        self._local_annotation_type_names: Dict[str, Set[str]] = {}
+        # P4.12 reverse hierarchy index: interface/abstract CLASS id -> every
+        # transitive subtype CLASS id (reverse of INHERITS ∪ IMPLEMENTS). The
+        # implementor fan-out walks this. Rebuilt each resolve_calls().
+        self._subtypes: Dict[str, Set[str]] = {}
+        # class id -> {field_name: field VARIABLE node id}, for reading a
+        # receiver field's injection annotations (@Autowired/@Qualifier) during
+        # DI narrowing. Own declarations only; `_all_field_node_ids` merges
+        # ancestors on demand.
+        self._field_nodes: Dict[str, Dict[str, str]] = {}
+        # Enclosing class -> field name -> unanimous concrete allocation.
+        self._field_allocation_types: Dict[str, Dict[str, str]] = {}
+        # class id -> declared generic type parameter names, e.g. Box<T> -> ["T"].
+        self._class_type_params: Dict[str, List[str]] = {}
+        # class id -> upper bounds for its declared type parameters. This is
+        # distinct from method inference bounds: a raw receiver inside the
+        # declaring generic class still has its declaration-site upper bound.
+        self._class_type_param_bounds: Dict[str, Dict[str, str]] = {}
+        # (class_id, ancestor_class_id) -> the raw type-argument texts used in
+        # that class's own `extends`/`implements` clause, e.g.
+        # `StripeBox extends Box<Stripe>` -> {(StripeBox, Box): ["Stripe"]}.
+        # Lets a generic method's return type resolve through inheritance
+        # (F-01), not just when the receiver's own declared type at the call
+        # site carries the argument directly.
+        self._ancestor_type_args: Dict[Tuple[str, str], List[str]] = {}
+        # `@Bean` factory-method candidates: a `@Bean T make()` in a config
+        # class registers `T` as an injectable bean even when `T` carries no
+        # `@Component` annotation of its own (deep-dive §7.3).
+        self._bean_method_candidates: List[_BeanCandidate] = []
+        # Fields injected via constructor param assignment or a Spring
+        # setter (`@Autowired void setX(T v) { this.x = v; }`) — merged from
+        # both indexes in `resolve_calls` since `_is_injected_field`/
+        # `_field_qualifier` don't care which classical DI style produced
+        # the evidence.
+        self._di_injected_fields: Dict[str, _InjectedFieldMetadata] = {}
+        # P4.13: callable targets stored in Map-like fields, keyed by
+        # declaring class then field name. Used by `handlers.get(k).run()`.
+        self._field_callable_targets: Dict[str, Dict[str, Set[str]]] = {}
+        # Precision↔recall dial, read once from the environment (see
+        # `_FANOUT_MODES`). `DRIFT_RECALL_MODE=1` (P2.21's own flag) forces
+        # recall; `DRIFT_JAVA_FANOUT_MODE` selects a mode explicitly and wins
+        # over it.
+        self._fanout_mode = self._read_fanout_mode()
+        self._fanout_cap = self._read_fanout_cap()
+        # P4 telemetry: keep decision-level data because a capped call site
+        # emits no fan-out edge and cannot be reconstructed from the graph.
+        self.fanout_telemetry: Dict[str, object] = {
+            "mode": self._fanout_mode, "cap": self._fanout_cap,
+            "candidate_counts": [], "emitted_counts": [], "cap_skipped": 0,
+        }
+        # P4.6: lazily built, cached `JavaSymbolExtractor` used only by
+        # `_iter_func_cst` (below) to derive taint function ids the same way
+        # the real graph nodes were built.
+        self._method_extractor_cache: Optional["object"] = None
+        # Exact source-declared hierarchy, resolved with the same qualified
+        # type rules as receivers.  The shared graph relationship pass keeps
+        # a simple-name index for all languages; in a Java package containing
+        # many nested classes with the same simple name that index can attach
+        # an INHERITS edge to the wrong class.  Resolver dispatch must retain
+        # the declaration's package/member qualification independently.
+        self._declared_direct_ancestors: Dict[Tuple[str, EdgeType], List[str]] = {}
+        # BFS-result cache for `_class_ancestors`, reset alongside
+        # `_declared_direct_ancestors` above (see orchestration.py's
+        # `_build_resolution_indexes`) — see `_class_ancestors`'s docstring.
+        self._class_ancestors_cache: Dict[str, List[str]] = {}
+        # Result cache for `_contains_children`, reset the same way — see
+        # its docstring.
+        self._contains_children_cache: Dict[str, List[str]] = {}
+
+    @staticmethod
+    def _read_fanout_mode() -> str:
+        explicit = os.environ.get("DRIFT_JAVA_FANOUT_MODE", "").strip().lower()
+        if explicit in _FANOUT_MODES:
+            return explicit
+        if os.environ.get("DRIFT_RECALL_MODE", "0") == "1":
+            return "recall"
+        return _DEFAULT_FANOUT_MODE
+
+    @staticmethod
+    def _read_fanout_cap() -> int:
+        raw = os.environ.get("DRIFT_JAVA_FANOUT_MAX", "").strip()
+        if raw.isdigit() and int(raw) > 0:
+            return int(raw)
+        return _DEFAULT_FANOUT_CAP
+
+    # ------------------------------------------------------------------ main pass
+
+    def resolve_calls(
+        self,
+        parses: Dict[Path, ParseResult],
+        results: Dict[Path, AnalysisResult],
+    ) -> int:
+        """Resolve Java calls through the stable orchestration pass."""
+        return self._run_resolution_passes(parses, results)
+
+    @staticmethod
+    def _text(node, source: bytes) -> str:
+        return source[node.start_byte:node.end_byte].decode("utf-8", errors="replace")
+
+    def _build_bean_method_candidates(self) -> List[_BeanCandidate]:
+        """`@Bean`-annotated factory methods (deep-dive §7.3): a
+        `@Bean SomeImpl make() { ... }` in a `@Configuration` class registers
+        `SomeImpl` as an injectable bean even when `SomeImpl` itself carries no
+        `@Component` annotation. Resolves each such method's declared return
+        type (persisted as `java_return_type`) to a concrete CLASS node; the
+        method's own `@Qualifier`/`@Primary`/bean name feed the same narrowing
+        as a component class's would."""
+        out: List[_BeanCandidate] = []
+        for nid, node in self.builder._nodes.items():
+            if node.node_type != NodeType.FUNCTION or not node.decorators:
+                continue
+            names = {self._di_annotation_simple_name(d, node.file_path) for d in node.decorators}
+            if "Bean" not in names:
+                continue
+            return_type = node.metadata.get("java_return_type")
+            if not return_type:
+                continue
+            ctx = self._file_ctx.get(node.file_path)
+            if ctx is None:
+                continue
+            type_id = self._resolve_declared_type(
+                return_type, ctx.module, ctx.import_map, ctx.wildcard_packages,
+            )
+            if type_id is None or not self._is_concrete_class(type_id):
+                continue
+            bean_name, qualifiers, primary = self._bean_metadata_from_decorators(
+                node.decorators, node.name, node.file_path,
+            )
+            out.append(_BeanCandidate(
+                type_id, bean_name, qualifiers, primary, source="bean_method",
+            ))
+        return out
+
+    def _build_constructor_injection_index(
+        self,
+        parses: Dict[Path, ParseResult],
+        results: Dict[Path, AnalysisResult],
+        func_id_by_position: Dict[Tuple[str, int, int], str],
+    ) -> Dict[str, _InjectedFieldMetadata]:
+        """Fields injected by constructors via direct `this.field = param`."""
+        injected: Dict[str, _InjectedFieldMetadata] = {}
+        for file_path, parse in parses.items():
+            result = results.get(file_path)
+            if result is None:
+                continue
+            fp_str = str(file_path)
+            source = parse.source_bytes
+            for func_cst, caller_id in self._iter_method_cst(
+                parse.tree.root_node, fp_str, func_id_by_position,
+            ):
+                if func_cst.type not in ("constructor_declaration", "compact_constructor_declaration"):
+                    continue
+                class_id = self._declaring_class_id(caller_id)
+                if class_id is None:
+                    continue
+                field_nodes = self._field_nodes.get(class_id, {})
+                if not field_nodes:
+                    continue
+                constructor_annotations = self._annotations_from_node(func_cst, source)
+                constructor_is_injected = any(
+                    self._di_annotation_simple_name(d, fp_str) in JAVA_INJECTION_ANNOTATIONS
+                    for d in constructor_annotations
+                )
+                params = self._param_injection_metadata(func_cst, source, fp_str)
+                if not constructor_is_injected and not any(meta.source for _, meta in params.values()):
+                    continue
+                body = func_cst.child_by_field_name("body")
+                if body is None:
+                    continue
+                for field_name, param_name in self._constructor_field_assignments(
+                    body, source, set(params),
+                ):
+                    if param_name not in params or field_name not in field_nodes:
+                        continue
+                    param_type, metadata = params[param_name]
+                    field_id = field_nodes[field_name]
+                    field_node = self.builder._nodes.get(field_id)
+                    if field_node is None or not field_node.signature:
+                        continue
+                    if not self._declared_types_match(field_node.signature, param_type):
+                        continue
+                    if constructor_is_injected or metadata.source:
+                        injected[field_id] = metadata
+        return injected
+
+    def _build_setter_injection_index(
+        self,
+        parses: Dict[Path, ParseResult],
+        results: Dict[Path, AnalysisResult],
+        func_id_by_position: Dict[Tuple[str, int, int], str],
+    ) -> Dict[str, _InjectedFieldMetadata]:
+        """Fields injected via a Spring setter — `@Autowired void setX(T v)
+        { this.x = v; }` — the third classical injection style alongside
+        field- and constructor-injection above. Only single-parameter
+        `set<Name>` methods are considered: that is Spring's own
+        setter-injection convention, and narrow enough that an unrelated
+        single-arg method never gets mistaken for bean wiring."""
+        injected: Dict[str, _InjectedFieldMetadata] = {}
+        for file_path, parse in parses.items():
+            result = results.get(file_path)
+            if result is None:
+                continue
+            fp_str = str(file_path)
+            source = parse.source_bytes
+            for func_cst, caller_id in self._iter_method_cst(
+                parse.tree.root_node, fp_str, func_id_by_position,
+            ):
+                if func_cst.type != "method_declaration":
+                    continue
+                name_node = func_cst.child_by_field_name("name")
+                if name_node is None:
+                    continue
+                method_name = self._text(name_node, source)
+                if not method_name.startswith("set") or len(method_name) <= len("set"):
+                    continue
+                class_id = self._declaring_class_id(caller_id)
+                if class_id is None:
+                    continue
+                field_nodes = self._field_nodes.get(class_id, {})
+                if not field_nodes:
+                    continue
+                params = self._param_injection_metadata(func_cst, source, fp_str)
+                if len(params) != 1:
+                    continue  # not JavaBeans setter shape - a single (T v) param
+                method_annotations = self._annotations_from_node(func_cst, source)
+                method_is_injected = any(
+                    self._di_annotation_simple_name(d, fp_str) in JAVA_INJECTION_ANNOTATIONS
+                    for d in method_annotations
+                )
+                # Unlike a constructor (whose parameters are each qualified
+                # individually), a setter has exactly one parameter, so Spring
+                # allows `@Qualifier` on either the method or the parameter —
+                # both mean the same thing here. The parameter's own qualifier
+                # (if any) wins on conflict, matching `_field_qualifier`'s own
+                # "direct decorator first" precedence for a plain field.
+                method_qualifier = self._qualifier_from_decorators(method_annotations, fp_str)
+                if not method_is_injected and not method_qualifier and not any(
+                    meta.source for _, meta in params.values()
+                ):
+                    continue
+                body = func_cst.child_by_field_name("body")
+                if body is None:
+                    continue
+                for field_name, param_name in self._constructor_field_assignments(
+                    body, source, set(params),
+                ):
+                    if param_name not in params or field_name not in field_nodes:
+                        continue
+                    param_type, metadata = params[param_name]
+                    field_id = field_nodes[field_name]
+                    field_node = self.builder._nodes.get(field_id)
+                    if field_node is None or not field_node.signature:
+                        continue
+                    if not self._declared_types_match(field_node.signature, param_type):
+                        continue
+                    if metadata.qualifier is None and method_qualifier is not None:
+                        metadata = _InjectedFieldMetadata(
+                            qualifier=method_qualifier, source="method_qualifier",
+                        )
+                    if method_is_injected or metadata.source:
+                        injected[field_id] = metadata
+        return injected
+
+    def _param_injection_metadata(
+        self, method_cst, source: bytes, file_path: str,
+    ) -> Dict[str, Tuple[str, _InjectedFieldMetadata]]:
+        """`{param_name: (declared_type, metadata)}` for every formal
+        parameter of a constructor or setter, `metadata.source` set iff that
+        parameter itself carries `@Qualifier`/`@Resource(name=...)` or a
+        bare injection annotation (shared by `_build_constructor_injection_index`
+        and `_build_setter_injection_index` — the evidence a parameter
+        carries doesn't depend on which of the two enclosing method shapes
+        it is read from)."""
+        params_node = method_cst.child_by_field_name("parameters")
+        if params_node is None:
+            return {}
+        out: Dict[str, Tuple[str, _InjectedFieldMetadata]] = {}
+        for child in params_node.children:
+            if child.type != "formal_parameter":
+                continue
+            type_node = child.child_by_field_name("type")
+            name_node = child.child_by_field_name("name")
+            if type_node is None or name_node is None:
+                continue
+            decorators = self._annotations_from_node(child, source)
+            qualifier = self._qualifier_from_decorators(decorators, file_path)
+            source_name = ""
+            if qualifier is not None:
+                source_name = "param_qualifier"
+            elif any(
+                self._di_annotation_simple_name(d, file_path) in JAVA_INJECTION_ANNOTATIONS
+                for d in decorators
+            ):
+                source_name = "param_injection"
+            out[self._text(name_node, source)] = (
+                self._text(type_node, source),
+                _InjectedFieldMetadata(qualifier=qualifier, source=source_name),
+            )
+        return out
+
+    def _constructor_field_assignments(
+        self, body, source: bytes, param_names: Set[str],
+    ) -> List[Tuple[str, str]]:
+        """`(field_name, rhs_identifier)` pairs for every direct field
+        assignment in a constructor or setter body, whether written
+        `this.field = x` or as the bare `field = x` idiom used whenever the
+        field and parameter names differ (no shadowing, so no `this.` is
+        needed). A bare LHS identifier only counts as a field when it is
+        neither a local variable in scope at that point nor one of the
+        method's own parameters — either would shadow the field, so an
+        unqualified reference there resolves to the local/parameter, not the
+        field (same disambiguation `_receiver_field_node_id` does for read
+        sites)."""
+        assignments: List[Tuple[str, str]] = []
+        local_types = self._collect_local_scopes(body, source)
+        stack = [body]
+        while stack:
+            node = stack.pop()
+            if node.type in _NESTED_SCOPE_BOUNDARY:
+                continue
+            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 = children[0]
+                    field_name = self._this_field_name(lhs, source)
+                    if field_name is None and lhs.type == "identifier":
+                        name = self._text(lhs, source)
+                        if (
+                            name not in param_names
+                            and local_types.type_at(name, lhs.start_byte) is None
+                        ):
+                            field_name = name
+                    if field_name is not None and children[2].type == "identifier":
+                        assignments.append((field_name, self._text(children[2], source)))
+            stack.extend(node.children)
+        return assignments
+
+    def _this_field_name(self, node, source: bytes) -> Optional[str]:
+        if node.type != "field_access":
+            return None
+        inner = node.child_by_field_name("object")
+        field_node = node.child_by_field_name("field")
+        if inner is not None and inner.type == "this" and field_node is not None:
+            return self._text(field_node, source)
+        return None
+
+    def _annotations_from_node(self, node, source: bytes) -> List[str]:
+        modifiers = next((c for c in node.children if c.type == "modifiers"), None)
+        if modifiers is None:
+            return []
+        return [
+            self._text(child, source).strip()
+            for child in modifiers.children
+            if child.type in ("annotation", "marker_annotation")
+        ]
+
+    @staticmethod
+    def _declared_types_match(left: str, right: str) -> bool:
+        return erased_type(left).strip() == erased_type(right).strip()
+
+    @staticmethod
+    def _type_param_bounds_from_node(tp_node, source: bytes) -> Dict[str, str]:
+        """`{type_param_name: upper_bound_type_text}` for one `type_parameters`
+        CST node — the grammar shape is identical whether it hangs off a
+        method or a class/interface/record declaration, so this is shared by
+        both `_collect_type_param_bounds` call sites. Only the first
+        (leftmost) bound is kept — an intersection bound `T extends A & B`
+        has no single erased receiver type this resolver can pick, so it takes
+        `A`, the same first-alternative best-effort `_collect_local_scopes`
+        uses for a multi-catch. A parameter with no bound (`<T>`) contributes
+        nothing (its receiver stays unresolved, never guessed)."""
+        bounds: Dict[str, str] = {}
+        for child in tp_node.children:
+            if child.type != "type_parameter":
+                continue
+            name_node = next(
+                (c for c in child.children if c.type == "type_identifier"), None
+            )
+            if name_node is None:
+                continue
+            bound_node = next(
+                (c for c in child.children if c.type == "type_bound"), None
+            )
+            if bound_node is None:
+                continue
+            first_bound = next((c for c in bound_node.children if c.is_named), None)
+            if first_bound is not None:
+                bounds[JavaCallResolver._text(name_node, source)] = (
+                    JavaCallResolver._text(first_bound, source)
+                )
+        return bounds
+
+    def _collect_type_param_bounds(self, func_cst, source: bytes) -> Dict[str, str]:
+        """`{type_param_name: upper_bound_type_text}` for a method's own
+        `<T extends Bound>` type parameters *plus* every enclosing
+        class/interface/record's own `<T extends Bound>` (P4.12 generic
+        narrowing, F-04 fix) — `class Client<T extends Stripe> { void
+        run(T g) { g.charge(); } }` binds `T` from the class, not `run`,
+        which has no type parameters of its own.
+
+        Merge order is outermost-enclosing-type -> innermost-enclosing-type
+        -> method, each later layer overriding an earlier one for the same
+        name — mirrors real Java scoping, where a method's own `<T extends
+        ...>` (or an inner nested class's) shadows an outer class's `T` of
+        the same name rather than merging with it."""
+        bounds: Dict[str, str] = {}
+        enclosing_types: List = []
+        cur = func_cst.parent
+        while cur is not None:
+            if cur.type in _ENCLOSING_TYPE_CST_TYPES:
+                enclosing_types.append(cur)
+            cur = cur.parent
+        for type_node in reversed(enclosing_types):
+            tp_node = type_node.child_by_field_name("type_parameters")
+            if tp_node is not None:
+                bounds.update(self._type_param_bounds_from_node(tp_node, source))
+        tp_node = func_cst.child_by_field_name("type_parameters")
+        if tp_node is not None:
+            bounds.update(self._type_param_bounds_from_node(tp_node, source))
+        return bounds
+
+    def _collect_method_type_param_bounds(
+        self,
+        parses: Dict[Path, ParseResult],
+        func_id_by_position: Dict[Tuple[str, int, int], str],
+    ) -> Dict[str, Dict[str, str]]:
+        """Type parameters declared by each source method.
+
+        Class type parameters are deliberately excluded: their binding comes
+        from the receiver type. Method parameters are inferred independently
+        at every invocation and must not be resolved as ordinary class names.
+        """
+        out: Dict[str, Dict[str, str]] = {}
+        for file_path, parse in parses.items():
+            for method_node, func_id in self._iter_method_cst(
+                parse.tree.root_node, str(file_path), func_id_by_position,
+            ):
+                tp_node = method_node.child_by_field_name("type_parameters")
+                if tp_node is None:
+                    continue
+                names = self._type_param_names_from_node(tp_node, parse.source_bytes)
+                if not names:
+                    continue
+                bounds = self._type_param_bounds_from_node(tp_node, parse.source_bytes)
+                out[func_id] = {name: bounds.get(name, "Object") for name in names}
+        return out
+
+    def _collect_class_type_params(
+        self, parses: Dict[Path, ParseResult], class_id_by_position: Dict[Tuple[str, int, int], str],
+    ) -> Dict[str, List[str]]:
+        """`{class_id: [type parameter names]}` for source-declared generic
+        types. The resolver uses this to substitute a receiver's actual type
+        arguments into declared method return types (`Box<T>.value() -> T`)."""
+        out: Dict[str, List[str]] = {}
+        for file_path, parse in parses.items():
+            fp_str = str(file_path)
+            stack = [parse.tree.root_node]
+            while stack:
+                node = stack.pop()
+                if node.type in _ENCLOSING_TYPE_CST_TYPES:
+                    class_id = class_id_by_position.get(
+                        (fp_str, node.start_point[0] + 1, node.start_point[1]),
+                    )
+                    if class_id is not None:
+                        tp_node = node.child_by_field_name("type_parameters")
+                        if tp_node is not None:
+                            params = self._type_param_names_from_node(
+                                tp_node, parse.source_bytes,
+                            )
+                            if params:
+                                out[class_id] = params
+                stack.extend(node.children)
+        return out
+
+    def _collect_class_type_param_bounds(
+        self, parses: Dict[Path, ParseResult],
+        class_id_by_position: Dict[Tuple[str, int, int], str],
+    ) -> Dict[str, Dict[str, str]]:
+        """Upper bounds declared directly by each source generic type."""
+        out: Dict[str, Dict[str, str]] = {}
+        for file_path, parse in parses.items():
+            fp_str = str(file_path)
+            stack = [parse.tree.root_node]
+            while stack:
+                node = stack.pop()
+                if node.type in _ENCLOSING_TYPE_CST_TYPES:
+                    class_id = class_id_by_position.get(
+                        (fp_str, node.start_point[0] + 1, node.start_point[1]),
+                    )
+                    tp_node = node.child_by_field_name("type_parameters")
+                    if class_id is not None and tp_node is not None:
+                        bounds = self._type_param_bounds_from_node(
+                            tp_node, parse.source_bytes,
+                        )
+                        if bounds:
+                            out[class_id] = bounds
+                stack.extend(node.children)
+        return out
+
+    def _collect_ancestor_type_args(
+        self, results: Dict[Path, AnalysisResult],
+        class_id_by_position: Dict[Tuple[str, int, int], str],
+        file_ctx: Dict[str, "_ImportContext"],
+    ) -> Dict[Tuple[str, str], List[str]]:
+        """`{(class_id, ancestor_class_id): [type-argument texts]}` read off
+        each class/interface's own `extends`/`implements` clause.
+
+        `Symbol.superclasses`/`Symbol.implements` are erased (`extractor.py::
+        _extract_class`) to a plain declared name, matching what the shared
+        `graph/builder.py::resolve_relationships` INHERITS/IMPLEMENTS lookup
+        needs. The raw clause text with generics intact (`Box<Stripe>`) is
+        kept alongside in `Symbol.metadata["java_superclass_args"]`/
+        `["java_implements_args"]` — this is the one place that argument
+        text survives, keyed by the edge it belongs to so
+        `_compose_type_var_bindings` can walk it per hop."""
+        out: Dict[Tuple[str, str], List[str]] = {}
+        for path, ar in results.items():
+            ctx = file_ctx.get(str(path))
+            if ctx is None:
+                continue
+            for sym in ar.symbols:
+                if sym.kind != "class":
+                    continue
+                class_id = class_id_by_position.get(
+                    (str(sym.file_path), sym.position.line, sym.position.column),
+                )
+                if class_id is None:
+                    continue
+                parent_texts = (
+                    *sym.metadata.get("java_superclass_args", ()),
+                    *sym.metadata.get("java_implements_args", ()),
+                )
+                for parent_text in parent_texts:
+                    args = self._generic_type_arguments(parent_text)
+                    if not args:
+                        continue
+                    ancestor_id = self._resolve_declared_type(
+                        parent_text, ctx.module, ctx.import_map, ctx.wildcard_packages,
+                    )
+                    if ancestor_id is None or ancestor_id == class_id:
+                        continue
+                    out[(class_id, ancestor_id)] = args
+        return out
+
+    @staticmethod
+    def _type_param_names_from_node(tp_node, source: bytes) -> List[str]:
+        names: List[str] = []
+        for child in tp_node.children:
+            if child.type != "type_parameter":
+                continue
+            name_node = next(
+                (c for c in child.children if c.type == "type_identifier"), None
+            )
+            if name_node is not None:
+                names.append(JavaCallResolver._text(name_node, source))
+        return names
+
+    @staticmethod
+    def _count_args(args_node) -> int:
+        return len(argument_nodes(args_node))
+
+    # ------------------------------------------------------------------ member lookup + overload selection
+
+    def _is_static_member(self, func_id: str) -> bool:
+        """Whether `func_id` is a `static` method. Fail-safe: a node whose
+        metadata carries no `java_is_static` key (a graph built before the
+        extractor recorded it) returns True, so the static-import filter in
+        `_resolve_own_or_ancestor` never *drops* an edge on missing data —
+        it only excludes members positively known to be instance methods."""
+        node = self.builder._nodes.get(func_id)
+        if node is None:
+            return False
+        return bool(node.metadata.get("java_is_static", True))
+
+    def _resolve_own_or_ancestor(
+        self, class_id: str, method_name: str, arg_count: int,
+        arg_types: Optional[List[str]], self_conf: float, ancestor_conf: float,
+        arg_ctx: "_ImportContext", static_only: bool = False,
+        allow_method_type_inference: bool = False,
+        prefer_unique_own: bool = False,
+        narrowing_args: Optional[
+            Tuple[object, bytes, "_LocalScopes", Dict[str, str], Dict[str, str]]
+        ] = None,
+    ) -> Tuple[Union[str, List[str], None], float]:
+        """Candidate set is own-class overloads *plus* any inherited
+        overload not overridden by one of them (see `_members_named`) — a
+        same-name method on the child no longer hides the parent's other
+        overloads, only the one it actually overrides. Structural lookup
+        (own class, then the full INHERITS/IMPLEMENTS ancestor chain) always
+        runs, regardless of whether `method_name` is in
+        `builtins_deny_list`: unlike Python's deny-list, which guards a
+        whole-project unique-simple-name fallback, the Java ancestor walk
+        here has no such fuzzy fallback to guard — a match found via
+        `_members_named`'s ancestor search is a real INHERITS/IMPLEMENTS
+        edge to a real declaration, not a guess, so a base class that
+        genuinely declares `toString()` resolves the same way any other
+        inherited method does (P4.4 regression fix; previously this
+        early-returned unresolved whenever the receiver's own class didn't
+        declare a denied name itself, even when an ancestor did — see
+        PROBLEMS.md's P4.4 notes for the superseded rationale and
+        `TestDenyList`'s renamed test).
+
+        `narrowing_args` (`(args_node, source, local_types, param_types,
+        field_types)`), when given and `arg_types` is `None`, shrinks the
+        candidate set via `_narrow_candidates_by_known_arg_types` before
+        selection: a call whose arguments are only partially resolvable
+        still excludes a same-arity sibling that a *known* argument
+        provably cannot reach, instead of fanning out across every one.
+        Optional so every pre-existing call site (no known-argument
+        narrowing context) keeps its exact prior behavior."""
+        # This method resolves `method_invocation` dispatch targets only —
+        # never a constructor — so a member named after its own class (an
+        # interface method implementation sharing the class's simple name)
+        # must not be confused with the constructor of the same name.
+        own = self._members_named(
+            class_id, method_name, search_ancestors=False, exclude_constructors=True,
+            caller_class_id=arg_ctx.enclosing_class_id,
+        )
+        members = self._members_named(
+            class_id, method_name, search_ancestors=True, exclude_constructors=True,
+            caller_class_id=arg_ctx.enclosing_class_id,
+        )
+        if static_only:
+            # A static import (`import static a.b.C.name;`, or `C.*`) can only
+            # bind a *static* member, so an instance method of the same name
+            # is not a legal target here (F-02). Skip nodes whose metadata
+            # lacks `java_is_static` (graphs built before this flag existed):
+            # absent info must not silently drop a real edge.
+            own = [c for c in own if self._is_static_member(c)]
+            members = [c for c in members if self._is_static_member(c)]
+        if not members:
+            return None, 0.0
+        if arg_types is None and narrowing_args is not None:
+            args_node, source, local_types, param_types, field_types = narrowing_args
+            own = self._narrow_candidates_by_known_arg_types(
+                own, arg_count, args_node, source, local_types, param_types,
+                field_types, arg_ctx,
+            )
+            members = self._narrow_candidates_by_known_arg_types(
+                members, arg_count, args_node, source, local_types, param_types,
+                field_types, arg_ctx,
+            )
+        own_ids = set(own)
+        if prefer_unique_own and own:
+            own_target, own_conf = self._select_overload(
+                own, arg_count, arg_types, lambda _c: self_conf, arg_ctx,
+                allow_method_type_inference,
+            )
+            if isinstance(own_target, str):
+                return own_target, own_conf
+            if isinstance(own_target, list):
+                return None, 0.0
+            inherited = [candidate for candidate in members if candidate not in own_ids]
+            inherited_target, inherited_conf = self._select_overload(
+                inherited, arg_count, arg_types, lambda _c: ancestor_conf, arg_ctx,
+                allow_method_type_inference,
+            )
+            if isinstance(inherited_target, str):
+                return inherited_target, inherited_conf
+            return None, 0.0
+        return self._select_overload(
+            members, arg_count, arg_types,
+            lambda c: self_conf if c in own_ids else ancestor_conf,
+            arg_ctx, allow_method_type_inference,
+        )
+
+    def _annotation_stub_match(
+        self, class_id: str, method_name: str, search_self: bool = True,
+    ) -> bool:
+        """True iff `class_id` (when `search_self`) or any INHERITS/
+        IMPLEMENTS ancestor carries a stub-table annotation covering
+        `method_name` — Lombok generates its methods on the annotated class
+        itself, so a subclass with no annotation of its own still inherits
+        the real (compiler-generated) method and must resolve through it
+        the same way. `search_self=False` mirrors `_members_named`'s
+        `super.m()` semantics: `super.getX()` must reach an ancestor's
+        Lombok-generated method, never one implied by the child's own
+        annotation.
+
+        A decorator that resolves — by FQN if already qualified
+        (`@lombok.Getter`), else through the *declaring class's own file's*
+        package/import context if bare (`@Getter`) — to an annotation
+        declared *in the analyzed source* as an `@interface`
+        (`self._local_annotation_type_names`) is the project's own
+        annotation, never Lombok (whose annotations are always external), so
+        the stub is skipped for it — otherwise a local `@interface Getter
+        {}` would fabricate a synthetic `getX()` edge. Resolved per-file
+        (F-02 fix), not by simple name alone: an unrelated package
+        declaring `@interface Getter` must not blind `@lombok.Getter` used
+        anywhere else in the project — only a decorator that actually
+        resolves to *that* declaration is local."""
+        chain = (
+            (class_id, *self._class_ancestors(class_id))
+            if search_self else self._class_ancestors(class_id)
+        )
+        for cid in chain:
+            node = self.builder._nodes.get(cid)
+            if node is None or not node.decorators:
+                continue
+            for deco in node.decorators:
+                dname = self.builder._decorator_name(deco)
+                if not dname:
+                    continue
+                simple = dname.split(".")[-1]
+                if self._decorator_is_local_annotation(dname, simple, node):
+                    continue  # project's own annotation, not Lombok
+                prefixes = self.config.annotation_stub_table.get(simple)
+                if prefixes and any(method_name.startswith(p) for p in prefixes):
+                    return True
+        return False
+
+    def _decorator_is_local_annotation(
+        self, dname: str, simple: str, node,
+    ) -> bool:
+        """`_is_local_annotation` for a decorator found on a graph `node`
+        (Lombok-stub guard); see that method for the core resolution."""
+        return self._is_local_annotation(dname, simple, node.file_path)
+
+    def _is_local_annotation(self, dname: str, simple: str, file_path: str) -> bool:
+        """True iff decorator `dname` (simple name `simple`) declared in
+        `file_path` resolves to an `@interface` declared in the analyzed
+        source, per `self._local_annotation_type_names` (simple name ->
+        declared FQNs). Shared by the Lombok-stub guard
+        (`_decorator_is_local_annotation`, F-01/F-02) and the DI-evidence
+        guard (`_di_annotation_simple_name`, F-02 follow-up) — same question
+        ("does this well-known simple name actually resolve to *this
+        project's own* declaration, not the external framework's?") asked
+        for two different well-known-name tables.
+
+        A dotted `dname` is checked directly against the declared-FQN set
+        first (`@lombok.Getter` already *is* its own resolved FQN — that
+        direct-FQN path is the F-02 fix: it is what lets `@lombok.Getter`
+        survive an unrelated package's `@interface Getter`). Unlike a
+        top-level package-qualified name, though, a dotted `dname` is not
+        always an absolute FQN: `@Marks.Getter` on a *nested* annotation
+        type (`class Marks { @interface Getter {} }`) is a type-qualified
+        reference relative to `node`'s own package/import context, the same
+        way `Marks.Getter` would resolve as an ordinary (non-annotation)
+        member-type reference. So on a direct-match miss, the leading
+        segment is resolved as a declared type via `_resolve_declared_type`
+        (same import-map/wildcard-package machinery as any other receiver
+        type, no separate resolution path to drift) and the remaining
+        segment(s) are re-joined onto *that* type's own FQN (F-01 fix — the
+        old code trusted every dotted name as already-absolute and could
+        never match a nested declaration's `package.Enclosing.Simple` key).
+        Because a member annotation type is an *inherited* member, the
+        qualifier may be a subclass that inherits the declaration
+        (`@Child.Getter`, `class Child extends Marks`, `Marks` declaring
+        `Getter` -> canonical `package.Marks.Getter`); the candidate is
+        therefore tried against the resolved qualifier *and* each of its
+        `_class_ancestors`, mirroring Java's own member-type-inheritance
+        lookup (F-01 residual fix).
+        A bare `dname` (`@Getter`) is resolved through `node`'s own
+        declaring file's import map / package (`self._file_ctx`, mirroring
+        `_param_ctx_for`'s "declaring file's own context, not the call
+        site's" rule) before comparing — an explicit single-type import or
+        same-package sibling `@interface Getter` still counts as local,
+        matching Java's own name-resolution scoping.
+
+        Missing file context (e.g. a partial incremental rescan not passing
+        every file) falls back to treating any known local FQN for `simple`
+        as a match — "missing edge over wrong edge", same precision stance
+        as `_param_ctx_for` — for both the dotted and bare cases."""
+        local_fqns = self._local_annotation_type_names.get(simple)
+        if not local_fqns:
+            return False
+        ctx = self._file_ctx.get(file_path)
+        if "." in dname:
+            if dname in local_fqns:
+                return True
+            if ctx is None:
+                return True
+            head, _, rest = dname.partition(".")
+            head_id = self._resolve_declared_type(
+                head, ctx.module, ctx.import_map, ctx.wildcard_packages,
+            )
+            if head_id is None:
+                return False
+            # A member annotation type is an *inherited* member: `@Child.Getter`
+            # where `class Child extends Marks` and `Marks` declares `Getter`
+            # canonically names `<pkg>.Marks.Getter`, not `<pkg>.Child.Getter`
+            # (F-01 residual — the declaring type may be an ancestor of the
+            # qualifier, so re-joining `rest` onto the qualifier's own FQN alone
+            # misses it). Try the qualifier itself, then each ancestor, mirroring
+            # Java's own member-type-inheritance lookup. `@lombok.Getter` never
+            # reaches here (head `lombok` resolves to no CLASS node), so this
+            # cannot over-suppress a genuine external annotation.
+            for type_id in (head_id, *self._class_ancestors(head_id)):
+                type_node = self.builder._nodes[type_id]
+                type_chain = type_node.qualified_name
+                type_prefix = f"{type_node.module}."
+                if type_chain.startswith(type_prefix):
+                    type_chain = type_chain[len(type_prefix):]
+                candidate = (
+                    f"{type_chain}.{rest}" if type_node.module == DEFAULT_PACKAGE
+                    else f"{type_node.module}.{type_chain}.{rest}"
+                )
+                if candidate in local_fqns:
+                    return True
+            return False
+        if ctx is None:
+            return True
+        imported = ctx.import_map.get(simple)
+        if imported is not None:
+            return imported in local_fqns
+        own_fqn = simple if ctx.module == DEFAULT_PACKAGE else f"{ctx.module}.{simple}"
+        if own_fqn in local_fqns:
+            return True
+        return any(f"{pkg}.{simple}" in local_fqns for pkg in ctx.wildcard_packages)
+
+    # ------------------------------------------------------------------ call-site resolution
+
+    def _resolve_static_import_class(
+        self, cls_path: str, module_name: str,
+    ) -> Optional[str]:
+        """The CLASS node id a static import's class path (`a.b.C`) names, or
+        None. Tries `_lookup_qualified` first — the direct fully-qualified
+        lookup that a static import's already-resolved dotted path
+        (`a.b.C.method` minus its last segment) needs, and which
+        `_resolve_name(..., strict=True)` cannot do with an empty import map
+        (it only checks head-in-import-map or tail-in-same-module) — then
+        falls back to `_resolve_name` for a single-segment path (a same-module
+        or default-package class the qualified lookup, which needs >= 2 dotted
+        parts, can't handle)."""
+        if not cls_path:
+            return None
+        namespace = self.builder._module_namespace(module_name)
+        # Static imports carry the exact owner path. Prefer the dotted index
+        # so nested owners (`Documenter.CanvasOptions.Grouping`) cannot be
+        # replaced by another same-simple-name class in the package-level
+        # simple-name map.
+        cls_id = self.builder._node_for_dotted(cls_path, namespace)
+        if cls_id is None:
+            cls_id = self.builder._lookup_qualified(
+                cls_path, self._by_module_symbol, namespace,
+            )
+        if cls_id is None:
+            cls_id = self.builder._resolve_name(
+                cls_path, module_name, {}, {}, self._by_module_symbol, strict=True,
+            )
+        if cls_id and self.builder._nodes[cls_id].node_type == NodeType.CLASS:
+            return cls_id
+        return None
+
+    # ------------------------------------------------------------------ P4.12 abstract-receiver fan-out
+
+    @staticmethod
+    def _apply_type_bound(type_text: str, bounds: Dict[str, str]) -> str:
+        """Rewrite a receiver type that is a method type parameter to its
+        concrete upper bound (`T` -> `StripeGateway` given
+        `<T extends StripeGateway>`); pass anything else through unchanged. The
+        raw type is erased and de-arrayed first so `T[]`/`List<T>`-shaped names
+        still key on the bare parameter."""
+        if not bounds:
+            return type_text
+        base = erased_type(type_text).strip()
+        while base.endswith("[]"):
+            base = base[:-2]
+        return bounds.get(base, type_text)
+
+
+    def _resolve_call(
+        self, call_node, source: bytes, module_name: str,
+        enclosing_class_id: Optional[str], import_map: Dict[str, str],
+        wildcard_packages: List[str],
+        local_types: "_LocalScopes", own_param_types: Dict[str, str],
+        static_wildcard_classes: List[str],
+        type_param_bounds: Optional[Dict[str, str]] = None,
+    ) -> Tuple[Union[str, List[str], None], float, Dict[str, object]]:
+        """Resolve a `method_invocation` node to `(target_id_or_candidates,
+        confidence, edge_metadata)`. Cascade: `super.m()` -> ancestor walk
+        (0.85), then the ancestor-only annotation-stub fallback (0.6);
+        bare/`this.m()` -> own class then ancestors (0.95 / 0.85), bare calls
+        additionally try an explicit static import then each static wildcard
+        import (0.85 / 0.75), then the own+ancestor annotation-stub fallback
+        (0.6); typed receiver (local/param/field/static-class) -> own class
+        then ancestors at the receiver's confidence, then the same
+        annotation-stub fallback (0.6). The stub fallback is reachable from
+        every branch: Lombok generates real methods on the annotated class,
+        so a call site calling its *own* class's Lombok-generated accessor
+        (`this.getX()`/bare `getX()`) is exactly as legitimate as calling
+        one through an external typed receiver — the fallback must not be
+        exclusive to the latter.
+
+        `edge_metadata` is empty for every branch except the P4.12
+        abstract-receiver fan-out (a typed receiver whose declared type is an
+        interface/abstract class and whose P4.4 target is therefore an
+        abstract method): there it carries `strategy` + `declared_receiver_type`
+        so impact/MCP can explain the fanned-out (or DI-narrowed) edges
+        (deep-dive §8.4). `type_param_bounds` feeds generic narrowing — see
+        `_resolve_receiver`.
+        """
+        caller_ctx = _ImportContext(
+            module_name, import_map, wildcard_packages, enclosing_class_id,
+        )
+        name_node = call_node.child_by_field_name("name")
+        if name_node is None:
+            return None, 0.0, {}
+        method_name = self._text(name_node, source)
+        args_node = call_node.child_by_field_name("arguments")
+        arg_count = self._count_args(args_node)
+        field_types_own = (
+            self._visible_bare_field_types(enclosing_class_id)
+            if enclosing_class_id else {}
+        )
+        arg_types = self._infer_arg_types(
+            args_node, source, local_types, own_param_types, field_types_own,
+        )
+        obj_node = call_node.child_by_field_name("object")
+        arg_nodes = argument_nodes(args_node)
+        bare_creation_args = bool(arg_nodes) and all(
+            child.type == "object_creation_expression" for child in arg_nodes
+        )
+
+        if obj_node is not None and obj_node.type == "super":
+            if enclosing_class_id is None:
+                return None, 0.0, {}
+            cands = self._members_named(
+                enclosing_class_id, method_name, search_ancestors=True, search_self=False,
+                exclude_constructors=True, caller_class_id=enclosing_class_id,
+            )
+            if not cands:
+                if self._annotation_stub_match(enclosing_class_id, method_name, search_self=False):
+                    return enclosing_class_id, 0.6, {}
+                return None, 0.0, {}
+            target, conf = self._select_overload(
+                cands, arg_count, arg_types, lambda _c: 0.85, caller_ctx,
+            )
+            # `super.<abstract>()` is illegal Java, so this rarely fires, but
+            # keep the branch consistent with `this`/bare: if the ancestor walk
+            # somehow lands on an abstract declaration, fan out over the
+            # enclosing class's concrete implementors rather than emit a
+            # bodiless edge.
+            if target is not None and self._is_abstract_target(target):
+                fan = self._raw_implementor_fan_out(
+                    enclosing_class_id, method_name, arg_count, arg_types,
+                    caller_ctx,
+                )
+                if fan is not None:
+                    return fan
+            return target, conf, {}
+
+        if obj_node is None or obj_node.type == "this":
+            if enclosing_class_id is None:
+                return None, 0.0, {}
+            implicit_candidates = self._members_named(
+                enclosing_class_id, method_name, search_ancestors=True,
+                exclude_constructors=True, caller_class_id=enclosing_class_id,
+            )
+            overload_arg_types = self._contextual_overload_arg_types(
+                implicit_candidates, arg_count, arg_types, args_node, source,
+                module_name, enclosing_class_id, import_map, wildcard_packages,
+                local_types, own_param_types, field_types_own,
+                type_param_bounds or {},
+            )
+            target, conf = self._resolve_own_or_ancestor(
+                enclosing_class_id, method_name, arg_count, overload_arg_types,
+                0.95, 0.85,
+                caller_ctx,
+                # C04 direct-root scope: nested bare calls have a separate
+                # scoring/propagation identity and must remain unchanged.
+                allow_method_type_inference=(
+                    obj_node is None and call_node.parent.type != "arguments"
+                ),
+                # C04: for `helper(new T<>())`, require one applicable method
+                # on the own class before considering inherited declarations.
+                # A tied own overload is unresolved, never a C06-style fan-out.
+                prefer_unique_own=(obj_node is None and bare_creation_args),
+                narrowing_args=(
+                    args_node, source, local_types, own_param_types,
+                    field_types_own,
+                ),
+            )
+            if target is not None:
+                # P4.12: a `this`/bare call landing on an *abstract* method is
+                # the Template Method / interface-default-method pattern — the
+                # abstract sibling declared on this very (abstract/interface)
+                # class has no body, so fan out to the concrete implementors,
+                # exactly like the typed-receiver branch, rooted at the
+                # enclosing class (a concrete class cannot resolve one of its
+                # own calls to an abstract method, so `_is_abstract_target`
+                # implies the enclosing type is abstract/interface). No DI
+                # narrowing: `this` is never an injected field.
+                if self._is_abstract_target(target):
+                    fan = self._raw_implementor_fan_out(
+                        enclosing_class_id, method_name, arg_count,
+                        overload_arg_types,
+                        caller_ctx,
+                    )
+                    if fan is not None:
+                        # The abstract declaration has no executable body.
+                        # Once concrete implementors are known, emit only the
+                        # runtime targets — the typed-receiver branch follows
+                        # the same rule, and retaining the declaration creates
+                        # a false-positive call edge for template methods.
+                        return fan
+                return target, conf, {}
+            if obj_node is None:
+                # An unqualified call in a nested class may target a member
+                # of a lexical outer class through the implicit enclosing
+                # instance (`Inner.this` semantics).  Search only the exact
+                # lexical owner chain, nearest first.  An explicitly static
+                # nested class has no enclosing instance, so retain only
+                # static outer members in that case.
+                current_class = self.builder._nodes.get(enclosing_class_id)
+                static_context = bool(
+                    current_class
+                    and "static" in current_class.metadata.get("modifiers", ())
+                )
+                for outer_id in self._lexical_outer_class_ids(enclosing_class_id):
+                    outer_candidates = self._members_named(
+                        outer_id, method_name, search_ancestors=True,
+                        exclude_constructors=True, caller_class_id=enclosing_class_id,
+                    )
+                    if static_context:
+                        outer_candidates = [
+                            candidate for candidate in outer_candidates
+                            if self._is_static_member(candidate)
+                        ]
+                    outer_arg_types = self._contextual_overload_arg_types(
+                        outer_candidates, arg_count, arg_types, args_node, source,
+                        module_name, outer_id, import_map, wildcard_packages,
+                        local_types, own_param_types,
+                        self._all_field_types(outer_id), type_param_bounds or {},
+                    )
+                    outer_target, outer_conf = self._resolve_own_or_ancestor(
+                        outer_id, method_name, arg_count, outer_arg_types,
+                        0.90, 0.80, caller_ctx,
+                        prefer_unique_own=True,
+                        narrowing_args=(
+                            args_node, source, local_types, own_param_types,
+                            self._all_field_types(outer_id),
+                        ),
+                    )
+                    if outer_target is not None:
+                        return outer_target, outer_conf, {}
+                # A bare call unresolved on the own class/ancestors may be a
+                # statically-imported method invoked without a receiver.
+                if method_name in import_map:
+                    # explicit static import: `import static a.b.C.method;`
+                    resolved = import_map[method_name]
+                    cls_path = ".".join(resolved.split(".")[:-1])
+                    cls_id = self._resolve_static_import_class(cls_path, module_name)
+                    if cls_id is not None:
+                        candidates = [
+                            candidate for candidate in self._members_named(
+                                cls_id, method_name, search_ancestors=True,
+                                exclude_constructors=True, caller_class_id=enclosing_class_id,
+                            )
+                            if self._is_static_member(candidate)
+                        ]
+                        static_arg_types = self._contextual_overload_arg_types(
+                            candidates, arg_count, arg_types, args_node, source,
+                            module_name, enclosing_class_id, import_map,
+                            wildcard_packages, local_types, own_param_types,
+                            field_types_own, type_param_bounds or {},
+                        )
+                        st = self._resolve_own_or_ancestor(
+                            cls_id, method_name, arg_count, static_arg_types, 0.85, 0.75,
+                            caller_ctx, static_only=True,
+                            # Static generic utilities such as
+                            # `Preconditions.notNull(T, String)` infer their
+                            # method type variable from the supplied source
+                            # argument just as typed-receiver calls do.
+                            allow_method_type_inference=True,
+                            narrowing_args=(
+                                args_node, source, local_types, own_param_types,
+                                field_types_own,
+                            ),
+                        )
+                        if st[0] is not None:
+                            return st[0], st[1], {}
+                # static wildcard import: `import static a.b.C.*;` — no
+                # binding in `import_map` (the wildcard carries no name to
+                # bind), so every statically-wildcard-imported class's
+                # candidates must be gathered *before* overload resolution
+                # runs (F-03 fix): resolving one class at a time and
+                # returning on the first hit let an earlier `import static`
+                # line shadow a later one that declares an equally-
+                # applicable overload (`run(int)` in both `A` and `B`),
+                # silently picking whichever happened to be imported first
+                # instead of surfacing the real ambiguity. Collecting every
+                # class's own+ancestor candidates into one pool and running
+                # a single `_select_overload` over it reuses the same
+                # exact/strict/loose + `_most_specific` ranking (and its
+                # fan-out-at-reduced-confidence behavior) that already
+                # disambiguates overloads within a single class.
+                wildcard_conf: Dict[str, float] = {}
+                for cls_path in static_wildcard_classes:
+                    cls_id = self._resolve_static_import_class(cls_path, module_name)
+                    if cls_id is None:
+                        continue
+                    own = [
+                        c for c in self._members_named(
+                            cls_id, method_name, search_ancestors=False,
+                            exclude_constructors=True, caller_class_id=enclosing_class_id,
+                        )
+                        if self._is_static_member(c)
+                    ]
+                    own_ids = set(own)
+                    members = [
+                        c for c in self._members_named(
+                            cls_id, method_name, search_ancestors=True,
+                            exclude_constructors=True, caller_class_id=enclosing_class_id,
+                        )
+                        if self._is_static_member(c)
+                    ]
+                    for c in members:
+                        wildcard_conf[c] = 0.85 if c in own_ids else 0.75
+                if wildcard_conf:
+                    wildcard_candidates = list(wildcard_conf)
+                    wildcard_arg_types = self._contextual_overload_arg_types(
+                        wildcard_candidates, arg_count, arg_types, args_node, source,
+                        module_name, enclosing_class_id, import_map,
+                        wildcard_packages, local_types, own_param_types,
+                        field_types_own, type_param_bounds or {},
+                    )
+                    if wildcard_arg_types is None:
+                        wildcard_candidates = self._narrow_candidates_by_known_arg_types(
+                            wildcard_candidates, arg_count, args_node, source,
+                            local_types, own_param_types, field_types_own,
+                            caller_ctx,
+                        )
+                    st = self._select_overload(
+                        wildcard_candidates, arg_count, wildcard_arg_types,
+                        lambda c: wildcard_conf[c], caller_ctx,
+                        allow_method_type_inference=True,
+                    )
+                    if st[0] is not None:
+                        return st[0], st[1], {}
+            if self._annotation_stub_match(enclosing_class_id, method_name):
+                return enclosing_class_id, 0.6, {}
+            return None, 0.0, {}
+
+        if obj_node.type == "object_creation_expression":
+            # Deliberately narrow C08 slice: resolve only a method invoked
+            # directly on `new T(...)`.  Do not teach return propagation how
+            # to derive a type from object creation here, so an outer
+            # `new T().step().finish()` remains out of scope.  Likewise,
+            # require one structural same-name candidate before overload
+            # selection; overloaded root-new calls remain unresolved for
+            # their own follow-up task.
+            type_node = obj_node.child_by_field_name("type")
+            if type_node is None:
+                return None, 0.0, {}
+            created_type = self._text(type_node, source)
+            recv_class_id = self._resolve_declared_type(
+                created_type, module_name, import_map, wildcard_packages,
+                enclosing_class_id,
+            )
+            if recv_class_id is None:
+                return None, 0.0, {}
+            candidates = self._members_named(
+                recv_class_id, method_name, search_ancestors=True,
+                exclude_constructors=True, caller_class_id=enclosing_class_id,
+            )
+            if not candidates:
+                return None, 0.0, {}
+            root_new_arg_types = arg_types
+            if len(candidates) > 1:
+                root_new_arg_types = self._infer_contextual_arg_types(
+                    args_node, source, module_name, enclosing_class_id,
+                    import_map, wildcard_packages, local_types,
+                    own_param_types, field_types_own, type_param_bounds or {},
+                )
+                if root_new_arg_types is None:
+                    return None, 0.0, {}
+            target, conf = self._select_overload(
+                candidates, arg_count, root_new_arg_types,
+                lambda _candidate: 0.9,
+                caller_ctx,
+            )
+            if isinstance(target, str):
+                return target, conf, {}
+            return None, 0.0, {}
+
+        recv_class_id, recv_conf = self._resolve_receiver(
+            obj_node, source, module_name, enclosing_class_id, import_map,
+            wildcard_packages, local_types, field_types_own, own_param_types,
+            type_param_bounds,
+        )
+        if recv_class_id is None:
+            return None, 0.0, {}
+        typed_candidates = self._members_named(
+            recv_class_id, method_name, search_ancestors=True,
+            exclude_constructors=True, caller_class_id=enclosing_class_id,
+        )
+        overload_arg_types = self._contextual_overload_arg_types(
+            typed_candidates, arg_count, arg_types, args_node, source,
+            module_name, enclosing_class_id, import_map, wildcard_packages,
+            local_types, own_param_types, field_types_own,
+            type_param_bounds or {},
+        )
+        target, conf = self._resolve_own_or_ancestor(
+            recv_class_id, method_name, arg_count, overload_arg_types,
+            recv_conf, min(recv_conf, 0.85), caller_ctx,
+            # C07: once the explicit receiver class is resolved strictly,
+            # method-scoped type variables (`T`, `<A extends Appendable>`)
+            # participate in applicability instead of being mistaken for
+            # source class names. Exact concrete/Supplier overloads still win
+            # in `_select_overload`'s existing phase ordering.
+            allow_method_type_inference=True,
+            narrowing_args=(
+                args_node, source, local_types, own_param_types, field_types_own,
+            ),
+        )
+        if target is not None:
+            # P4.12: a typed receiver whose declared type is an interface/
+            # abstract class resolves (per P4.4) to an *abstract* method — the
+            # interface declaration, which has no body and is useless for blast
+            # radius. Fan out to the concrete implementors instead (or narrow
+            # via Spring DI). Only fires when the resolved target is actually
+            # abstract; a concrete method on an abstract class (a template
+            # method) or an interface `default` method keeps its direct edge.
+            fan = self._abstract_fan_out(
+                recv_class_id, target, method_name, arg_count,
+                overload_arg_types,
+                caller_ctx, obj_node, source, enclosing_class_id, own_param_types,
+                local_types,
+            )
+            if fan is not None:
+                return fan
+            return target, conf, {}
+        if self._annotation_stub_match(recv_class_id, method_name):
+            return recv_class_id, min(recv_conf, 0.6), {}
+        return None, 0.0, {}