adl-toolkit 0.0.0-stage → 0.1.3

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

@@ -0,0 +1,866 @@
+"""Execution-order-preserving orchestration for Java call resolution."""
+
+from __future__ import annotations
+
+import copy
+import logging
+import multiprocessing
+import os
+import sys
+from collections import defaultdict
+from concurrent.futures import ProcessPoolExecutor
+from concurrent.futures.process import BrokenProcessPool
+from pathlib import Path
+from typing import Dict, List, Set, Tuple
+
+from adl_drift.graph.edges import EdgeType, GraphEdge
+from adl_drift.graph.node import GraphNode, NodeType
+from adl_drift.lang.base import ParseResult
+from adl_drift.lang.java.resolution.constants import (
+    _ENCLOSING_TYPE_CST_TYPES,
+    _INIT_BLOCK_PARENTS,
+)
+from adl_drift.lang.java.resolution.model import ImportContext as _ImportContext
+from adl_drift.utils.types import AnalysisResult
+
+logger = logging.getLogger(__name__)
+
+
+class _ProcessEdgeCollector:
+    """Worker-local edge sink over the parent's read-only graph snapshot."""
+
+    def __init__(self, base) -> None:
+        self._base = base
+        self._nodes = base._nodes
+        self.graph = base.graph
+        # The worker must observe edges it has already emitted.  Reading the
+        # parent's key set alone would emit duplicate dependency edges from
+        # two call sites in the same file and make `edges_added` inaccurate.
+        self._edge_keys = set(base._edge_keys)
+        self._occurrence_keys = set(base._occurrence_keys)
+        self.edges: List[GraphEdge] = []
+        self.occurrences: List[GraphEdge] = []
+
+    def _add_edge(self, edge: GraphEdge) -> None:
+        key = (edge.source, edge.target, edge.edge_type)
+        if key in self._edge_keys:
+            return
+        self._edge_keys.add(key)
+        self.edges.append(edge)
+
+    def _record_edge_occurrence(self, edge: GraphEdge) -> None:
+        key = (
+            edge.source, edge.target, edge.edge_type, edge.file_path,
+            edge.start_byte if edge.start_byte is not None else edge.line,
+            edge.end_byte if edge.end_byte is not None else edge.column,
+        )
+        if key in self._occurrence_keys:
+            return
+        self._occurrence_keys.add(key)
+        self.occurrences.append(edge)
+
+    def __getattr__(self, name: str):
+        return getattr(self._base, name)
+
+
+def _edge_order(edge: GraphEdge) -> tuple:
+    return (
+        edge.file_path or "", edge.line if edge.line is not None else -1,
+        edge.column if edge.column is not None else -1,
+        edge.start_byte if edge.start_byte is not None else -1,
+        edge.end_byte if edge.end_byte is not None else -1,
+        edge.source, edge.target, edge.edge_type.name,
+    )
+
+
+# Set immediately before forking.  ParseResult/Tree objects are intentionally
+# not sent through the process queue (they are not pickleable); Linux fork gives
+# workers a copy-on-write read-only view of the completed resolution index.
+_PROCESS_RESOLVER = None
+_PROCESS_PARSES = None
+_PROCESS_RESULTS = None
+_PROCESS_FUNC_IDS = None
+
+# A failed pool has not mutated the parent graph: workers return data only.
+# Fall back to the existing sequential path rather than making an optional
+# speed-up a new availability requirement.
+_PROCESS_POOL_FAILURES = (BrokenProcessPool, OSError, RuntimeError)
+
+
+def _resolve_one_forked(file_path: Path):
+    resolver = copy.copy(_PROCESS_RESOLVER)
+    collector = _ProcessEdgeCollector(_PROCESS_RESOLVER.builder)
+    resolver.builder = collector
+    resolver._method_cst_cache = {}
+    resolver._cst_index_cache = {}
+    resolver._method_facts_cache = {}
+    resolver._local_scopes_cache = {}
+    resolver._declaring_class_cache = {}
+    resolver._members_by_name_cache = {}
+    resolver._erased_signature_cache = {}
+    resolver._param_ctx_for_cache = {}
+    resolver._declared_type_memo = {}
+    resolver._class_ancestors_cache = {}
+    resolver._contains_children_cache = {}
+    resolver.fanout_telemetry = {
+        "mode": resolver._fanout_mode, "cap": resolver._fanout_cap,
+        "candidate_counts": [], "emitted_counts": [], "cap_skipped": 0,
+    }
+    parse = _PROCESS_PARSES[file_path]
+    result = _PROCESS_RESULTS.get(file_path)
+    if result is not None:
+        resolver._resolve_project_call_sites_sequential(
+            {file_path: parse}, {file_path: result}, _PROCESS_FUNC_IDS, 0,
+        )
+    return collector.edges, collector.occurrences, resolver.fanout_telemetry
+
+
+class ResolutionOrchestrationMixin:
+    def _run_resolution_passes(
+        self,
+        parses: Dict[Path, ParseResult],
+        results: Dict[Path, AnalysisResult],
+    ) -> int:
+        """Emit CALLS (method_invocation) / INSTANTIATES
+        (object_creation_expression) edges for every call site.
+
+        No AWAITS (Java has no `await` expression) and no P1.8 REFERENCES
+        pass here — field/variable *reads* outside of a call are not part of
+        this issue's scope (P4.4 is call resolution; a Java REFERENCES pass
+        would be an additive follow-up, not required by PROBLEMS.md's "what
+        the fix looks like" list for this issue).
+        """
+        func_id_by_position, edges_added = self._build_resolution_indexes(
+            parses, results,
+        )
+        return self._resolve_project_call_sites(
+            parses, results, func_id_by_position, edges_added,
+        )
+
+    def _build_resolution_indexes(
+        self, parses: Dict[Path, ParseResult], results: Dict[Path, AnalysisResult],
+    ) -> Tuple[Dict[Tuple[str, int, int], str], int]:
+        # Per-run caches (see resolver.__init__): the graph's node set and
+        # CONTAINS edges are fixed for the whole run, the method-CST index
+        # keys on the tree object, and the declared-type memo is armed only
+        # at the end of this method once every index it reads exists.
+        self._method_cst_cache = {}
+        self._cst_index_cache = {}
+        self._method_facts_cache = {}
+        self._local_scopes_cache = {}
+        self._declaring_class_cache = {}
+        self._members_by_name_cache = {}
+        self._erased_signature_cache = {}
+        self._param_ctx_for_cache = {}
+        self._declared_type_memo = None
+        self._file_import_map_ids = frozenset()
+        by_module_symbol: Dict[str, Dict[str, str]] = defaultdict(dict)
+        field_types: Dict[str, Dict[str, str]] = defaultdict(dict)
+        field_nodes: Dict[str, Dict[str, str]] = defaultdict(dict)
+        # Keyed by (file, line, column) — not just (file, line). Two type
+        # declarations routinely start on the same *line* (`} class Box<T> {`
+        # closing a preceding class, or compact/generated/minified source),
+        # and a line-only key silently collides, dropping whichever
+        # declaration loses the last-write-wins race (F-02: `Box`'s own
+        # `<T>` type parameters attributed to an unrelated class sharing its
+        # line, breaking generic narrowing with no warning). Two
+        # declarations can never share a start *column* too, so the triple
+        # is collision-free.
+        class_id_by_position: Dict[Tuple[str, int, int], str] = {}
+        for nid, node in self.builder._nodes.items():
+            if node.language != "java":
+                continue
+            if node.node_type == NodeType.CLASS:
+                by_module_symbol[node.module][node.name] = nid
+                class_id_by_position[(node.file_path, node.line, node.column)] = nid
+            elif node.node_type == NodeType.VARIABLE and node.contained_in and node.signature:
+                class_id = self._declaring_class_id(nid)
+                if class_id is None:
+                    continue
+                field_types[class_id][node.name] = node.signature
+                field_nodes[class_id][node.name] = nid
+        self._by_module_symbol = by_module_symbol
+        self._field_types = field_types
+        self._field_nodes = field_nodes
+        # P4.12 reverse hierarchy index, built off the now-complete node/edge
+        # graph. The `@Bean` factory list also needs `self._file_ctx` (a
+        # `@Bean` return type resolves against its declaring file's imports),
+        # so it is built lower down, once `file_ctx` exists.
+        self._subtypes = self._build_subtype_index()
+
+        param_type_lists: Dict[str, List[str]] = {}
+        # Same (file, line, column) reasoning as `class_id_by_position`
+        # above: two methods routinely share a line (`void a() {} void b()
+        # {}`), and a line-only key drops one of them from `_iter_method_cst`
+        # entirely — not a narrowing miss but the caller's whole call-site
+        # scan (and constructor/setter DI indexing) silently skipped.
+        func_id_by_position: Dict[Tuple[str, int, int], str] = {}
+        file_ctx: Dict[str, _ImportContext] = {}
+        static_wildcard_by_file: Dict[str, List[str]] = {}
+        for path, ar in results.items():
+            mod = self.builder._module_for_result(ar)
+            # Each candidate method's parameter types must resolve against
+            # *its own declaring file's* imports, not whichever call site
+            # happens to be resolving against it right now — see
+            # `_ImportContext`. Keyed by file path, not by `mod`: Java's
+            # module id is the declared `package`, so several files
+            # routinely share one module, each with its own import list.
+            file_ctx[str(path)] = _ImportContext(
+                mod,
+                self.builder._import_map_for(ar, mod),
+                self.builder._wildcard_packages_for(ar, mod),
+            )
+            static_wildcard_by_file[str(path)] = (
+                self.builder._static_wildcard_classes_for(ar, mod)
+            )
+            for sym in ar.symbols:
+                if sym.kind != "function":
+                    continue
+                fid = self.builder._symbol_to_id(sym, mod)
+                param_type_lists[fid] = list(sym.param_types.values())
+                func_id_by_position[
+                    (str(sym.file_path), sym.position.line, sym.position.column)
+                ] = fid
+        param_type_lists.update(self._ensure_generated_member_stubs())
+        self._param_type_lists = param_type_lists
+        self._class_id_by_position = class_id_by_position
+        # Bug group 4 fix: materialize the synthetic `<init>`/`<clinit>`
+        # FUNCTION each class needs *before* `_resolve_project_call_sites`
+        # runs, the same way `_ensure_generated_member_stubs` above
+        # materializes `values()`/`valueOf()`/record accessors — those are
+        # real call *targets* the extractor never emits a Symbol for; these
+        # are real call *sources* (a field initializer or `static { }` block
+        # invoking something) it never emits one for either, so without a
+        # matching FUNCTION node here `_resolve_initializer_call_sites`
+        # would have nothing to attribute the edge to.
+        self._synthesize_initializer_members(parses, class_id_by_position)
+        self._method_type_param_bounds = self._collect_method_type_param_bounds(
+            parses, func_id_by_position,
+        )
+        self._file_ctx = file_ctx
+        self._static_wildcard_by_file = static_wildcard_by_file
+        declared_ancestors: Dict[Tuple[str, EdgeType], List[str]] = defaultdict(list)
+        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
+                for edge_type, parent_names in (
+                    (EdgeType.INHERITS, sym.superclasses),
+                    (EdgeType.IMPLEMENTS, sym.implements),
+                ):
+                    for parent_name in parent_names:
+                        parent_id = self._resolve_declared_type(
+                            parent_name, ctx.module, ctx.import_map,
+                            ctx.wildcard_packages, class_id,
+                        )
+                        if parent_id and parent_id != class_id:
+                            declared_ancestors[(class_id, edge_type)].append(parent_id)
+        self._declared_direct_ancestors = {
+            key: list(dict.fromkeys(values))
+            for key, values in declared_ancestors.items()
+        }
+        # `_class_ancestors`/`_contains_children`'s memoization caches must
+        # not outlive the graph state they were computed against (see
+        # resolution/overloads.py) — reset them here, alongside
+        # `_declared_direct_ancestors`, on every resolution pass. This runs
+        # after `_ensure_generated_member_stubs()` above, so the reset
+        # covers any CONTAINS edges that call added too.
+        self._class_ancestors_cache = {}
+        self._contains_children_cache = {}
+        # Rebuild from the exact resolver hierarchy (plus graph edges) now
+        # that the per-file import contexts exist.
+        self._subtypes = self._build_subtype_index()
+        self._local_annotation_type_names = self._collect_annotation_type_names(parses)
+        self._class_type_params = self._collect_class_type_params(
+            parses, class_id_by_position,
+        )
+        self._class_type_param_bounds = self._collect_class_type_param_bounds(
+            parses, class_id_by_position,
+        )
+        self._ancestor_type_args = self._collect_ancestor_type_args(
+            results, class_id_by_position, file_ctx,
+        )
+        self._field_allocation_types = self._build_field_allocation_index(
+            parses, func_id_by_position, class_id_by_position,
+        )
+        # `@Bean` factory beans (P4.12 DI): resolves each factory method's
+        # return type against its declaring file's imports, so it must run
+        # after `self._file_ctx` is populated above.
+        self._bean_method_candidates = self._build_bean_method_candidates()
+        self._di_injected_fields = {
+            **self._build_constructor_injection_index(
+                parses, results, func_id_by_position,
+            ),
+            **self._build_setter_injection_index(
+                parses, results, func_id_by_position,
+            ),
+        }
+        edge_count_before_callable_fields = len(self.builder._edges)
+        self._field_callable_targets = self._index_field_callable_targets(
+            parses, class_id_by_position, func_id_by_position,
+        )
+
+        self._file_import_map_ids = frozenset(
+            id(ctx.import_map) for ctx in self._file_ctx.values()
+        )
+        self._declared_type_memo = {}
+        return (
+            func_id_by_position,
+            len(self.builder._edges) - edge_count_before_callable_fields,
+        )
+
+    def _resolve_project_call_sites(
+        self, parses: Dict[Path, ParseResult], results: Dict[Path, AnalysisResult],
+        func_id_by_position: Dict[Tuple[str, int, int], str], edges_added: int,
+    ) -> int:
+        """Resolve calls, optionally using a Linux fork process pool.
+
+        This experimental path is opt-in because it relies on ``fork`` to
+        share the non-pickleable Tree-sitter parse trees copy-on-write.  Each
+        process has private resolver caches and edge buffers; only this main
+        process changes the real graph after deterministic sorting.
+        """
+        if self._should_process_resolve(parses):
+            raw_workers = os.environ.get("DRIFT_JAVA_RESOLVE_WORKERS", "")
+            try:
+                workers = int(raw_workers) if raw_workers else min(os.cpu_count() or 1, 8)
+            except ValueError:
+                workers = min(os.cpu_count() or 1, 8)
+            workers = min(workers, len(parses))
+            if workers > 1:
+                global _PROCESS_RESOLVER, _PROCESS_PARSES, _PROCESS_RESULTS, _PROCESS_FUNC_IDS
+                _PROCESS_RESOLVER = self
+                _PROCESS_PARSES = parses
+                _PROCESS_RESULTS = results
+                _PROCESS_FUNC_IDS = func_id_by_position
+                try:
+                    context = multiprocessing.get_context("fork")
+                    with ProcessPoolExecutor(max_workers=workers, mp_context=context) as pool:
+                        resolved = list(pool.map(_resolve_one_forked, sorted(parses)))
+                except _PROCESS_POOL_FAILURES as exc:
+                    logger.warning(
+                        "Java resolve process pool unavailable (%s: %s); "
+                        "falling back to sequential resolution.",
+                        type(exc).__name__, exc,
+                    )
+                    return self._resolve_project_call_sites_sequential(
+                        parses, results, func_id_by_position, edges_added,
+                    )
+                finally:
+                    _PROCESS_RESOLVER = _PROCESS_PARSES = _PROCESS_RESULTS = _PROCESS_FUNC_IDS = None
+                for edges, occurrences, telemetry in resolved:
+                    for edge in sorted(occurrences, key=_edge_order):
+                        self.builder._record_edge_occurrence(edge)
+                    for edge in sorted(edges, key=_edge_order):
+                        key = (edge.source, edge.target, edge.edge_type)
+                        if key in self.builder._edge_keys:
+                            continue
+                        self.builder._add_edge(edge)
+                        # Workers mutate copy-on-write GraphNodes only.  Keep
+                        # the public node-level adjacency sets equivalent to
+                        # the sequential resolver while the parent remains
+                        # the sole writer of the real graph.
+                        self.builder._nodes[edge.source].calls.add(edge.target)
+                        self.builder._nodes[edge.target].called_by.add(edge.source)
+                    self.fanout_telemetry["candidate_counts"].extend(telemetry["candidate_counts"])
+                    self.fanout_telemetry["emitted_counts"].extend(telemetry["emitted_counts"])
+                    self.fanout_telemetry["cap_skipped"] += telemetry["cap_skipped"]
+                return edges_added + sum(len(edges) for edges, _, _ in resolved)
+        return self._resolve_project_call_sites_sequential(
+            parses, results, func_id_by_position, edges_added,
+        )
+
+    @staticmethod
+    def _should_process_resolve(parses: Dict[Path, ParseResult]) -> bool:
+        """Whether the opt-in fork implementation is usable for this run.
+
+        `fork` is deliberately Linux-only.  On spawn-only platforms a child
+        cannot inherit Tree-sitter trees or the resolver's read-only indexes,
+        and serialising that state is a different implementation strategy.
+        Never nest this pool inside another multiprocessing worker either.
+        """
+        return (
+            os.environ.get("DRIFT_JAVA_PROCESS_RESOLVE") == "1"
+            and sys.platform.startswith("linux")
+            and "fork" in multiprocessing.get_all_start_methods()
+            and multiprocessing.parent_process() is None
+            and len(parses) >= 12
+        )
+
+    def _resolve_project_call_sites_sequential(
+        self, parses: Dict[Path, ParseResult], results: Dict[Path, AnalysisResult],
+        func_id_by_position: Dict[Tuple[str, int, int], str], edges_added: int,
+    ) -> int:
+        for file_path, parse in parses.items():
+            result = results.get(file_path)
+            if result is None:
+                continue
+            module_name = self.builder._module_for_result(result)
+            caller_ctx = self._file_ctx[str(file_path)]
+            import_map = caller_ctx.import_map
+            wildcard_packages = caller_ctx.wildcard_packages
+            static_wildcard_classes = self._static_wildcard_by_file.get(str(file_path), [])
+            source = parse.source_bytes
+            fp_str = str(file_path)
+
+            for func_cst, caller_id in self._iter_method_cst(
+                parse.tree.root_node, fp_str, func_id_by_position
+            ):
+                if caller_id not in self.builder._nodes:
+                    continue
+                caller_node = self.builder._nodes[caller_id]
+                enclosing_class_id = self._declaring_class_id(caller_id)
+                field_types_own = (
+                    self._visible_bare_field_types(enclosing_class_id)
+                    if enclosing_class_id else {}
+                )
+                body = func_cst.child_by_field_name("body")
+                if body is None:
+                    continue
+
+                own_param_types = dict(
+                    zip(
+                        self._param_names(func_cst, source),
+                        self._param_type_lists.get(caller_id, []),
+                    )
+                )
+                # A method declared in an anonymous/local class may read an
+                # effectively-final parameter of its lexical enclosing method.
+                # Add only that enclosing method's declared parameters; its
+                # locals and fields remain governed by their ordinary scopes.
+                captured_param_types = self._captured_param_types(
+                    func_cst, source, fp_str, func_id_by_position,
+                )
+                captured_param_types.update(own_param_types)
+                own_param_types = captured_param_types
+                # P4.12 generic narrowing: `<T extends StripeGateway>` binds a
+                # method type parameter to a concrete upper bound, so a receiver
+                # declared `T` resolves to that bound (narrowing the fan-out, or
+                # pinning it to one concrete class) instead of dropping to no
+                # edge at all (no project class is named `T`).
+                type_param_bounds = self._collect_type_param_bounds(func_cst, source)
+
+                edges_added = self._resolve_caller_body(
+                    body, source, module_name, enclosing_class_id, import_map,
+                    wildcard_packages, static_wildcard_classes, field_types_own,
+                    own_param_types, type_param_bounds, caller_node, caller_id,
+                    fp_str, edges_added,
+                )
+
+            edges_added = self._resolve_initializer_call_sites(
+                parse, source, module_name, fp_str, func_id_by_position,
+                import_map, wildcard_packages, static_wildcard_classes, edges_added,
+            )
+        return edges_added
+
+    def _resolve_caller_body(
+        self, body, source: bytes, module_name: str, enclosing_class_id,
+        import_map, wildcard_packages, static_wildcard_classes, field_types_own,
+        own_param_types, type_param_bounds, caller_node, caller_id: str,
+        fp_str: str, edges_added: int,
+    ) -> int:
+        """Shared per-caller resolution tail: scope inference over `body`
+        (a method/constructor's `block`, or — for a synthetic `<init>`/
+        `<clinit>` caller, see `_resolve_initializer_call_sites` — a bare
+        field-initializer expression or a `static`/instance-initializer
+        `block`) followed by method-reference and call-site resolution.
+        Factored out of `_resolve_project_call_sites` so both real methods
+        and synthetic initializer callers run through exactly one call
+        resolution path (PROBLEMS.md bug group 4)."""
+        local_types = self._collect_local_scopes(
+            body, source, field_types=field_types_own,
+            param_types=own_param_types,
+        )
+        self._collect_var_method_call_scopes(
+            body, source, module_name, enclosing_class_id, import_map,
+            wildcard_packages, local_types, own_param_types,
+            type_param_bounds,
+        )
+        self._collect_lambda_parameter_scopes(
+            body, source, module_name, enclosing_class_id, import_map,
+            wildcard_packages, local_types, own_param_types,
+            type_param_bounds, static_wildcard_classes,
+        )
+
+        # P4.13 target typing augments the existing receiver scopes:
+        # preserve the current branch's var/lambda inference, then add
+        # SAM-derived parameter scopes used by functional references.
+        self._add_lambda_param_scopes(
+            body, source, module_name, import_map, wildcard_packages,
+            local_types, own_param_types, field_types_own, caller_node,
+        )
+
+        resolved_refs, edges_added = self._resolve_method_reference_pass(
+            body, source, module_name, enclosing_class_id, import_map,
+            wildcard_packages, local_types, own_param_types, field_types_own,
+            caller_node, caller_id, fp_str, edges_added,
+        )
+
+        local_callable_targets = self._local_callable_targets(
+            body, source, resolved_refs,
+        )
+
+        return self._resolve_call_site_pass(
+            body, source, module_name, enclosing_class_id, import_map,
+            wildcard_packages, static_wildcard_classes, local_types,
+            own_param_types, type_param_bounds, local_callable_targets,
+            caller_node, caller_id, fp_str, edges_added,
+        )
+
+    # ------------------------------------------------------------ bug group 4:
+    # field initializers / static+instance initializer blocks
+
+    def _iter_initializer_sites(
+        self, root, file_path_str: str, source: bytes, extractor,
+    ):
+        """Yield `(owner_node, body_node, kind)` for every field initializer
+        expression, `static { }` block, and bare instance-initializer `{ }`
+        block anywhere in the file — the three CST shapes JLS 8.6/8.7 fold
+        into a class's implicit instance-initializer (`kind="init"`) or
+        class-initializer (`kind="clinit"`). `owner_node` is the enclosing
+        declaration (`field_declaration`/`static_initializer`/the block
+        itself) used to find the nearest enclosing class and to anchor
+        `_captured_param_types`; `body_node` is what actually gets walked
+        for call sites (a field's initializer *expression*, not the whole
+        `field_declaration`, so a multi-declarator `int a = f(), b = g();`
+        yields one entry per initializer).
+
+        Deliberately not gated by `_NESTED_SCOPE_BOUNDARY`: unlike
+        `_collect_call_sites` (which walks *within* an already-found
+        caller's body and must stop at a nested method/class), this is a
+        fresh top-level scan for these three node types anywhere in the
+        file, including inside local/anonymous classes — exactly how
+        `JavaSymbolExtractor._build`'s own top-level `_walk` finds nested
+        `field_declaration`s today.
+        """
+        for node in self._initializer_declarations(root, file_path_str):
+            if node.type == "field_declaration":
+                is_static = "static" in extractor._extract_modifiers(node, source)
+                kind = "clinit" if is_static else "init"
+                for child in node.children:
+                    if child.type != "variable_declarator":
+                        continue
+                    value = child.child_by_field_name("value")
+                    if value is not None:
+                        yield node, value, kind
+            elif node.type == "static_initializer":
+                block = next((c for c in node.children if c.type == "block"), None)
+                if block is not None:
+                    yield node, block, "clinit"
+            elif node.type == "block" and node.parent is not None \
+                    and node.parent.type in _INIT_BLOCK_PARENTS:
+                yield node, node, "init"
+
+    @staticmethod
+    def _nearest_enclosing_class_cst(node):
+        """Nearest enclosing class-like CST node (real declaration, or an
+        anonymous class's own `class_body`) — the node-object counterpart of
+        `JavaSymbolExtractor._find_parent_class`, which returns only the
+        *name*. Needed here to key into `class_id_by_position` (itself keyed
+        by the exact CST node `JavaSymbolExtractor` positioned the CLASS
+        Symbol on) rather than a second, driftable name-based lookup."""
+        p = node.parent
+        while p is not None:
+            if p.type in _ENCLOSING_TYPE_CST_TYPES:
+                return p
+            if p.type == "class_body" and p.parent is not None \
+                    and p.parent.type in ("object_creation_expression", "enum_constant"):
+                return p
+            p = p.parent
+        return None
+
+    def _ensure_initializer_member_stub(self, class_node, kind: str) -> str:
+        """Materialize the synthetic `<init>`/`<clinit>` FUNCTION `class_node`
+        needs, mirroring `GeneratedMembersMixin._add_generated_member_stub`'s
+        direct-`GraphNode` pattern (no CST node backs either, so there is no
+        `Symbol` to route through `JavaSymbolExtractor`). `<`/`>` are illegal
+        in a Java identifier, so `f"{class_node.id}.<init>"` can never collide
+        with a real member's id (a no-arg constructor's own id is
+        `f"{class_node.id}.()"`, never `.{name}"` for any declared name)."""
+        name = "<clinit>" if kind == "clinit" else "<init>"
+        member_id = f"{class_node.id}.{name}"
+        if member_id not in self.builder._nodes:
+            self.builder._add_node(GraphNode(
+                id=member_id,
+                name=name,
+                node_type=NodeType.FUNCTION,
+                module=class_node.module,
+                file_path=class_node.file_path,
+                line=class_node.line,
+                column=class_node.column,
+                contained_in=class_node.name,
+                language="java",
+                metadata={
+                    "java_is_static": kind == "clinit",
+                    "java_is_abstract": False,
+                    "synthetic": "class_initializer" if kind == "clinit" else "instance_initializer",
+                },
+            ))
+            self.builder._add_edge(GraphEdge(
+                source=class_node.id,
+                target=member_id,
+                edge_type=EdgeType.CONTAINS,
+                file_path=class_node.file_path,
+                line=class_node.line,
+                column=class_node.column,
+                strategy="java_resolver",
+            ))
+        return member_id
+
+    def _synthesize_initializer_members(
+        self, parses: Dict[Path, ParseResult],
+        class_id_by_position: Dict[Tuple[str, int, int], str],
+    ) -> None:
+        extractor = self._method_extractor()
+        for file_path, parse in parses.items():
+            source = parse.source_bytes
+            fp_str = str(file_path)
+            for owner_node, _body, kind in self._iter_initializer_sites(
+                parse.tree.root_node, fp_str, source, extractor,
+            ):
+                class_cst = self._nearest_enclosing_class_cst(owner_node)
+                if class_cst is None:
+                    continue
+                class_id = class_id_by_position.get(
+                    (fp_str, class_cst.start_point[0] + 1, class_cst.start_point[1]),
+                )
+                if class_id is None or class_id not in self.builder._nodes:
+                    continue
+                self._ensure_initializer_member_stub(
+                    self.builder._nodes[class_id], kind,
+                )
+
+    def _resolve_initializer_call_sites(
+        self, parse: ParseResult, source: bytes, module_name: str, fp_str: str,
+        func_id_by_position: Dict[Tuple[str, int, int], str],
+        import_map, wildcard_packages, static_wildcard_classes,
+        edges_added: int,
+    ) -> int:
+        """Route call sites found inside field initializers / static+instance
+        initializer blocks to the synthetic `<init>`/`<clinit>` FUNCTION
+        `_synthesize_initializer_members` already created for their class —
+        the fix for PROBLEMS.md bug group 4 (these call sites previously had
+        no caller CST node `_iter_method_cst` could ever yield, so the edge
+        was silently dropped)."""
+        extractor = self._method_extractor()
+        for owner_node, body, kind in self._iter_initializer_sites(
+            parse.tree.root_node, fp_str, source, extractor,
+        ):
+            class_cst = self._nearest_enclosing_class_cst(owner_node)
+            if class_cst is None:
+                continue
+            class_id = self._class_id_by_position.get(
+                (fp_str, class_cst.start_point[0] + 1, class_cst.start_point[1]),
+            )
+            if class_id is None:
+                continue
+            name = "<clinit>" if kind == "clinit" else "<init>"
+            caller_id = f"{class_id}.{name}"
+            if caller_id not in self.builder._nodes:
+                continue
+            caller_node = self.builder._nodes[caller_id]
+            field_types_own = self._visible_bare_field_types(class_id)
+            # Neither a field initializer nor a static/instance-initializer
+            # block declares parameters of its own; an anonymous/local
+            # class's initializer may still read an effectively-final local
+            # of its lexically enclosing method, same as a real method there
+            # would (`_captured_param_types` walks up from `owner_node`
+            # exactly as it would from that method's own CST node).
+            own_param_types = self._captured_param_types(
+                owner_node, source, fp_str, func_id_by_position,
+            )
+            edges_added = self._resolve_caller_body(
+                body, source, module_name, class_id, import_map,
+                wildcard_packages, static_wildcard_classes, field_types_own,
+                own_param_types, {}, caller_node, caller_id, fp_str, edges_added,
+            )
+        return edges_added
+
+    def _captured_param_types(
+        self, func_cst, source: bytes, file_path: str,
+        func_id_by_position: Dict[Tuple[str, int, int], str],
+    ) -> Dict[str, str]:
+        """Declared parameters captured from the nearest lexical method.
+
+        Java permits an anonymous or local class to use effectively-final
+        parameters from the method that contains its declaration.  A member
+        class has no enclosing method in its CST ancestry, so this contributes
+        no facts there.  The current method's parameters are overlaid by the
+        caller and therefore correctly shadow captured names.
+        """
+        parent = func_cst.parent
+        while parent is not None:
+            if parent.type in (
+                "method_declaration", "constructor_declaration",
+                "compact_constructor_declaration",
+            ):
+                outer_id = func_id_by_position.get(
+                    (file_path, parent.start_point[0] + 1, parent.start_point[1]),
+                )
+                if outer_id is None:
+                    return {}
+                return dict(zip(
+                    self._param_names(parent, source),
+                    self._param_type_lists.get(outer_id, []),
+                ))
+            parent = parent.parent
+        return {}
+
+    def _resolve_method_reference_pass(
+        self, body, source: bytes, module_name: str, enclosing_class_id,
+        import_map, wildcard_packages, local_types, own_param_types,
+        field_types_own, caller_node, caller_id: str, fp_str: str, edges_added: int,
+    ):
+        resolved_refs: Dict[int, Set[str]] = {}
+        for ref_node in self._collect_method_references(body):
+            target_id, confidence, ref_etype, ref_meta = self._resolve_method_reference(
+                ref_node, source, module_name, enclosing_class_id,
+                import_map, wildcard_packages, local_types,
+                own_param_types, field_types_own, caller_node,
+            )
+            if not target_id:
+                caller_node.metadata.setdefault(
+                    "unresolved_method_references", []
+                ).append({
+                    "text": self._text(ref_node, source),
+                    "line": ref_node.start_point[0] + 1,
+                    "column": ref_node.start_point[1],
+                })
+                continue
+            targets = target_id if isinstance(target_id, list) else [target_id]
+            resolved_refs[ref_node.start_byte] = set(targets)
+            for tid in targets:
+                # A recursive reference (`this::walk` inside `walk`,
+                # `Node::contains` inside `contains`) still gets its
+                # CALLABLE_REF/REFERENCES edge, exactly as a recursive bare
+                # call already does.
+                if tid not in self.builder._nodes:
+                    continue
+                edge = GraphEdge(
+                    source=caller_id, target=tid, edge_type=ref_etype,
+                    file_path=fp_str, line=ref_node.start_point[0] + 1,
+                    column=ref_node.start_point[1],
+                    start_byte=ref_node.start_byte, end_byte=ref_node.end_byte,
+                    confidence=float(confidence), metadata=dict(ref_meta),
+                    strategy="java_resolver",
+                )
+                self.builder._record_edge_occurrence(edge)
+                if (caller_id, tid, ref_etype) in self.builder._edge_keys:
+                    continue
+                self.builder._add_edge(edge)
+                # Backward-compatible semantic view: pre-P4.13
+                # consumers query method references as REFERENCES,
+                # while the richer CALLABLE_REF edge carries SAM
+                # target-typing metadata for newer consumers.
+                if ref_etype == EdgeType.CALLABLE_REF:
+                    compat_edge = GraphEdge(
+                        source=caller_id, target=tid,
+                        edge_type=EdgeType.REFERENCES,
+                        file_path=fp_str,
+                        line=ref_node.start_point[0] + 1,
+                        column=ref_node.start_point[1],
+                        start_byte=ref_node.start_byte,
+                        end_byte=ref_node.end_byte,
+                        confidence=float(confidence),
+                        metadata=dict(ref_meta),
+                        strategy="java_resolver",
+                    )
+                    self.builder._record_edge_occurrence(compat_edge)
+                    compat_key = (caller_id, tid, EdgeType.REFERENCES)
+                    if compat_key not in self.builder._edge_keys:
+                        self.builder._add_edge(compat_edge)
+                # `.calls`/`.called_by` model actual invocation (mirrored by
+                # memory.py's persistence reload, which only repopulates
+                # them from EdgeType.CALLS rows). A method reference
+                # (`Type::method`) never invokes anything by itself, so it
+                # must not inflate caller/callee bookkeeping here — the
+                # CALLABLE_REF/REFERENCES edges above already make it
+                # visible to blast-radius/impact analysis via
+                # IMPACT_EDGE_TYPES.
+                edges_added += 1
+
+        return resolved_refs, edges_added
+
+
+    def _resolve_call_site_pass(
+        self, body, source: bytes, module_name: str, enclosing_class_id,
+        import_map, wildcard_packages, static_wildcard_classes, local_types,
+        own_param_types, type_param_bounds, local_callable_targets, caller_node,
+        caller_id: str, fp_str: str, edges_added: int,
+    ) -> int:
+        for call_node, call_kind in self._collect_call_sites(body):
+            if call_kind != "method":
+                resolver = (
+                    self._resolve_explicit_constructor
+                    if call_kind == "explicit_constructor"
+                    else self._resolve_constructor
+                )
+                target_id, confidence, constructor_signature = resolver(
+                    call_node, source, module_name, import_map, wildcard_packages,
+                    local_types, own_param_types, enclosing_class_id,
+                )
+                etype = EdgeType.INSTANTIATES
+                edge_meta: Dict[str, object] = {
+                    "constructor_signature": constructor_signature,
+                }
+            else:
+                indirect = self._resolve_callable_container_dispatch(
+                    call_node, source, enclosing_class_id,
+                    local_callable_targets, local_types, own_param_types,
+                )
+                if indirect:
+                    target_id, confidence, edge_meta = indirect
+                else:
+                    target_id, confidence, edge_meta = self._resolve_call(
+                        call_node, source, module_name, enclosing_class_id,
+                        import_map, wildcard_packages, local_types, own_param_types,
+                        static_wildcard_classes, type_param_bounds,
+                    )
+                etype = EdgeType.CALLS
+            if not target_id:
+                continue
+            targets = target_id if isinstance(target_id, list) else [target_id]
+            target_overrides = edge_meta.get("_target_overrides", {})
+            shared_edge_meta = {
+                key: value for key, value in edge_meta.items()
+                if key != "_target_overrides"
+            }
+            for tid in targets:
+                if tid not in self.builder._nodes:
+                    continue
+                override = (
+                    target_overrides.get(tid, {})
+                    if isinstance(target_overrides, dict) else {}
+                )
+                target_confidence = override.get("confidence", confidence)
+                target_metadata = override.get("metadata", shared_edge_meta)
+                edge = GraphEdge(
+                    source=caller_id,
+                    target=tid,
+                    edge_type=etype,
+                    file_path=fp_str,
+                    line=call_node.start_point[0] + 1,
+                    column=call_node.start_point[1],
+                    start_byte=call_node.start_byte,
+                    end_byte=call_node.end_byte,
+                    confidence=float(target_confidence),
+                    metadata=dict(target_metadata) if target_metadata else {},
+                    strategy="java_resolver",
+                )
+                self.builder._record_edge_occurrence(edge)
+                key = (caller_id, tid, etype)
+                if key in self.builder._edge_keys:
+                    continue
+                self.builder._add_edge(edge)
+                caller_node.calls.add(tid)
+                self.builder._nodes[tid].called_by.add(caller_id)
+                edges_added += 1
+        return edges_added