adl-toolkit 0.0.0-stage → 0.1.3

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

@@ -0,0 +1,278 @@
+"""Java object and explicit-constructor resolution."""
+
+from __future__ import annotations
+
+from typing import Dict, List, Optional, Tuple
+
+from adl_drift.graph.edges import EdgeType
+from adl_drift.lang.java.ids import signature_key
+from adl_drift.lang.java.resolution.constants import argument_nodes
+from adl_drift.lang.java.resolution.model import (
+    ImportContext as _ImportContext,
+    LocalScopes as _LocalScopes,
+)
+
+
+class ConstructorResolutionMixin:
+    def _resolve_constructor(
+        self, call_node, source: bytes, module_name: str, import_map: Dict[str, str],
+        wildcard_packages: List[str],
+        local_types: "_LocalScopes", param_types: Dict[str, str],
+        enclosing_class_id: Optional[str],
+    ) -> Tuple[Optional[str], float, Optional[str]]:
+        """Resolve an `object_creation_expression` to `(class_id,
+        confidence)`. Always targets the CLASS node — mirrors Python's
+        `ClassName(...)` -> CLASS-node INSTANTIATES semantics (P2.8) and the
+        existing `_impact_in_edges` fold of constructor callers onto the
+        class. Overload disambiguation among multiple declared constructors
+        only ever *adjusts confidence*; it never fans out to per-constructor
+        targets, since there is nothing else to point INSTANTIATES at
+        (a documented simplification vs. plain method overloading — see the
+        Fix Applied notes).
+
+        `local_types`/`param_types`/`enclosing_class_id` (the calling
+        method's own locals, parameters, and containing class) feed argument
+        type inference exactly like `_resolve_call` does for method calls —
+        `new Box(value)` must be able to read `value`'s declared type the
+        same way `repo.save(value)` can (P4.4 regression fix: this used to
+        call `_infer_arg_types(..., {}, {}, {})` unconditionally, so a
+        constructor argument's type was *always* treated as unknown even
+        when statically known, which both under-confidently fanned out an
+        otherwise-unambiguous call and — worse — let a sole arity-matching
+        but type-*incompatible* constructor resolve unconditionally at full
+        confidence, since `_select_overload`'s `arg_types is None` branch
+        never runs a type check against a single survivor)."""
+        type_node = call_node.child_by_field_name("type")
+        if type_node is None:
+            return None, 0.0, None
+        cls_id = self._resolve_declared_type(
+            self._text(type_node, source), module_name, import_map, wildcard_packages,
+            enclosing_class_id,
+        )
+        if cls_id is None:
+            return None, 0.0, None
+        cls_node = self.builder._nodes[cls_id]
+        type_kind = cls_node.metadata.get("java_type_kind")
+        if type_kind in ("interface", "enum"):
+            # Interfaces can't be instantiated with `new`, and enum instances
+            # can only come from their declared constants — neither has any
+            # constructor a call site could reach.
+            return None, 0.0, None
+        ctors = self._members_named(
+            cls_id, cls_node.name, search_ancestors=False,
+            caller_class_id=enclosing_class_id,
+        )
+        args_node = call_node.child_by_field_name("arguments")
+        arg_count = self._count_args(args_node)
+        field_types = (
+            self._all_field_types(enclosing_class_id) if enclosing_class_id else {}
+        )
+        arg_types = self._infer_arg_types(
+            args_node, source, local_types, param_types, field_types,
+        )
+        if not ctors:
+            # No explicit constructor: the compiler-generated implicit one
+            # takes zero arguments for a plain class — a call site with any
+            # arguments cannot actually reach it. `record` is the one
+            # exception: its implicit canonical constructor takes one arg
+            # per component, not zero, so check against the component arity
+            # extracted by JavaSymbolExtractor instead.
+            if type_kind == "record":
+                component_types = cls_node.metadata.get("record_component_types")
+                if component_types is not None and self._record_canonical_matches(
+                    component_types, arg_count, arg_types, _ImportContext(
+                        module_name, import_map, wildcard_packages,
+                    ),
+                ):
+                    return cls_id, 0.95, self._record_canonical_signature(component_types)
+                return None, 0.0, None
+            if arg_count == 0:
+                return cls_id, 0.95, "()"
+            return None, 0.0, None
+        # `this` has the statically known enclosing-class type, but the
+        # generic argument inferencer intentionally has no enclosing-class
+        # parameter. Supply that one exact fact here so constructor overloads
+        # such as `new ToStringBuilder(this)` select `(Object)` rather than
+        # retaining an ambiguous candidate set with no constructor signature.
+        args = argument_nodes(args_node)
+        if (
+            arg_types is None and len(args) == 1 and args[0].type == "this"
+            and enclosing_class_id is not None and ":" in enclosing_class_id
+        ):
+            owner_module, owner_qualname = enclosing_class_id.rsplit(":", 1)
+            arg_types = [
+                f"{self.builder._display_module(owner_module)}.{owner_qualname}"
+            ]
+        if arg_types is None and len(ctors) > 1:
+            arg_types = self._infer_contextual_arg_types(
+                args_node, source, module_name, enclosing_class_id, import_map,
+                wildcard_packages, local_types, param_types, field_types, {},
+            )
+        caller_ctx = _ImportContext(
+            module_name, import_map, wildcard_packages, enclosing_class_id,
+        )
+        target, conf = self._select_overload(
+            ctors, arg_count, arg_types, lambda _c: 0.95, caller_ctx,
+        )
+        if target is None:
+            # Every record has a canonical constructor for its components,
+            # even when the source also declares auxiliary constructors.  A
+            # `record Key(Object event, Id id) { Key(Publication p) {...} }`
+            # therefore has a real two-argument construction path although
+            # the extracted member list contains only the auxiliary
+            # one-argument declaration.  Only recover that implicit path
+            # when no declared constructor has the requested arity: if a
+            # declared same-arity candidate was rejected for incompatible
+            # types, preserving that rejection avoids manufacturing an edge.
+            component_types = cls_node.metadata.get("record_component_types")
+            if (
+                type_kind == "record"
+                and component_types is not None
+                and self._record_canonical_matches(
+                    component_types, arg_count, arg_types, caller_ctx,
+                )
+                and not any(self._arity_matches(ctor, arg_count) for ctor in ctors)
+            ):
+                return cls_id, 0.95, self._record_canonical_signature(component_types)
+            # No declared constructor matches this call's arg count — an
+            # INSTANTIATES edge here would point at a constructor the call
+            # site cannot actually reach.
+            return None, 0.0, None
+        selected = target[0] if isinstance(target, list) and len(target) == 1 else target
+        constructor_signature = (
+            signature_key(self._param_type_lists.get(selected, []))
+            if isinstance(selected, str) else None
+        )
+        return cls_id, (0.6 if isinstance(target, list) else conf), constructor_signature
+
+    def _record_canonical_matches(
+        self, component_types: List[str], arg_count: int,
+        arg_types: Optional[List[str]], arg_ctx: _ImportContext,
+    ) -> bool:
+        """Whether a record's implicit canonical constructor accepts a call.
+
+        JLS 8.10.4 gives the canonical constructor the record components'
+        parameter list verbatim.  Consequently, a final ``T...`` component is
+        a real variable-arity parameter, not one array parameter that happens
+        to use an ellipsis in the header.  Records do not materialize that
+        implicit constructor as a function node, so apply the same bounded
+        arity and compatibility rules used for an extracted vararg member.
+        """
+        if not component_types:
+            return arg_count == 0
+        is_vararg = self._is_vararg_param(component_types[-1])
+        fixed_count = len(component_types) - 1 if is_vararg else len(component_types)
+        if arg_count < fixed_count or (not is_vararg and arg_count != fixed_count):
+            return False
+        # Preserve the established implicit-record behavior for ordinary
+        # canonical constructors. This batch only changes the JLS variable-
+        # arity form; widening the new argument-type filter to every record
+        # would reject existing callers whose source type spelling cannot be
+        # fully canonicalized in a multi-module graph.
+        if not is_vararg:
+            return True
+        if arg_types is None:
+            return True
+        if len(arg_types) != arg_count:
+            return False
+        # The record header is declared in the class's own source file.
+        # There is no function node from which `_param_ctx_for()` could read
+        # that context, but source and call contexts are identical for this
+        # implicit member.
+        if not all(
+            self._types_compatible(param, arg, arg_ctx, arg_ctx)
+            for param, arg in zip(component_types[:fixed_count], arg_types[:fixed_count])
+        ):
+            return False
+        trailing = arg_types[fixed_count:]
+        array_type = component_types[-1].replace("...", "[]")
+        if len(trailing) == 1 and self._types_compatible(
+            array_type, trailing[0], arg_ctx, arg_ctx,
+        ):
+            return True
+        component_type = self._vararg_component_type(array_type)
+        return all(
+            self._types_compatible(component_type, arg, arg_ctx, arg_ctx)
+            for arg in trailing
+        )
+
+    @staticmethod
+    def _record_canonical_signature(component_types: List[str]) -> str:
+        """Metric identity for a record's implicit canonical constructor.
+
+        The source-level JavaParser oracle represents a canonical varargs
+        component as its element type (``Object``), while ordinary declared
+        constructor symbols retain erased array identity (``Object[]``).
+        Keep that oracle-compatible projection confined to the implicit
+        record member; overload identity for real declared constructors is
+        unchanged.
+        """
+        if component_types and component_types[-1].strip().endswith("..."):
+            return signature_key([*component_types[:-1], component_types[-1].replace("...", "")])
+        return signature_key(component_types)
+
+    def _resolve_explicit_constructor(
+        self, call_node, source: bytes, module_name: str, import_map: Dict[str, str],
+        wildcard_packages: List[str], local_types: "_LocalScopes",
+        param_types: Dict[str, str], enclosing_class_id: Optional[str],
+    ) -> Tuple[Optional[str], float, Optional[str]]:
+        """Resolve ``this(...)``/``super(...)`` to the constructed class node."""
+        if enclosing_class_id is None:
+            return None, 0.0, None
+        keyword = self._text(call_node.named_children[0], source)
+        if keyword == "this":
+            cls_id = enclosing_class_id
+        elif keyword == "super":
+            parents = self._declared_direct_ancestors.get(
+                (enclosing_class_id, EdgeType.INHERITS), []
+            )
+            if not parents:
+                return None, 0.0, None
+            cls_id = parents[0]
+        else:
+            return None, 0.0, None
+
+        cls_node = self.builder._nodes.get(cls_id)
+        if cls_node is None:
+            return None, 0.0, None
+        ctors = self._members_named(
+            cls_id, cls_node.name, search_ancestors=False,
+            caller_class_id=enclosing_class_id,
+        )
+        args_node = next(
+            (child for child in call_node.named_children if child.type == "argument_list"),
+            None,
+        )
+        arg_count = self._count_args(args_node)
+        if not ctors:
+            return (cls_id, 0.95, "()") if arg_count == 0 else (None, 0.0, None)
+        arg_types = self._infer_arg_types(
+            args_node, source, local_types, param_types,
+            self._all_field_types(enclosing_class_id),
+        )
+        if arg_types is None and len(ctors) > 1:
+            arg_types = self._infer_contextual_arg_types(
+                args_node, source, module_name, enclosing_class_id, import_map,
+                wildcard_packages, local_types, param_types,
+                self._all_field_types(enclosing_class_id), {},
+            )
+        target, confidence = self._select_overload(
+            ctors, arg_count, arg_types, lambda _candidate: 0.95,
+            _ImportContext(
+                module_name, import_map, wildcard_packages, enclosing_class_id,
+            ),
+        )
+        if target is None:
+            return None, 0.0, None
+        # Unlike `_resolve_constructor`, `this()`/`super()`'s target class is
+        # never in doubt (it's always the current class or its direct
+        # ancestor) — an ambiguous overload pick (`target` is a list of
+        # arity-matching candidates whose arg types weren't statically known)
+        # still means the class itself is reached, just at reduced
+        # confidence and with no single constructor signature to report.
+        selected = target[0] if isinstance(target, list) and len(target) == 1 else target
+        constructor_signature = (
+            signature_key(self._param_type_lists.get(selected, []))
+            if isinstance(selected, str) else None
+        )
+        return cls_id, (0.6 if isinstance(target, list) else confidence), constructor_signature

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

@@ -0,0 +1,305 @@
+"""CST collection and lightweight indexes for Java resolution."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from pathlib import Path
+from typing import Dict, List, Set, Tuple
+
+from adl_drift.graph.node import NodeType
+from adl_drift.lang.base import ParseResult
+from adl_drift.lang.java.ids import DEFAULT_PACKAGE
+from adl_drift.lang.java.resolution.constants import (
+    _ENCLOSING_TYPE_CST_TYPES,
+    _INIT_BLOCK_PARENTS,
+    _METHOD_CST_TYPES,
+    _NESTED_SCOPE_BOUNDARY,
+)
+from adl_drift.lang.java.resolution.model import MethodFacts
+from adl_drift.utils.types import AnalysisResult
+
+
+def _node_text(node, source: bytes) -> str:
+    return source[node.start_byte:node.end_byte].decode("utf-8", errors="replace")
+
+
+class ContextResolutionMixin:
+    def _collect_annotation_type_names(
+        self, parses: Dict[Path, ParseResult]
+    ) -> Dict[str, Set[str]]:
+        """Simple name -> FQNs of every `@interface Foo {}` (`annotation_
+        type_declaration`) declared across the analyzed source — used by
+        `_annotation_stub_match` to tell a project's own annotation apart
+        from an (always-external) Lombok one. Read straight from the CST
+        because `JavaSymbolExtractor` does not emit a graph node for an
+        annotation type (it is not in `_CLASS_TYPES`), so there is no
+        `_by_module_symbol` entry to consult.
+
+        FQN = declaring file's package (via `self._file_ctx`, already built
+        by the time `resolve_calls()` calls this) + every enclosing
+        class/interface/enum/record/annotation-type name (outermost first,
+        via `_enclosing_type_chain`) + simple name, or just that chain for a
+        default-package file — mirrors how Java itself scopes a (possibly
+        nested) `@interface` declaration: `class Marks { @interface Getter
+        {} }` in package `app` canonically names as `app.Marks.Getter`,
+        never `app.Getter` (F-01 fix — the enclosing chain used to be
+        dropped, so a nested project annotation collapsed onto the same key
+        as an unrelated top-level declaration and lost its "local"
+        status). Keying by simple name alone (pre-F-02) let an unrelated
+        package's `@interface Getter` blind the Lombok-stub check for every
+        *other* package's `@Getter`/`@lombok.Getter` in the whole
+        project."""
+        names: Dict[str, Set[str]] = defaultdict(set)
+        for file_path, parse in parses.items():
+            ctx = self._file_ctx.get(str(file_path))
+            package = ctx.module if ctx is not None else DEFAULT_PACKAGE
+            stack = [parse.tree.root_node]
+            while stack:
+                node = stack.pop()
+                if node.type == "annotation_type_declaration":
+                    name_node = node.child_by_field_name("name")
+                    if name_node is not None:
+                        simple = self._text(name_node, parse.source_bytes)
+                        segments = self._enclosing_type_chain(node, parse.source_bytes)
+                        segments.append(simple)
+                        fqn = (
+                            ".".join(segments) if package == DEFAULT_PACKAGE
+                            else f"{package}.{'.'.join(segments)}"
+                        )
+                        names[simple].add(fqn)
+                stack.extend(node.children)
+        return dict(names)
+
+    @staticmethod
+    def _enclosing_type_chain(node, source: bytes) -> List[str]:
+        """Names of `node`'s enclosing class/interface/enum/record/
+        annotation-type ancestors, outermost first — mirrors
+        `JavaSymbolExtractor._scope_chain`'s type-only case (an annotation
+        type can only nest inside another type, never inside a method, so
+        no method/anonymous-class segment handling is needed here)."""
+        chain: List[str] = []
+        p = node.parent
+        while p is not None:
+            if p.type in _ENCLOSING_TYPE_CST_TYPES:
+                nn = p.child_by_field_name("name")
+                if nn is not None:
+                    chain.append(_node_text(nn, source))
+            p = p.parent
+        chain.reverse()
+        return chain
+
+    # ------------------------------------------------------------------ P4.12 index builders
+
+    def _build_subtype_index(self) -> Dict[str, Set[str]]:
+        """Reverse of INHERITS ∪ IMPLEMENTS: every CLASS id -> the set of all
+        transitive subtype CLASS ids. Built by walking each class's *forward*
+        ancestor chain (`_class_ancestors`, already BFS over both edge kinds)
+        and recording the class under each ancestor — so an interface maps to
+        every class that implements it directly *or* through an intermediate
+        abstract class (`StripeGateway extends AuditedGateway implements ...`),
+        which is exactly the implementor set the fan-out enumerates."""
+        subtypes: Dict[str, Set[str]] = defaultdict(set)
+        for nid, node in self.builder._nodes.items():
+            if node.node_type != NodeType.CLASS:
+                continue
+            for anc in self._class_ancestors(nid):
+                subtypes[anc].add(nid)
+        return subtypes
+
+    def _iter_method_cst(self, root, file_path_str: str, func_id_by_position):
+        """Yield (method_declaration/constructor_declaration CST node,
+        node_id) for every method in the file.
+
+        Looks the id up by `(file_path, start_line, start_column)` against
+        the index built from `results` in `resolve_calls` rather than
+        re-deriving the `module:qualname` id from the CST — the id shape
+        (scope chain + P4.5 signature_key discriminator) is already computed
+        once by `JavaSymbolExtractor`/`CallGraphBuilder._symbol_to_id`;
+        duplicating that logic here would be a second, driftable source of
+        truth. The column is load-bearing, not decorative: two methods
+        routinely share one line (`void a() {} void b() {}`), and a
+        line-only key would silently drop one of them from this walk —
+        no call-site resolution, no DI indexing, no warning (F-02).
+        """
+        # Six index-building passes plus the call-site pass each walk every
+        # file's whole CST through here; the (node, id) list is identical on
+        # every pass of one resolution run (same tree object, same position
+        # index), so build it once per file and replay it. `_method_cst_cache`
+        # is reset at the top of `_build_resolution_indexes`, so an
+        # incremental rebuild with a re-parsed file never sees a stale tree.
+        # tree-sitter's Python binding hands out a fresh `Node` wrapper on
+        # every `tree.root_node` access (`is` never matches); `Node.id` is
+        # the underlying node's identity within its tree, so key on that.
+        cache = self._method_cst_cache
+        cached = cache.get(file_path_str) if cache is not None else None
+        if cached is not None and cached[0] == root.id:
+            yield from cached[1]
+            return
+        found = []
+        for node in self._cst_index(root, file_path_str)["__methods__"]:
+            nid = func_id_by_position.get(
+                (file_path_str, node.start_point[0] + 1, node.start_point[1]),
+            )
+            if nid:
+                found.append((node, nid))
+        if cache is not None:
+            cache[file_path_str] = (root.id, found)
+        yield from found
+
+    def _cst_index(self, root, file_path_str: str) -> Dict[str, list]:
+        """One stack-DFS walk of `root` per file per resolution run, shared by
+        every index-building pass that used to walk the whole tree itself.
+        `"__methods__"`: every `_METHOD_CST_TYPES` node, in the exact order the
+        old per-pass walk yielded them. `"__fields__"`: `field_declaration`
+        nodes not nested inside another field's initializer — the old field
+        walks stopped descending at a field_declaration, so a field declared
+        by an anonymous class inside a field initializer was never visited,
+        and still isn't. `"__initializer_nodes__"` keeps every declaration
+        shape the initializer resolver needs; unlike `__fields__`, it does
+        include nested/anonymous-class fields, matching the old fresh walk.
+        Cached in `_cst_index_cache` keyed on `Node.id`."""
+        cache = self._cst_index_cache
+        cached = cache.get(file_path_str) if cache is not None else None
+        if cached is not None and cached[0] == root.id:
+            return cached[1]
+        methods: list = []
+        fields: list = []
+        initializer_nodes: list = []
+        stack = [(root, False)]
+        while stack:
+            node, inside_field = stack.pop()
+            node_type = node.type
+            if node_type in _METHOD_CST_TYPES:
+                methods.append(node)
+            elif node_type == "field_declaration":
+                if not inside_field:
+                    fields.append(node)
+                initializer_nodes.append(node)
+                inside_field = True
+            elif node_type == "static_initializer":
+                initializer_nodes.append(node)
+            elif node_type == "block" and node.parent is not None \
+                    and node.parent.type in _INIT_BLOCK_PARENTS:
+                initializer_nodes.append(node)
+            stack.extend((child, inside_field) for child in node.children)
+        index = {
+            "__methods__": methods,
+            "__fields__": fields,
+            "__initializer_nodes__": initializer_nodes,
+        }
+        if cache is not None:
+            cache[file_path_str] = (root.id, index)
+        return index
+
+    def _field_declarations(self, root, file_path_str: str) -> list:
+        """Top-level `field_declaration` nodes of a file (see `_cst_index`)."""
+        return self._cst_index(root, file_path_str)["__fields__"]
+
+    def _initializer_declarations(self, root, file_path_str: str) -> list:
+        """All initializer-owning CST nodes of a file (see `_cst_index`)."""
+        return self._cst_index(root, file_path_str)["__initializer_nodes__"]
+
+    def _method_extractor(self):
+        """Lazily build (and cache) a `JavaSymbolExtractor` used only by
+        `_iter_func_cst` to derive Symbols the same way the real graph nodes
+        were built. `JavaSymbolExtractor._extract_method` only calls
+        `self.parser.node_text`/`node_position` (both `@staticmethod`s on
+        `LanguageParser`), so any real Java `LanguageParser` works here —
+        there is no per-file state to keep in sync."""
+        if self._method_extractor_cache is None:
+            from adl_drift.lang.java.extractor import JavaSymbolExtractor
+            from adl_drift.lang.java.parser import create_parser
+            self._method_extractor_cache = JavaSymbolExtractor(create_parser())
+        return self._method_extractor_cache
+
+    def _iter_func_cst(self, root, source: bytes, module_name: str):
+        """Yield (method/constructor CST node, node_id) for every method in
+        the file — P4.6's cross-function taint index (`detectors/taint.py::
+        TaintAnalyzer._build_func_index`), mirroring `PythonCallResolver.
+        _iter_func_cst`'s contract.
+
+        Unlike `_iter_method_cst` above (used by `resolve_calls`, which
+        looks the id up in a position index built earlier in that same
+        pass), this is called standalone by the taint analyzer with only a
+        CST root — so it derives each method's `Symbol` itself via
+        `JavaSymbolExtractor._extract_method` (the exact function that built
+        the real graph nodes) and turns it into an id via
+        `CallGraphBuilder._symbol_to_id`. Using the same two functions the
+        graph itself used guarantees the taint `function_id` always matches
+        the real FUNCTION node id — not a second, independently-derived
+        scheme (scope_chain + P4.5 signature_key) that could silently drift
+        out of sync with the extractor's own.
+        """
+        from adl_drift.lang.java.extractor import _METHOD_TYPES
+
+        extractor = self._method_extractor()
+        anon_index = extractor._index_anonymous_classes(root)
+        stack = [root]
+        while stack:
+            node = stack.pop()
+            if node.type in _METHOD_TYPES:
+                sym = extractor._extract_method(node, source, Path("."), anon_index)
+                if sym is not None:
+                    nid = self.builder._symbol_to_id(sym, module_name)
+                    yield node, nid
+            stack.extend(node.children)
+
+    def _method_facts(self, body) -> MethodFacts:
+        """Return one body walk's reusable call/reference CST facts.
+
+        The cache is deliberately per-resolution-run and keys on ``Node.id``:
+        tree-sitter re-wraps a CST node on access, but the underlying id is
+        stable for a parsed tree.  Facts are tuples so no consumer can mutate
+        the shared view; all semantic resolution remains in its existing
+        passes.  This preserves the old nested-class/method exclusion exactly.
+        """
+        cache = self._method_facts_cache
+        if cache is not None:
+            hit = cache.get(body.id)
+            if hit is not None:
+                return hit
+        call_sites: List[Tuple[object, str]] = []
+        method_references: List[object] = []
+        assignment_expressions: List[object] = []
+        local_scope_nodes: List[object] = []
+        lambda_expressions: List[object] = []
+        stack = [body]
+        while stack:
+            node = stack.pop()
+            if node.type == "method_invocation":
+                call_sites.append((node, "method"))
+            elif node.type == "object_creation_expression":
+                call_sites.append((node, "object_creation"))
+            elif node.type == "explicit_constructor_invocation":
+                call_sites.append((node, "explicit_constructor"))
+            elif node.type == "method_reference":
+                call_sites.append((node, "method_reference"))
+                method_references.append(node)
+            if node.type == "assignment_expression":
+                assignment_expressions.append(node)
+            elif node.type in {
+                "local_variable_declaration", "enhanced_for_statement",
+                "resource", "catch_formal_parameter", "instanceof_expression",
+            }:
+                local_scope_nodes.append(node)
+            elif node.type == "lambda_expression":
+                lambda_expressions.append(node)
+            if node.type in _NESTED_SCOPE_BOUNDARY:
+                continue
+            stack.extend(node.children)
+        facts = MethodFacts(
+            tuple(call_sites), tuple(method_references),
+            tuple(assignment_expressions), tuple(local_scope_nodes),
+            tuple(lambda_expressions),
+        )
+        if cache is not None:
+            cache[body.id] = facts
+        return facts
+
+    def _collect_call_sites(self, body):
+        """Call-site facts for ``body`` from its shared ``MethodFacts`` walk."""
+        return self._method_facts(body).call_sites
+
+    def _collect_method_references(self, body) -> Tuple[object, ...]:
+        """Method-reference facts for ``body`` from its shared CST walk."""
+        return self._method_facts(body).method_references