adl-toolkit 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,1619 @@
+"""Policy tables and exact external facts used by Java call resolution."""
+
+from __future__ import annotations
+
+import re
+from typing import Dict, FrozenSet, List, Set, Tuple, Union
+
+from adl_drift.lang.java.scopes import TYPE_BODIES
+
+# P2.7-equivalent deny-list for Java: `java.lang.Object` methods (present on
+# every instance whether declared or not) + common Collection/Map/Iterator
+# method names. Unlike Python's `PYTHON_BUILTINS` (which also guards a
+# whole-project unique-simple-name fallback that Java's call resolver has no
+# equivalent of), `JavaCallResolver` no longer consults this set at all for
+# call resolution — own-class and ancestor lookup are both fully structural
+# (real CONTAINS/INHERITS/IMPLEMENTS edges, never a guess), so gating either
+# of them here only cost recall for zero precision benefit (P4.4 regression
+# fix; `_resolve_own_or_ancestor` used to early-return unresolved whenever
+# the receiver's own class didn't declare a denied name itself, even when an
+# ancestor genuinely did). `JAVA_BUILTINS` still backs
+# `ResolverConfig.builtins_deny_list`, consumed by
+# `CallGraphBuilder._is_denied()` for the language-agnostic `god_nodes()`
+# metric — that usage is unrelated to call resolution and unaffected here.
+JAVA_OBJECT_METHODS: Set[str] = {
+    "equals", "hashCode", "toString", "getClass", "clone", "finalize",
+    "notify", "notifyAll", "wait",
+}
+JAVA_COMMON_COLLECTION_METHODS: Set[str] = {
+    "get", "set", "add", "remove", "size", "isEmpty", "contains", "clear",
+    "put", "putAll", "containsKey", "containsValue", "keySet", "values",
+    "entrySet", "iterator", "next", "hasNext", "forEach", "stream",
+    "toArray", "addAll", "removeAll", "retainAll", "indexOf", "sort",
+    "getOrDefault", "compute", "computeIfAbsent", "computeIfPresent",
+    "merge", "of", "asList", "peek", "poll", "push", "pop", "offer",
+}
+JAVA_BUILTINS: Set[str] = JAVA_OBJECT_METHODS | JAVA_COMMON_COLLECTION_METHODS
+
+# Lombok-style annotation simple name -> name *prefixes* it generates on the
+# annotated class. Illustrative, not exhaustive — the Java analogue of
+# DECORATOR_STUB_TABLE, scoped to "simple proxies" per this issue; Spring
+# AOP/DI dispatch is P4.12, not here.
+JAVA_ANNOTATION_STUB_TABLE: Dict[str, FrozenSet[str]] = {
+    "Getter": frozenset({"get", "is"}),
+    "Setter": frozenset({"set"}),
+    "Data": frozenset({"get", "is", "set", "toString", "hashCode", "equals", "canEqual"}),
+    "Value": frozenset({"get", "is", "toString", "hashCode", "equals", "canEqual"}),
+    "Builder": frozenset({"build", "builder", "toBuilder"}),
+    "EqualsAndHashCode": frozenset({"equals", "hashCode", "canEqual"}),
+    "ToString": frozenset({"toString"}),
+}
+
+# argument_list / formal_parameters punctuation children to skip when
+# counting/walking positional entries.
+_PUNCTUATION = (",", "(", ")")
+
+# Tree-sitter keeps comments as *named* children of `argument_list`
+# (`line_comment` / `block_comment`), so `call(a, // note\n b)` has three
+# named children but two arguments. Punctuation is unnamed; comments are
+# named trivia. Every positional walk over an argument list must go through
+# here so arity and per-argument typing never disagree.
+_COMMENT_CST_TYPES = frozenset({"line_comment", "block_comment", "comment"})
+
+
+def argument_nodes(args_node) -> list:
+    """Positional argument expressions of an `argument_list` node, in order,
+    skipping punctuation and comment trivia. `None` -> `[]`."""
+    if args_node is None:
+        return []
+    return [
+        child for child in args_node.children
+        if child.is_named and child.type not in _COMMENT_CST_TYPES
+    ]
+
+_LITERAL_ARG_TYPE = {
+    "character_literal": "char",
+    "string_literal": "String",
+    "true": "boolean",
+    "false": "boolean",
+}
+
+# Sentinel "type" for the `null` literal. `null` is a Java keyword, so no real
+# type is ever named `null` and this cannot collide with a declared type. It
+# carries the JLS "null type": assignable to every *reference* type (class,
+# interface, array, boxed primitive), never to a primitive. Treated as a
+# *known* argument type by overload selection (not "unknown"), so `save(null)`
+# runs through most-specific ranking among reference candidates instead of
+# fanning out across every arity match — see `_types_compatible`.
+_NULL_ARG_TYPE = "null"
+# Must survive `erased_type()` unchanged. Angle-bracket sentinels are invalid
+# here because erasure correctly treats them as a generic argument list and
+# reduces the value to an empty type.
+_LAMBDA_ARG_TYPE = "$drift_lambda$"
+# Placeholder for one argument position whose type genuinely cannot be
+# determined (an external/JDK method-call result with no exact-return fact,
+# for example). Unlike `_NULL_ARG_TYPE`/`_LAMBDA_ARG_TYPE` — both real,
+# *known* facts about the argument — this means "no information," so
+# `_types_compatible` treats it as compatible with every parameter shape
+# rather than ruling anything in or out. It lets a mixed argument list (some
+# positions known, one unresolvable) still exclude a candidate that is
+# provably incompatible on a position that *is* known, without ever
+# guessing the unresolvable one. See `_narrow_candidates_by_known_arg_types`.
+_UNKNOWN_ARG_TYPE = "$drift_unknown$"
+# Marks a local variable initialized from a Mockito `mock(...)`/`spy(...)`
+# factory call (see `ScopeInferenceMixin._is_mockito_factory_call`). Stored
+# through the same allocation-tracking path as a real `new Impl()` so
+# `_abstract_fan_out`'s allocation-narrowing step can recognize it and
+# decline to fan out at all — a mock has no real declared implementation to
+# dispatch to, so guessing any concrete implementor (unrelated project code
+# that happens to declare the same interface method) is a wrong edge every
+# stubbed call site, not an unresolved one.
+_MOCK_ALLOCATION_TYPE = "$drift_mock$"
+_JAVA_FUNCTIONAL_INTERFACES: FrozenSet[str] = frozenset({
+    "BooleanSupplier", "Callable", "Comparator", "Consumer", "BiConsumer", "Function",
+    "BiFunction", "Predicate", "BiPredicate", "Supplier", "Runnable",
+    "UnaryOperator", "BinaryOperator",
+})
+# (abstract-method arity, is-void-returning) for each JDK functional
+# interface above. Used only to narrow a lambda-expression argument's
+# candidate overloads by two syntactic, JLS-exact facts about the lambda
+# itself — its own declared parameter count, and (for a block body) whether
+# it contains a `return <expr>;` — against a *sibling* candidate's SAM shape
+# (E1, JAVA_METRICS_SPRING_MODULITH_PRECISION_SAMPLE.md:
+# `Scenario.stimulate(Runnable/Supplier/Function/BiConsumer/BiFunction)` all
+# accepted any lambda regardless of its own arity/return shape). Excludes
+# `Comparator`/`BiPredicate` from the shape table entries that would collide
+# with `Function`/`BiFunction`'s arity on purpose: `Comparator` and
+# `BiFunction` are both arity-2/non-void, so they are never distinguishable
+# by shape alone anyway; leaving both in the table changes nothing since
+# neither ever gets excluded from the other.
+_JAVA_FUNCTIONAL_INTERFACE_SHAPE: Dict[str, Tuple[int, bool]] = {
+    "BooleanSupplier": (0, False),
+    "Callable": (0, False),
+    "Comparator": (2, False),
+    "Consumer": (1, True),
+    "BiConsumer": (2, True),
+    "Function": (1, False),
+    "BiFunction": (2, False),
+    "Predicate": (1, False),
+    "BiPredicate": (2, False),
+    "Supplier": (0, False),
+    "Runnable": (0, True),
+    "UnaryOperator": (1, False),
+    "BinaryOperator": (2, False),
+}
+
+# Integer/floating-point literal node types whose Java type depends on a
+# suffix character in the literal *text*, not just the node type (a
+# `decimal_integer_literal` is `int` by default but `long` when it ends in
+# `l`/`L`; a `decimal_floating_point_literal` is `double` by default but
+# `float` when it ends in `f`/`F` — JLS 3.10.1/3.10.2). Same rule applies to
+# hex/octal/binary integer literals.
+_INTEGER_LITERAL_TYPES = frozenset({
+    "decimal_integer_literal", "hex_integer_literal",
+    "octal_integer_literal", "binary_integer_literal",
+})
+_FLOATING_POINT_LITERAL_TYPES = frozenset({
+    "decimal_floating_point_literal", "hex_floating_point_literal",
+})
+
+# The CST node types that carry a caller body `resolve_calls` must walk:
+# regular methods, ordinary constructors, and a `record`'s *compact*
+# canonical constructor (`R { ... }`) — the last has a real body whose call
+# sites would otherwise be dropped (it is a distinct node type from
+# `constructor_declaration`). Shared by `_iter_method_cst` (what to yield as
+# a caller) and `_NESTED_SCOPE_BOUNDARY` (where a body walk must stop
+# descending) so the two never drift; `JavaSymbolExtractor._CONSTRUCTOR_TYPES`
+# is the extractor-side counterpart that emits the matching FUNCTION nodes.
+_METHOD_CST_TYPES = (
+    "method_declaration", "constructor_declaration", "compact_constructor_declaration",
+)
+
+# Node types whose call sites belong to a *different* enclosing method than
+# whatever body we're currently walking — mirrors Python's "don't descend
+# into nested function_definition" guard in `_collect_calls`. Java can't
+# nest a method inside a method, but a method body can contain a local or
+# anonymous class with its own `method_declaration`(s); those get their own
+# top-level pass in `_iter_method_cst`; a type-body boundary marks where
+# nested-class call sites start belonging to that class's own methods. Uses
+# `scopes.TYPE_BODIES`, not just `class_body` — tree-sitter-java pairs
+# `interface_declaration`/`enum_declaration`/`annotation_type_declaration`
+# with their own `interface_body`/`enum_body`/`annotation_type_body`, so a
+# `class_body`-only check walks straight through a local enum's `static {
+# }` initializer or an interface constant's field initializer and
+# misattributes its call sites to the enclosing method (PROBLEMS.md P4.6;
+# same bug fixed in `lang/java/taint.py::_NESTED_SCOPE_BOUNDARY`, confirmed
+# live via a spurious `CALLS` edge before this fix).
+_NESTED_SCOPE_BOUNDARY = (*_METHOD_CST_TYPES, *TYPE_BODIES)
+
+# Direct-parent node types of a bare instance-initializer `{ }` block (JLS
+# 8.6) — i.e. every `TYPE_BODIES` container *except* that an enum's constant
+# list wraps its trailing member section (fields, initializer blocks,
+# methods) in an extra `enum_body_declarations` node tree-sitter-java uses
+# nowhere else, so `block.parent.type` there is `enum_body_declarations`,
+# not `enum_body` itself. Used by `_iter_initializer_sites` (below) to tell
+# a real instance-initializer block apart from an ordinary nested `{ }`
+# inside a method/constructor body (whose parent is never one of these
+# types) without walking further up.
+_INIT_BLOCK_PARENTS = TYPE_BODIES | {"enum_body_declarations"}
+
+# JDK functional interfaces whose SAM parameter types are derivable without
+# indexing JDK sources. Integers reference the interface's generic arguments;
+# strings are concrete primitive types. Custom interfaces use graph metadata
+# and the same generic-substitution path as normal Java calls.
+_JDK_SAM_PARAMS: Dict[str, Tuple[Union[int, str], ...]] = {
+    "Runnable": (), "Callable": (), "Supplier": (), "BooleanSupplier": (),
+    "IntSupplier": (), "LongSupplier": (), "DoubleSupplier": (),
+    "Consumer": (0,), "Function": (0,), "Predicate": (0,), "UnaryOperator": (0,),
+    "BiConsumer": (0, 1), "BiFunction": (0, 1), "BiPredicate": (0, 1),
+    "BinaryOperator": (0, 0), "Comparator": (0, 0),
+    "IntConsumer": ("int",), "LongConsumer": ("long",),
+    "DoubleConsumer": ("double",), "IntFunction": ("int",),
+    "LongFunction": ("long",), "DoubleFunction": ("double",),
+    "IntPredicate": ("int",), "LongPredicate": ("long",),
+    "DoublePredicate": ("double",), "IntUnaryOperator": ("int",),
+    "LongUnaryOperator": ("long",), "DoubleUnaryOperator": ("double",),
+    "IntBinaryOperator": ("int", "int"),
+    "LongBinaryOperator": ("long", "long"),
+    "DoubleBinaryOperator": ("double", "double"),
+    "ToIntFunction": (0,), "ToLongFunction": (0,), "ToDoubleFunction": (0,),
+    "ToIntBiFunction": (0, 1), "ToLongBiFunction": (0, 1),
+    "ToDoubleBiFunction": (0, 1), "ObjIntConsumer": (0, "int"),
+    "ObjLongConsumer": (0, "long"), "ObjDoubleConsumer": (0, "double"),
+    "IntToLongFunction": ("int",), "IntToDoubleFunction": ("int",),
+    "LongToIntFunction": ("long",), "LongToDoubleFunction": ("long",),
+    "DoubleToIntFunction": ("double",), "DoubleToLongFunction": ("double",),
+}
+
+_JDK_SAM_RETURNS: Dict[str, Union[int, str]] = {
+    "Runnable": "void", "Callable": 0, "Supplier": 0,
+    "BooleanSupplier": "boolean", "IntSupplier": "int",
+    "LongSupplier": "long", "DoubleSupplier": "double",
+    "Consumer": "void", "BiConsumer": "void", "Function": 1,
+    "BiFunction": 2, "Predicate": "boolean", "BiPredicate": "boolean",
+    "UnaryOperator": 0, "BinaryOperator": 0, "Comparator": "int",
+    "IntConsumer": "void", "LongConsumer": "void", "DoubleConsumer": "void",
+    "IntFunction": 0, "LongFunction": 0, "DoubleFunction": 0,
+    "IntPredicate": "boolean", "LongPredicate": "boolean", "DoublePredicate": "boolean",
+    "IntUnaryOperator": "int", "LongUnaryOperator": "long", "DoubleUnaryOperator": "double",
+    "IntBinaryOperator": "int", "LongBinaryOperator": "long", "DoubleBinaryOperator": "double",
+    "ToIntFunction": "int", "ToLongFunction": "long", "ToDoubleFunction": "double",
+    "ToIntBiFunction": "int", "ToLongBiFunction": "long", "ToDoubleBiFunction": "double",
+    "ObjIntConsumer": "void", "ObjLongConsumer": "void", "ObjDoubleConsumer": "void",
+    "IntToLongFunction": "long", "IntToDoubleFunction": "double",
+    "LongToIntFunction": "int", "LongToDoubleFunction": "double",
+    "DoubleToIntFunction": "int", "DoubleToLongFunction": "long",
+}
+
+
+# Type-declaration CST node kinds that can enclose a nested `@interface`
+# (F-01 fix). Mirrors `JavaSymbolExtractor._CLASS_TYPES` plus
+# `annotation_type_declaration` itself (an annotation type may nest inside
+# another one), kept as a local copy rather than importing the extractor's
+# constant — `_collect_annotation_type_names` walks raw CST nodes the
+# extractor never turns into `Symbol`s, so the two have no shared id/scope
+# logic to drift apart, only this grammar-level type list.
+_ENCLOSING_TYPE_CST_TYPES = (
+    "class_declaration",
+    "interface_declaration",
+    "enum_declaration",
+    "record_declaration",
+    "annotation_type_declaration",
+)
+
+# ---------------------------------------------------------------- P4.12 fan-out
+# Annotation simple names (see codegraph-java-deep-dive.md §7.3) that mark a
+# field for dependency injection — a receiver typed as an interface but read
+# off such a field has its concrete bean chosen by the Spring container, so DI
+# narrowing (below) can resolve it precisely where a bare interface receiver
+# only fans out.
+JAVA_INJECTION_ANNOTATIONS: FrozenSet[str] = frozenset({
+    "Autowired", "Inject", "Resource",
+})
+# Annotation simple names that register a class as a Spring bean (a concrete
+# injectable candidate for any interface it implements).
+JAVA_COMPONENT_ANNOTATIONS: FrozenSet[str] = frozenset({
+    "Component", "Service", "Repository", "Controller", "RestController",
+})
+JAVA_DI_ANNOTATION_FQNS: FrozenSet[str] = frozenset({
+    "org.springframework.beans.factory.annotation.Autowired",
+    "org.springframework.beans.factory.annotation.Qualifier",
+    "org.springframework.context.annotation.Bean",
+    "org.springframework.context.annotation.Primary",
+    "org.springframework.stereotype.Component",
+    "org.springframework.stereotype.Controller",
+    "org.springframework.stereotype.Repository",
+    "org.springframework.stereotype.Service",
+    "org.springframework.web.bind.annotation.RestController",
+    "jakarta.inject.Inject",
+    "jakarta.inject.Qualifier",
+    "jakarta.annotation.Resource",
+    "javax.inject.Inject",
+    "javax.inject.Qualifier",
+    "javax.annotation.Resource",
+})
+
+# Generic method signatures for JDK/container types whose source declaration is
+# outside the analyzed project. Values are declared return types in terms of the
+# receiver's class type parameters; source classes use the same substitution
+# path via `_generic_return_type_from_source_method`.
+JAVA_GENERIC_METHOD_STUB_RETURNS: Dict[Tuple[str, str], str] = {
+    # `java.lang.String` instance members whose declared return is the same
+    # across *every* overload (JDK 17+ javadoc). Only such fixed-return
+    # members belong here: a member with overload-dependent returns would
+    # turn a narrowing hint into a guess. Needed so a `String`-typed chain
+    # used as a call argument (`"...".formatted(a, b)`, `name.toUpperCase()`,
+    # `text.substring(1)`) can exclude a same-arity `Supplier<String>`/
+    # primitive sibling overload instead of fanning out at 0.55 (JUnit5
+    # FP/FN catalog #16476 and the wider `overload/java_resolver@0.55`
+    # stratum).
+    ("String", "trim"): "String",
+    ("String", "strip"): "String",
+    ("String", "stripLeading"): "String",
+    ("String", "stripTrailing"): "String",
+    ("String", "stripIndent"): "String",
+    ("String", "formatted"): "String",
+    ("String", "toUpperCase"): "String",
+    ("String", "toLowerCase"): "String",
+    ("String", "substring"): "String",
+    ("String", "replace"): "String",
+    ("String", "replaceAll"): "String",
+    ("String", "replaceFirst"): "String",
+    ("String", "concat"): "String",
+    ("String", "repeat"): "String",
+    ("String", "intern"): "String",
+    ("String", "indent"): "String",
+    ("String", "translateEscapes"): "String",
+    ("String", "length"): "int",
+    ("String", "indexOf"): "int",
+    ("String", "lastIndexOf"): "int",
+    ("String", "compareTo"): "int",
+    ("String", "compareToIgnoreCase"): "int",
+    ("String", "codePointAt"): "int",
+    ("String", "charAt"): "char",
+    ("String", "isEmpty"): "boolean",
+    ("String", "isBlank"): "boolean",
+    ("String", "contains"): "boolean",
+    ("String", "startsWith"): "boolean",
+    ("String", "endsWith"): "boolean",
+    ("String", "equals"): "boolean",
+    ("String", "equalsIgnoreCase"): "boolean",
+    ("String", "contentEquals"): "boolean",
+    ("String", "matches"): "boolean",
+    ("String", "regionMatches"): "boolean",
+    ("String", "toCharArray"): "char[]",
+    ("String", "getBytes"): "byte[]",
+    ("String", "split"): "String[]",
+    ("String", "lines"): "Stream<String>",
+    ("String", "chars"): "IntStream",
+    ("Class", "getClassLoader"): "ClassLoader",
+    ("Class", "getName"): "String",
+    ("Class", "getSimpleName"): "String",
+    ("Class", "getPackage"): "java.lang.Package",
+    ("Class", "getDeclaredMethod"): "java.lang.reflect.Method",
+    ("Package", "getName"): "String",
+    ("Method", "getName"): "String",
+    ("Method", "getParameterTypes"): "Class[]",
+    ("Iterable", "iterator"): "Iterator<T>",
+    ("Collection", "iterator"): "Iterator<E>",
+    ("List", "iterator"): "Iterator<E>",
+    ("ArrayList", "iterator"): "Iterator<E>",
+    ("LinkedList", "iterator"): "Iterator<E>",
+    ("Collection", "stream"): "Stream<E>",
+    ("List", "stream"): "Stream<E>",
+    ("ArrayList", "stream"): "Stream<E>",
+    ("LinkedList", "stream"): "Stream<E>",
+    ("Set", "stream"): "Stream<E>",
+    ("SortedSet", "stream"): "Stream<E>",
+    ("Collection", "parallelStream"): "Stream<E>",
+    ("List", "parallelStream"): "Stream<E>",
+    ("Set", "parallelStream"): "Stream<E>",
+    ("Iterator", "next"): "T",
+    ("ListIterator", "next"): "E",
+    ("List", "get"): "E",
+    # Java 21 SequencedCollection API.  A declared List receiver retains its
+    # element type through `getFirst()` just as it does through indexed get.
+    ("List", "getFirst"): "E",
+    ("ArrayList", "get"): "E",
+    ("ArrayList", "getFirst"): "E",
+    ("LinkedList", "get"): "E",
+    ("LinkedList", "getFirst"): "E",
+    ("Optional", "get"): "T",
+    ("Optional", "orElseThrow"): "T",
+    ("Map", "get"): "V",
+    ("Map", "getOrDefault"): "V",
+    ("Map", "values"): "Collection<V>",
+    ("Map", "keySet"): "Set<K>",
+    ("Map", "entrySet"): "Set<Map.Entry<K,V>>",
+    ("Entry", "getKey"): "K",
+    ("Entry", "getValue"): "V",
+    ("HashMap", "get"): "V",
+    ("HashMap", "values"): "Collection<V>",
+    ("HashMap", "keySet"): "Set<K>",
+    ("HashMap", "entrySet"): "Set<Map.Entry<K,V>>",
+    ("LinkedHashMap", "get"): "V",
+    ("LinkedHashMap", "values"): "Collection<V>",
+    ("LinkedHashMap", "keySet"): "Set<K>",
+    ("LinkedHashMap", "entrySet"): "Set<Map.Entry<K,V>>",
+    ("TreeMap", "get"): "V",
+    ("TreeMap", "values"): "Collection<V>",
+    ("TreeMap", "keySet"): "Set<K>",
+    ("TreeMap", "entrySet"): "Set<Map.Entry<K,V>>",
+    ("Stream", "filter"): "Stream<T>",
+    ("Stream", "peek"): "Stream<T>",
+    ("Stream", "distinct"): "Stream<T>",
+    ("Stream", "sorted"): "Stream<T>",
+    ("Stream", "toList"): "List<T>",
+    ("Stream", "findFirst"): "Optional<T>",
+    ("Optional", "filter"): "Optional<T>",
+    # Primitive stream specializations (`IntStream`/`LongStream`/
+    # `DoubleStream`) are not generic (JLS: no type parameter to
+    # substitute), so each fixed contract return is written as a plain,
+    # non-generic string here, the same way the `Collection.contains() ->
+    # boolean` facts above are. `map`/`filter`/`sorted`/`distinct` return
+    # the same specialized stream type (not a boxed `Stream<T>`); the
+    # reduction terminal ops (`sum`/`count`/`average`/`max`/`min`) have one
+    # fixed primitive/`OptionalX` result regardless of the pipeline's own
+    # element-producing lambda, so a *known* argument this narrows can
+    # never be defeated by an unrelated unresolvable sibling (P5 finding
+    # #1's `IntStream.range(...).map(...).sum()` shape).
+    ("IntStream", "map"): "IntStream",
+    ("IntStream", "filter"): "IntStream",
+    ("IntStream", "sorted"): "IntStream",
+    ("IntStream", "distinct"): "IntStream",
+    ("IntStream", "boxed"): "Stream<Integer>",
+    ("IntStream", "toArray"): "int[]",
+    ("IntStream", "sum"): "int",
+    ("IntStream", "count"): "long",
+    ("IntStream", "average"): "OptionalDouble",
+    ("IntStream", "max"): "OptionalInt",
+    ("IntStream", "min"): "OptionalInt",
+    ("LongStream", "map"): "LongStream",
+    ("LongStream", "filter"): "LongStream",
+    ("LongStream", "sorted"): "LongStream",
+    ("LongStream", "distinct"): "LongStream",
+    ("LongStream", "boxed"): "Stream<Long>",
+    ("LongStream", "toArray"): "long[]",
+    ("LongStream", "sum"): "long",
+    ("LongStream", "count"): "long",
+    ("LongStream", "average"): "OptionalDouble",
+    ("LongStream", "max"): "OptionalLong",
+    ("LongStream", "min"): "OptionalLong",
+    ("DoubleStream", "map"): "DoubleStream",
+    ("DoubleStream", "filter"): "DoubleStream",
+    ("DoubleStream", "sorted"): "DoubleStream",
+    ("DoubleStream", "distinct"): "DoubleStream",
+    ("DoubleStream", "boxed"): "Stream<Double>",
+    ("DoubleStream", "toArray"): "double[]",
+    ("DoubleStream", "sum"): "double",
+    ("DoubleStream", "count"): "long",
+    ("DoubleStream", "average"): "OptionalDouble",
+    ("DoubleStream", "max"): "OptionalDouble",
+    ("DoubleStream", "min"): "OptionalDouble",
+    # `Stream<T>.mapToInt/mapToLong/mapToDouble` bridge to the matching
+    # primitive stream; the bridging lambda's own element type does not
+    # change this fixed contract return.
+    ("Stream", "mapToInt"): "IntStream",
+    ("Stream", "mapToLong"): "LongStream",
+    ("Stream", "mapToDouble"): "DoubleStream",
+    # Function/Supplier results are needed when a fluent call is assigned to
+    # `var` and used as the receiver of a later source call.
+    ("Function", "apply"): "R",
+    ("Supplier", "get"): "T",
+    # Invoking the single abstract method of a typed JDK functional value
+    # yields its declared result variable (`BiFunction<A,B,R>.apply -> R`).
+    ("BiFunction", "apply"): "R",
+    ("UnaryOperator", "apply"): "T",
+    ("BinaryOperator", "apply"): "T",
+    ("Callable", "call"): "V",
+    # Exact `java.lang.reflect` facts, spelled fully qualified so the
+    # element type is import-independent at the call site.  They are
+    # consulted only for a receiver whose declared type is not a source
+    # class, so a project type named `Method` or `Class` is never stubbed.
+    ("Class", "getDeclaredMethods"): "java.lang.reflect.Method[]",
+    ("Class", "getMethods"): "java.lang.reflect.Method[]",
+    ("Class", "getDeclaredFields"): "java.lang.reflect.Field[]",
+    ("Class", "getFields"): "java.lang.reflect.Field[]",
+    ("Executable", "getParameters"): "java.lang.reflect.Parameter[]",
+    ("Method", "getParameters"): "java.lang.reflect.Parameter[]",
+    ("Constructor", "getParameters"): "java.lang.reflect.Parameter[]",
+    ("Executable", "getGenericParameterTypes"): "java.lang.reflect.Type[]",
+    ("Method", "getGenericParameterTypes"): "java.lang.reflect.Type[]",
+    ("Constructor", "getGenericParameterTypes"): "java.lang.reflect.Type[]",
+    # Fixed (non-generic) `Collection`/`Map` contract returns, needed for
+    # overload-argument narrowing (P5 finding #1): `list.contains(x)`'s
+    # result is always primitive `boolean`, never a candidate's guessed
+    # reference type, regardless of the element type `E`/`K`/`V`.
+    ("Collection", "contains"): "boolean",
+    ("Collection", "isEmpty"): "boolean",
+    ("List", "contains"): "boolean",
+    ("List", "isEmpty"): "boolean",
+    ("ArrayList", "contains"): "boolean",
+    ("ArrayList", "isEmpty"): "boolean",
+    ("LinkedList", "contains"): "boolean",
+    ("LinkedList", "isEmpty"): "boolean",
+    ("Set", "contains"): "boolean",
+    ("Set", "isEmpty"): "boolean",
+    ("SortedSet", "contains"): "boolean",
+    ("SortedSet", "isEmpty"): "boolean",
+    ("Map", "containsKey"): "boolean",
+    ("Map", "containsValue"): "boolean",
+    ("Map", "isEmpty"): "boolean",
+    ("HashMap", "containsKey"): "boolean",
+    ("HashMap", "containsValue"): "boolean",
+    ("HashMap", "isEmpty"): "boolean",
+    ("LinkedHashMap", "containsKey"): "boolean",
+    ("LinkedHashMap", "containsValue"): "boolean",
+    ("LinkedHashMap", "isEmpty"): "boolean",
+    ("TreeMap", "containsKey"): "boolean",
+    ("TreeMap", "containsValue"): "boolean",
+    ("TreeMap", "isEmpty"): "boolean",
+    # Batch 24 — more fixed, non-generic JDK contract returns, all
+    # identical across every overload of the member. Same narrowing use as
+    # `contains`/`isEmpty` above; the largest remaining `overload@0.55`
+    # shapes in JUnit5 were `assertEquals(2, list.size())` (56 sites) and
+    # atomic/boxed accessors (`counter.get()`, `value.intValue()`).
+    ("Collection", "size"): "int",
+    ("List", "size"): "int",
+    ("ArrayList", "size"): "int",
+    ("LinkedList", "size"): "int",
+    ("Set", "size"): "int",
+    ("SortedSet", "size"): "int",
+    ("Map", "size"): "int",
+    ("HashMap", "size"): "int",
+    ("LinkedHashMap", "size"): "int",
+    ("TreeMap", "size"): "int",
+    ("Stream", "count"): "long",
+    ("Optional", "isPresent"): "boolean",
+    ("Optional", "isEmpty"): "boolean",
+    ("AtomicInteger", "get"): "int",
+    ("AtomicInteger", "intValue"): "int",
+    ("AtomicInteger", "incrementAndGet"): "int",
+    ("AtomicInteger", "getAndIncrement"): "int",
+    ("AtomicInteger", "decrementAndGet"): "int",
+    ("AtomicInteger", "getAndDecrement"): "int",
+    ("AtomicInteger", "addAndGet"): "int",
+    ("AtomicInteger", "getAndAdd"): "int",
+    ("AtomicInteger", "getAndSet"): "int",
+    ("AtomicInteger", "updateAndGet"): "int",
+    ("AtomicInteger", "compareAndSet"): "boolean",
+    ("AtomicLong", "get"): "long",
+    ("AtomicLong", "longValue"): "long",
+    ("AtomicLong", "incrementAndGet"): "long",
+    ("AtomicLong", "getAndIncrement"): "long",
+    ("AtomicLong", "decrementAndGet"): "long",
+    ("AtomicLong", "getAndDecrement"): "long",
+    ("AtomicLong", "addAndGet"): "long",
+    ("AtomicLong", "getAndAdd"): "long",
+    ("AtomicLong", "getAndSet"): "long",
+    ("AtomicLong", "updateAndGet"): "long",
+    ("AtomicLong", "compareAndSet"): "boolean",
+    ("AtomicBoolean", "get"): "boolean",
+    ("AtomicBoolean", "getAndSet"): "boolean",
+    ("AtomicBoolean", "compareAndSet"): "boolean",
+    ("AtomicReference", "get"): "V",
+    ("AtomicReference", "compareAndSet"): "boolean",
+    ("Number", "intValue"): "int",
+    ("Number", "longValue"): "long",
+    ("Number", "doubleValue"): "double",
+    ("Number", "floatValue"): "float",
+    ("Number", "shortValue"): "short",
+    ("Number", "byteValue"): "byte",
+    ("Integer", "intValue"): "int",
+    ("Integer", "longValue"): "long",
+    ("Integer", "doubleValue"): "double",
+    ("Long", "intValue"): "int",
+    ("Long", "longValue"): "long",
+    ("Long", "doubleValue"): "double",
+    ("Short", "intValue"): "int",
+    ("Short", "shortValue"): "short",
+    ("Byte", "intValue"): "int",
+    ("Byte", "byteValue"): "byte",
+    ("Double", "intValue"): "int",
+    ("Double", "longValue"): "long",
+    ("Double", "doubleValue"): "double",
+    ("Float", "intValue"): "int",
+    ("Float", "floatValue"): "float",
+    ("Float", "doubleValue"): "double",
+    ("Boolean", "booleanValue"): "boolean",
+    ("Character", "charValue"): "char",
+    ("BooleanSupplier", "getAsBoolean"): "boolean",
+    ("IntSupplier", "getAsInt"): "int",
+    ("LongSupplier", "getAsLong"): "long",
+    ("DoubleSupplier", "getAsDouble"): "double",
+    ("Duration", "isNegative"): "boolean",
+    ("Duration", "isZero"): "boolean",
+    ("Duration", "toMillis"): "long",
+    ("Duration", "toNanos"): "long",
+    ("Duration", "toSeconds"): "long",
+    ("Duration", "getSeconds"): "long",
+    # Batch 25 — fixed-return JDK members behind the remaining
+    # `assertTrue/assertFalse/assumeTrue(boolean)` vs `(BooleanSupplier)`
+    # fan-outs in JUnit5 (`filter.toPredicate().test(x)`, `stack.isEmpty()`,
+    # `lock.tryLock()`, `tempDir.exists()`, `stream.anyMatch(..)`,
+    # `Foo.class.getMethod(..).isBridge()`, `executor.awaitTermination(..)`)
+    # plus the fixed `String`/`Class`/reflection returns those chains pass
+    # through. Every entry is identical across all overloads of the member
+    # and holds for every element/type argument, exactly like the
+    # `contains`/`isEmpty` facts above; a source class sharing a JDK simple
+    # name is still never stubbed (`_generic_method_invocation_return_type`
+    # checks source resolution first).
+    ("Predicate", "test"): "boolean",
+    ("BiPredicate", "test"): "boolean",
+    ("Stream", "anyMatch"): "boolean",
+    ("Stream", "allMatch"): "boolean",
+    ("Stream", "noneMatch"): "boolean",
+    ("IntStream", "anyMatch"): "boolean",
+    ("IntStream", "allMatch"): "boolean",
+    ("IntStream", "noneMatch"): "boolean",
+    ("Iterator", "hasNext"): "boolean",
+    ("ListIterator", "hasNext"): "boolean",
+    ("ListIterator", "hasPrevious"): "boolean",
+    ("Collection", "add"): "boolean",
+    ("List", "add"): "boolean",
+    ("ArrayList", "add"): "boolean",
+    ("LinkedList", "add"): "boolean",
+    ("Set", "add"): "boolean",
+    ("SortedSet", "add"): "boolean",
+    ("Collection", "containsAll"): "boolean",
+    ("List", "containsAll"): "boolean",
+    ("Set", "containsAll"): "boolean",
+    ("HashSet", "contains"): "boolean",
+    ("HashSet", "isEmpty"): "boolean",
+    ("HashSet", "add"): "boolean",
+    ("HashSet", "size"): "int",
+    ("LinkedHashSet", "contains"): "boolean",
+    ("LinkedHashSet", "isEmpty"): "boolean",
+    ("LinkedHashSet", "add"): "boolean",
+    ("LinkedHashSet", "size"): "int",
+    ("TreeSet", "contains"): "boolean",
+    ("TreeSet", "isEmpty"): "boolean",
+    ("TreeSet", "add"): "boolean",
+    ("TreeSet", "size"): "int",
+    ("EnumSet", "contains"): "boolean",
+    ("EnumSet", "isEmpty"): "boolean",
+    ("EnumSet", "containsAll"): "boolean",
+    ("EnumSet", "size"): "int",
+    ("Stack", "isEmpty"): "boolean",
+    ("Stack", "empty"): "boolean",
+    ("Stack", "contains"): "boolean",
+    ("Stack", "add"): "boolean",
+    ("Stack", "size"): "int",
+    ("Stack", "search"): "int",
+    ("Stack", "peek"): "E",
+    ("Stack", "pop"): "E",
+    ("Stack", "push"): "E",
+    ("Deque", "isEmpty"): "boolean",
+    ("Deque", "contains"): "boolean",
+    ("Deque", "size"): "int",
+    ("ArrayDeque", "isEmpty"): "boolean",
+    ("ArrayDeque", "contains"): "boolean",
+    ("ArrayDeque", "size"): "int",
+    ("Queue", "isEmpty"): "boolean",
+    ("Queue", "contains"): "boolean",
+    ("Queue", "size"): "int",
+    ("Map", "isEmpty"): "boolean",
+    ("ConcurrentHashMap", "containsKey"): "boolean",
+    ("ConcurrentHashMap", "isEmpty"): "boolean",
+    ("ConcurrentHashMap", "size"): "int",
+    ("ConcurrentMap", "containsKey"): "boolean",
+    ("ConcurrentMap", "isEmpty"): "boolean",
+    ("ConcurrentMap", "size"): "int",
+    ("Lock", "tryLock"): "boolean",
+    ("ReentrantLock", "tryLock"): "boolean",
+    ("ReentrantLock", "isLocked"): "boolean",
+    ("ReentrantLock", "isHeldByCurrentThread"): "boolean",
+    ("ReentrantLock", "hasQueuedThreads"): "boolean",
+    ("ReentrantLock", "isFair"): "boolean",
+    ("ReentrantLock", "getHoldCount"): "int",
+    ("ThreadLocal", "get"): "T",
+    ("Future", "get"): "V",
+    ("Future", "isDone"): "boolean",
+    ("Future", "isCancelled"): "boolean",
+    ("Future", "cancel"): "boolean",
+    ("CompletableFuture", "get"): "T",
+    ("CompletableFuture", "join"): "T",
+    ("CompletableFuture", "getNow"): "T",
+    ("CompletableFuture", "isDone"): "boolean",
+    ("CompletableFuture", "isCancelled"): "boolean",
+    ("CompletableFuture", "isCompletedExceptionally"): "boolean",
+    ("CompletableFuture", "cancel"): "boolean",
+    ("CompletableFuture", "complete"): "boolean",
+    ("ExecutorService", "awaitTermination"): "boolean",
+    ("ExecutorService", "isShutdown"): "boolean",
+    ("ExecutorService", "isTerminated"): "boolean",
+    ("ScheduledExecutorService", "awaitTermination"): "boolean",
+    ("ScheduledExecutorService", "isShutdown"): "boolean",
+    ("ScheduledExecutorService", "isTerminated"): "boolean",
+    ("ThreadPoolExecutor", "awaitTermination"): "boolean",
+    ("ThreadPoolExecutor", "isShutdown"): "boolean",
+    ("ThreadPoolExecutor", "isTerminated"): "boolean",
+    ("ForkJoinPool", "awaitTermination"): "boolean",
+    ("ForkJoinPool", "awaitQuiescence"): "boolean",
+    ("ForkJoinPool", "isShutdown"): "boolean",
+    ("ForkJoinPool", "isTerminated"): "boolean",
+    ("ForkJoinPool", "isQuiescent"): "boolean",
+    ("ForkJoinPool", "getParallelism"): "int",
+    ("CountDownLatch", "await"): "boolean",
+    ("CountDownLatch", "getCount"): "long",
+    ("Semaphore", "tryAcquire"): "boolean",
+    ("Semaphore", "availablePermits"): "int",
+    ("Thread", "isInterrupted"): "boolean",
+    ("Thread", "isAlive"): "boolean",
+    ("Thread", "isDaemon"): "boolean",
+    ("Thread", "isVirtual"): "boolean",
+    ("Thread", "getName"): "String",
+    ("Thread", "getPriority"): "int",
+    ("Thread", "getId"): "long",
+    ("Thread", "threadId"): "long",
+    ("File", "exists"): "boolean",
+    ("File", "isDirectory"): "boolean",
+    ("File", "isFile"): "boolean",
+    ("File", "isAbsolute"): "boolean",
+    ("File", "isHidden"): "boolean",
+    ("File", "canRead"): "boolean",
+    ("File", "canWrite"): "boolean",
+    ("File", "canExecute"): "boolean",
+    ("File", "createNewFile"): "boolean",
+    ("File", "delete"): "boolean",
+    ("File", "mkdir"): "boolean",
+    ("File", "mkdirs"): "boolean",
+    ("File", "renameTo"): "boolean",
+    ("File", "setReadOnly"): "boolean",
+    ("File", "setReadable"): "boolean",
+    ("File", "setWritable"): "boolean",
+    ("File", "setExecutable"): "boolean",
+    ("File", "setLastModified"): "boolean",
+    ("File", "getName"): "String",
+    ("File", "getPath"): "String",
+    ("File", "getParent"): "String",
+    ("File", "getAbsolutePath"): "String",
+    ("File", "getCanonicalPath"): "String",
+    ("File", "getParentFile"): "java.io.File",
+    ("File", "getAbsoluteFile"): "java.io.File",
+    ("File", "getCanonicalFile"): "java.io.File",
+    ("File", "toPath"): "java.nio.file.Path",
+    ("File", "length"): "long",
+    ("File", "lastModified"): "long",
+    ("File", "listFiles"): "java.io.File[]",
+    ("File", "list"): "String[]",
+    ("Path", "toFile"): "java.io.File",
+    ("Path", "getFileName"): "java.nio.file.Path",
+    ("Path", "getParent"): "java.nio.file.Path",
+    ("Path", "getRoot"): "java.nio.file.Path",
+    ("Path", "toAbsolutePath"): "java.nio.file.Path",
+    ("Path", "normalize"): "java.nio.file.Path",
+    ("Path", "resolve"): "java.nio.file.Path",
+    ("Path", "resolveSibling"): "java.nio.file.Path",
+    ("Path", "relativize"): "java.nio.file.Path",
+    ("Path", "toRealPath"): "java.nio.file.Path",
+    ("Path", "startsWith"): "boolean",
+    ("Path", "endsWith"): "boolean",
+    ("Path", "isAbsolute"): "boolean",
+    ("Path", "getNameCount"): "int",
+    ("Class", "isArray"): "boolean",
+    ("Class", "isPrimitive"): "boolean",
+    ("Class", "isInterface"): "boolean",
+    ("Class", "isEnum"): "boolean",
+    ("Class", "isRecord"): "boolean",
+    ("Class", "isAnnotation"): "boolean",
+    ("Class", "isAssignableFrom"): "boolean",
+    ("Class", "isInstance"): "boolean",
+    ("Class", "isAnonymousClass"): "boolean",
+    ("Class", "isMemberClass"): "boolean",
+    ("Class", "isLocalClass"): "boolean",
+    ("Class", "isSynthetic"): "boolean",
+    ("Class", "isSealed"): "boolean",
+    ("Class", "isHidden"): "boolean",
+    ("Class", "isNestmateOf"): "boolean",
+    ("Class", "isAnnotationPresent"): "boolean",
+    ("Class", "desiredAssertionStatus"): "boolean",
+    ("Class", "getComponentType"): "Class",
+    ("Class", "getSuperclass"): "Class",
+    ("Class", "getEnclosingClass"): "Class",
+    ("Class", "getDeclaringClass"): "Class",
+    ("Class", "getNestHost"): "Class",
+    ("Class", "getInterfaces"): "Class[]",
+    ("Class", "getMethod"): "java.lang.reflect.Method",
+    ("Class", "getConstructor"): "java.lang.reflect.Constructor",
+    ("Class", "getDeclaredConstructor"): "java.lang.reflect.Constructor",
+    ("Class", "getField"): "java.lang.reflect.Field",
+    ("Class", "getDeclaredField"): "java.lang.reflect.Field",
+    ("Class", "getModifiers"): "int",
+    ("Class", "getCanonicalName"): "String",
+    ("Class", "getTypeName"): "String",
+    ("Class", "getPackageName"): "String",
+    ("Class", "getModule"): "java.lang.Module",
+    ("Module", "isNamed"): "boolean",
+    ("Module", "getName"): "String",
+    ("Method", "isBridge"): "boolean",
+    ("Method", "isSynthetic"): "boolean",
+    ("Method", "isDefault"): "boolean",
+    ("Method", "isVarArgs"): "boolean",
+    ("Method", "isAnnotationPresent"): "boolean",
+    ("Method", "getModifiers"): "int",
+    ("Method", "getParameterCount"): "int",
+    ("Method", "getReturnType"): "Class",
+    ("Method", "getDeclaringClass"): "Class",
+    ("Constructor", "isSynthetic"): "boolean",
+    ("Constructor", "isVarArgs"): "boolean",
+    ("Constructor", "getModifiers"): "int",
+    ("Constructor", "getParameterCount"): "int",
+    ("Constructor", "getDeclaringClass"): "Class",
+    ("Field", "getName"): "String",
+    ("Field", "getType"): "Class",
+    ("Field", "getDeclaringClass"): "Class",
+    ("Field", "getModifiers"): "int",
+    ("Field", "isSynthetic"): "boolean",
+    ("Field", "isEnumConstant"): "boolean",
+    ("Parameter", "getName"): "String",
+    ("Parameter", "getType"): "Class",
+    ("Parameter", "isNamePresent"): "boolean",
+    ("Parameter", "isVarArgs"): "boolean",
+    ("Pattern", "matcher"): "java.util.regex.Matcher",
+    ("Pattern", "pattern"): "String",
+    ("Matcher", "matches"): "boolean",
+    ("Matcher", "find"): "boolean",
+    ("Matcher", "lookingAt"): "boolean",
+    ("Matcher", "hitEnd"): "boolean",
+    ("Matcher", "group"): "String",
+    ("Matcher", "groupCount"): "int",
+    ("Matcher", "start"): "int",
+    ("Matcher", "end"): "int",
+    ("Throwable", "getMessage"): "String",
+    ("Throwable", "getLocalizedMessage"): "String",
+    ("Throwable", "getCause"): "Throwable",
+    ("Throwable", "getStackTrace"): "StackTraceElement[]",
+    ("Throwable", "getSuppressed"): "Throwable[]",
+    ("Exception", "getMessage"): "String",
+    ("Exception", "getLocalizedMessage"): "String",
+    ("Exception", "getCause"): "Throwable",
+    ("Exception", "getStackTrace"): "StackTraceElement[]",
+    ("RuntimeException", "getMessage"): "String",
+    ("RuntimeException", "getCause"): "Throwable",
+    ("RuntimeException", "getStackTrace"): "StackTraceElement[]",
+    ("Error", "getMessage"): "String",
+    ("Error", "getCause"): "Throwable",
+    ("Error", "getStackTrace"): "StackTraceElement[]",
+    ("AssertionError", "getMessage"): "String",
+    ("AssertionError", "getCause"): "Throwable",
+    ("AssertionError", "getStackTrace"): "StackTraceElement[]",
+    ("IllegalArgumentException", "getMessage"): "String",
+    ("IllegalArgumentException", "getCause"): "Throwable",
+    ("IllegalStateException", "getMessage"): "String",
+    ("IllegalStateException", "getCause"): "Throwable",
+    ("UnsupportedOperationException", "getMessage"): "String",
+    ("NullPointerException", "getMessage"): "String",
+    ("IOException", "getMessage"): "String",
+    ("IOException", "getCause"): "Throwable",
+    ("UncheckedIOException", "getMessage"): "String",
+    ("UncheckedIOException", "getCause"): "IOException",
+    ("InterruptedException", "getMessage"): "String",
+    ("ExecutionException", "getMessage"): "String",
+    ("ExecutionException", "getCause"): "Throwable",
+    ("TimeoutException", "getMessage"): "String",
+    ("ReflectiveOperationException", "getMessage"): "String",
+    ("ClassNotFoundException", "getMessage"): "String",
+    ("NoSuchMethodException", "getMessage"): "String",
+    ("InvocationTargetException", "getMessage"): "String",
+    ("InvocationTargetException", "getCause"): "Throwable",
+    ("InvocationTargetException", "getTargetException"): "Throwable",
+    ("StackTraceElement", "getClassName"): "String",
+    ("StackTraceElement", "getMethodName"): "String",
+    ("StackTraceElement", "getFileName"): "String",
+    ("StackTraceElement", "getLineNumber"): "int",
+    ("StackTraceElement", "isNativeMethod"): "boolean",
+    # Batch 26 — `java.time` accessors (fixed `int`/`long`/`boolean`
+    # results on every temporal type that declares them), `Comparable`,
+    # primitive-stream pipeline steps with a fixed result stream, and the
+    # `InputStream`/`Reader`/`ClassLoader` members behind remaining
+    # `assertEquals` fan-outs.
+    ("LocalDate", "getYear"): "int",
+    ("LocalDate", "getMonthValue"): "int",
+    ("LocalDate", "getDayOfMonth"): "int",
+    ("LocalDate", "getDayOfYear"): "int",
+    ("LocalDate", "lengthOfMonth"): "int",
+    ("LocalDate", "lengthOfYear"): "int",
+    ("LocalDate", "toEpochDay"): "long",
+    ("LocalDate", "isLeapYear"): "boolean",
+    ("LocalDate", "isBefore"): "boolean",
+    ("LocalDate", "isAfter"): "boolean",
+    ("LocalDate", "isEqual"): "boolean",
+    ("LocalDateTime", "getYear"): "int",
+    ("LocalDateTime", "getMonthValue"): "int",
+    ("LocalDateTime", "getDayOfMonth"): "int",
+    ("LocalDateTime", "getDayOfYear"): "int",
+    ("LocalDateTime", "getHour"): "int",
+    ("LocalDateTime", "getMinute"): "int",
+    ("LocalDateTime", "getSecond"): "int",
+    ("LocalDateTime", "getNano"): "int",
+    ("LocalDateTime", "isBefore"): "boolean",
+    ("LocalDateTime", "isAfter"): "boolean",
+    ("LocalDateTime", "isEqual"): "boolean",
+    ("LocalTime", "getHour"): "int",
+    ("LocalTime", "getMinute"): "int",
+    ("LocalTime", "getSecond"): "int",
+    ("LocalTime", "getNano"): "int",
+    ("LocalTime", "toSecondOfDay"): "int",
+    ("LocalTime", "toNanoOfDay"): "long",
+    ("LocalTime", "isBefore"): "boolean",
+    ("LocalTime", "isAfter"): "boolean",
+    ("ZonedDateTime", "getYear"): "int",
+    ("ZonedDateTime", "getMonthValue"): "int",
+    ("ZonedDateTime", "getDayOfMonth"): "int",
+    ("ZonedDateTime", "getHour"): "int",
+    ("ZonedDateTime", "getMinute"): "int",
+    ("ZonedDateTime", "getSecond"): "int",
+    ("ZonedDateTime", "getNano"): "int",
+    ("ZonedDateTime", "toEpochSecond"): "long",
+    ("ZonedDateTime", "isBefore"): "boolean",
+    ("ZonedDateTime", "isAfter"): "boolean",
+    ("OffsetDateTime", "getYear"): "int",
+    ("OffsetDateTime", "getMonthValue"): "int",
+    ("OffsetDateTime", "getDayOfMonth"): "int",
+    ("OffsetDateTime", "getHour"): "int",
+    ("OffsetDateTime", "getMinute"): "int",
+    ("OffsetDateTime", "getSecond"): "int",
+    ("OffsetDateTime", "toEpochSecond"): "long",
+    ("Instant", "getEpochSecond"): "long",
+    ("Instant", "toEpochMilli"): "long",
+    ("Instant", "getNano"): "int",
+    ("Instant", "isBefore"): "boolean",
+    ("Instant", "isAfter"): "boolean",
+    ("Year", "getValue"): "int",
+    ("Year", "length"): "int",
+    ("Year", "isLeap"): "boolean",
+    ("Year", "isBefore"): "boolean",
+    ("Year", "isAfter"): "boolean",
+    ("YearMonth", "getYear"): "int",
+    ("YearMonth", "getMonthValue"): "int",
+    ("YearMonth", "lengthOfMonth"): "int",
+    ("YearMonth", "lengthOfYear"): "int",
+    ("Period", "getYears"): "int",
+    ("Period", "getMonths"): "int",
+    ("Period", "getDays"): "int",
+    ("Period", "toTotalMonths"): "long",
+    ("Period", "isNegative"): "boolean",
+    ("Period", "isZero"): "boolean",
+    ("Duration", "toDays"): "long",
+    ("Duration", "toHours"): "long",
+    ("Duration", "toMinutes"): "long",
+    ("Duration", "getNano"): "int",
+    ("Duration", "compareTo"): "int",
+    ("Comparable", "compareTo"): "int",
+    ("Comparator", "compare"): "int",
+    ("IntStream", "limit"): "IntStream",
+    ("IntStream", "skip"): "IntStream",
+    ("IntStream", "peek"): "IntStream",
+    ("IntStream", "asLongStream"): "LongStream",
+    ("IntStream", "asDoubleStream"): "DoubleStream",
+    ("LongStream", "limit"): "LongStream",
+    ("LongStream", "skip"): "LongStream",
+    ("LongStream", "peek"): "LongStream",
+    ("DoubleStream", "limit"): "DoubleStream",
+    ("DoubleStream", "skip"): "DoubleStream",
+    ("DoubleStream", "peek"): "DoubleStream",
+    ("Stream", "limit"): "Stream<T>",
+    ("Stream", "skip"): "Stream<T>",
+    ("InputStream", "read"): "int",
+    ("InputStream", "available"): "int",
+    ("InputStream", "readAllBytes"): "byte[]",
+    ("Reader", "read"): "int",
+    ("BufferedReader", "readLine"): "String",
+    ("ClassLoader", "loadClass"): "Class",
+    ("ClassLoader", "getResource"): "java.net.URL",
+    ("ClassLoader", "getParent"): "ClassLoader",
+}
+
+JAVA_GENERIC_TYPE_PARAM_STUBS: Dict[str, List[str]] = {
+    "Iterable": ["T"],
+    "AtomicReference": ["V"],
+    "Collection": ["E"],
+    "List": ["E"],
+    "Set": ["E"],
+    "SortedSet": ["E"],
+    "ArrayList": ["E"],
+    "LinkedList": ["E"],
+    "Iterator": ["T"],
+    "ListIterator": ["E"],
+    "Optional": ["T"],
+    "Stream": ["T"],
+    "Map": ["K", "V"],
+    "Entry": ["K", "V"],
+    "HashMap": ["K", "V"],
+    "LinkedHashMap": ["K", "V"],
+    "TreeMap": ["K", "V"],
+    "Function": ["T", "R"],
+    "Supplier": ["T"],
+    "BiFunction": ["T", "U", "R"],
+    "UnaryOperator": ["T"],
+    "BinaryOperator": ["T"],
+    "Callable": ["V"],
+    "HashSet": ["E"],
+    "LinkedHashSet": ["E"],
+    "TreeSet": ["E"],
+    "Stack": ["E"],
+    "ThreadLocal": ["T"],
+    "Future": ["V"],
+    "CompletableFuture": ["T"],
+}
+# Stream operations whose first functional argument consumes one stream
+# element.  This is used only to type an implicit lambda parameter from an
+# already-proven `Stream<T>` receiver; it does not fabricate a call target
+# for the external JDK method itself.
+JAVA_STREAM_ELEMENT_LAMBDA_METHODS: FrozenSet[str] = frozenset({
+    "allMatch", "anyMatch", "filter", "forEach", "forEachOrdered", "map",
+    "noneMatch", "peek",
+    # Batch 26: the remaining element-consuming single-lambda steps —
+    # `mapToObj`/`mapToInt`/`mapToLong`/`mapToDouble`/`flatMap`/
+    # `takeWhile`/`dropWhile` all receive one element as their sole lambda
+    # parameter (`IntStream.range(..).mapToObj(n -> ..)` is the JUnit5
+    # dynamic-test idiom).
+    "mapToObj", "mapToInt", "mapToLong", "mapToDouble", "flatMap",
+    "takeWhile", "dropWhile",
+    # `Comparator<? super T>` consumers: every lambda parameter is `T`
+    # (`sorted((l, r) -> ...)`, `min`, `max`). `reduce` is excluded because
+    # its identity overload places the accumulator at argument index 1.
+    "max", "min", "sorted",
+})
+JAVA_OPTIONAL_ELEMENT_LAMBDA_METHODS: FrozenSet[str] = frozenset({
+    "filter", "flatMap", "ifPresent", "ifPresentOrElse", "map",
+})
+# `org.assertj.core.api` static-factory owners whose `assertThat(actual)`
+# this resolver recognizes by argument type alone (AssertJ's own overload
+# set lives outside the analyzed source and cannot be resolved structurally).
+# Used only to type a `Consumer`/`Predicate` argument passed to the returned
+# assert wrapper's own fluent methods one hop later (`hasValueSatisfying`,
+# `satisfies`, `allSatisfy`, ...) — never to fabricate a call edge to AssertJ
+# itself.
+ASSERTJ_ASSERT_FACTORY_OWNERS: FrozenSet[str] = frozenset({
+    "org.assertj.core.api.Assertions",
+    "org.assertj.core.api.AssertionsForClassTypes",
+    "org.assertj.core.api.AssertionsForInterfaceTypes",
+})
+# AssertJ assert-wrapper simple name -> its `Consumer<element>`-typed fluent
+# methods, keyed by the wrapper this resolver derives in
+# `_assertj_assertthat_return_type` (`ObjectAssert`, `OptionalAssert`,
+# `ListAssert`). Real AssertJ also exposes `IterableAssert` for a plain
+# `Iterable` actual; kept here too since `allSatisfy`/`anySatisfy`/
+# `noneSatisfy` share the identical signature on both.
+ASSERTJ_CONSUMER_SATISFIES_METHODS: FrozenSet[str] = frozenset({
+    "hasValueSatisfying", "satisfies", "allSatisfy", "anySatisfy", "noneSatisfy",
+})
+# Same wrappers' `Predicate<element>`-typed fluent methods.
+ASSERTJ_PREDICATE_METHODS: FrozenSet[str] = frozenset({
+    "filteredOn", "allMatch", "anyMatch", "noneMatch",
+})
+# `java.lang` simple names that are in scope without an import.  A file that
+# spells one of these without a same-package or imported declaration means the
+# JDK type; it must never be recovered as an unrelated project class that
+# happens to share the simple name.
+JAVA_LANG_SIMPLE_TYPES: FrozenSet[str] = frozenset({
+    "AssertionError", "Boolean", "Byte", "Character", "CharSequence", "Class",
+    "ClassLoader",
+    "CloneNotSupportedException",
+    "Comparable", "Double", "Enum", "Error", "Exception", "Float", "Integer",
+    "IllegalAccessException", "InterruptedException", "Iterable", "LinkageError", "Long", "Math", "NullPointerException", "Number",
+    "Object",
+    "Record", "Runnable",
+    "RuntimeException", "Short", "String", "StringBuilder", "StringBuffer",
+    "System", "Thread", "Throwable", "Void",
+})
+# Exact external static-return facts needed for overload argument inference.
+# Keyed by FQN so a project-local same-simple-name class never matches.
+JAVA_STATIC_METHOD_STUB_RETURNS: Dict[Tuple[str, str], str] = {
+    ("java.lang.String", "valueOf"): "String",
+    # Every overload of `String.format`/`String.join` returns `String`. A
+    # `String.format(...)` argument is the most common shape of the JUnit5
+    # `overload/java_resolver@0.55` stratum alongside `"...".formatted(...)`
+    # (`assertTrue(cond, String.format(...))` vs the `Supplier<String>`
+    # sibling; `new PreconditionViolationException(String.format(...))`).
+    ("java.lang.String", "format"): "String",
+    ("java.lang.String", "join"): "String",
+    # Batch 24: `java.lang` parsers (no import needed — see
+    # `_external_static_call_return_type`'s `java.lang` default) and the
+    # `java.nio.file.Files` predicates/readers; every overload of each has
+    # the one fixed return listed. `assertTrue(Files.exists(dir))` (JUnit5
+    # `TempDirectory*Tests`, 51 sites) fanned out to `assertTrue
+    # (BooleanSupplier)` before.
+    ("java.lang.Integer", "parseInt"): "int",
+    ("java.lang.Long", "parseLong"): "long",
+    ("java.lang.Short", "parseShort"): "short",
+    ("java.lang.Byte", "parseByte"): "byte",
+    ("java.lang.Double", "parseDouble"): "double",
+    ("java.lang.Float", "parseFloat"): "float",
+    ("java.lang.Boolean", "parseBoolean"): "boolean",
+    ("java.nio.file.Files", "exists"): "boolean",
+    ("java.nio.file.Files", "notExists"): "boolean",
+    ("java.nio.file.Files", "isDirectory"): "boolean",
+    ("java.nio.file.Files", "isRegularFile"): "boolean",
+    ("java.nio.file.Files", "isReadable"): "boolean",
+    ("java.nio.file.Files", "isWritable"): "boolean",
+    ("java.nio.file.Files", "isExecutable"): "boolean",
+    ("java.nio.file.Files", "isHidden"): "boolean",
+    ("java.nio.file.Files", "isSymbolicLink"): "boolean",
+    ("java.nio.file.Files", "isSameFile"): "boolean",
+    ("java.nio.file.Files", "deleteIfExists"): "boolean",
+    ("java.nio.file.Files", "readAllLines"): "List<String>",
+    ("java.nio.file.Files", "readString"): "String",
+    ("java.nio.file.Files", "readAllBytes"): "byte[]",
+    ("java.nio.file.Files", "lines"): "Stream<String>",
+    ("java.nio.file.Files", "size"): "long",
+    # Every overload of `Paths.get` has the fixed declared return `Path`.
+    # Keep the key FQN-scoped so a source `Paths` type never receives this
+    # external JDK contract accidentally.
+    ("java.nio.file.Paths", "get"): "Path",
+    ("java.time.Clock", "systemDefaultZone"): "Clock",
+    # `java.time.Year`'s three fixed-return static factories — needed for
+    # overload narrowing: `YearHasPassed.of(int)` derives a `Year` via one of
+    # these and passes it to the sibling `YearHasPassed.of(Year)`, which used
+    # to fan out against the `int` overload itself since each nested call's
+    # return type was unknown (spring-modulith benchmark, one call site each
+    # in `YearHasPassed.java` (`of`), `Moments.java` (`from`) and
+    # `MomentsUnitTests.java` (`now`)).
+    ("java.time.Year", "of"): "Year",
+    ("java.time.Year", "from"): "Year",
+    ("java.time.Year", "now"): "Year",
+    # `IntStream`/`LongStream`'s two static range factories are fixed to
+    # their own (non-generic) stream type regardless of the bound
+    # expressions, feeding the primitive-stream terminal-op facts in
+    # `JAVA_GENERIC_METHOD_STUB_RETURNS` above.
+    ("java.util.stream.IntStream", "range"): "IntStream",
+    ("java.util.stream.IntStream", "rangeClosed"): "IntStream",
+    ("java.util.stream.LongStream", "range"): "LongStream",
+    ("java.util.stream.LongStream", "rangeClosed"): "LongStream",
+    # Batch 25 — fixed static returns behind remaining JUnit5 boolean/int/
+    # String overload arguments (`Thread.interrupted()`, `Modifier.isPublic
+    # (m)`, `Objects.equals(a, b)`, `Arrays.toString(x)`, `System.
+    # getProperty(k)`) and the fluent roots they chain from
+    # (`Thread.currentThread().isInterrupted()`, `Pattern.compile(p).
+    # matcher(s).matches()`, `Files.createTempDirectory(p).toFile()`).
+    ("java.lang.Thread", "interrupted"): "boolean",
+    ("java.lang.Thread", "currentThread"): "Thread",
+    ("java.lang.Thread", "activeCount"): "int",
+    ("java.lang.System", "currentTimeMillis"): "long",
+    ("java.lang.System", "nanoTime"): "long",
+    ("java.lang.System", "getProperty"): "String",
+    ("java.lang.System", "getenv"): "String",
+    ("java.lang.System", "lineSeparator"): "String",
+    ("java.lang.System", "identityHashCode"): "int",
+    ("java.lang.Boolean", "toString"): "String",
+    ("java.lang.Boolean", "logicalAnd"): "boolean",
+    ("java.lang.Boolean", "logicalOr"): "boolean",
+    ("java.lang.Boolean", "logicalXor"): "boolean",
+    ("java.lang.Boolean", "getBoolean"): "boolean",
+    ("java.lang.Character", "isDigit"): "boolean",
+    ("java.lang.Character", "isLetter"): "boolean",
+    ("java.lang.Character", "isLetterOrDigit"): "boolean",
+    ("java.lang.Character", "isWhitespace"): "boolean",
+    ("java.lang.Character", "isSpaceChar"): "boolean",
+    ("java.lang.Character", "isUpperCase"): "boolean",
+    ("java.lang.Character", "isLowerCase"): "boolean",
+    ("java.lang.Character", "isAlphabetic"): "boolean",
+    ("java.lang.Character", "isJavaIdentifierStart"): "boolean",
+    ("java.lang.Character", "isJavaIdentifierPart"): "boolean",
+    ("java.lang.Integer", "toString"): "String",
+    ("java.lang.Integer", "toHexString"): "String",
+    ("java.lang.Integer", "toBinaryString"): "String",
+    ("java.lang.Integer", "compare"): "int",
+    ("java.lang.Integer", "signum"): "int",
+    ("java.lang.Integer", "bitCount"): "int",
+    ("java.lang.Integer", "sum"): "int",
+    ("java.lang.Integer", "max"): "int",
+    ("java.lang.Integer", "min"): "int",
+    ("java.lang.Long", "toString"): "String",
+    ("java.lang.Long", "toHexString"): "String",
+    ("java.lang.Long", "compare"): "int",
+    ("java.lang.Long", "signum"): "int",
+    ("java.lang.Long", "sum"): "long",
+    ("java.lang.Long", "max"): "long",
+    ("java.lang.Long", "min"): "long",
+    ("java.lang.Double", "toString"): "String",
+    ("java.lang.Double", "compare"): "int",
+    ("java.lang.Double", "isNaN"): "boolean",
+    ("java.lang.Double", "isInfinite"): "boolean",
+    ("java.lang.Double", "isFinite"): "boolean",
+    ("java.lang.Double", "sum"): "double",
+    ("java.lang.Double", "max"): "double",
+    ("java.lang.Double", "min"): "double",
+    ("java.lang.Float", "isNaN"): "boolean",
+    ("java.lang.Float", "isInfinite"): "boolean",
+    ("java.lang.Float", "isFinite"): "boolean",
+    ("java.lang.Math", "sqrt"): "double",
+    ("java.lang.Math", "pow"): "double",
+    ("java.lang.Math", "floor"): "double",
+    ("java.lang.Math", "ceil"): "double",
+    ("java.lang.Math", "random"): "double",
+    ("java.lang.Math", "toIntExact"): "int",
+    ("java.lang.String", "copyValueOf"): "String",
+    ("java.lang.Class", "forName"): "Class",
+    # Batch 26 — boxed `valueOf` factories (every overload returns the box),
+    # `IntStream`/`Stream` sources whose result type is fixed, class loading.
+    ("java.lang.Integer", "valueOf"): "Integer",
+    ("java.lang.Long", "valueOf"): "Long",
+    ("java.lang.Short", "valueOf"): "Short",
+    ("java.lang.Byte", "valueOf"): "Byte",
+    ("java.lang.Double", "valueOf"): "Double",
+    ("java.lang.Float", "valueOf"): "Float",
+    ("java.lang.Boolean", "valueOf"): "Boolean",
+    ("java.lang.Character", "valueOf"): "Character",
+    ("java.util.stream.IntStream", "of"): "IntStream",
+    ("java.util.stream.IntStream", "iterate"): "IntStream",
+    ("java.util.stream.IntStream", "generate"): "IntStream",
+    ("java.util.stream.IntStream", "concat"): "IntStream",
+    ("java.util.stream.IntStream", "empty"): "IntStream",
+    ("java.util.stream.LongStream", "of"): "LongStream",
+    ("java.util.stream.LongStream", "iterate"): "LongStream",
+    ("java.util.stream.LongStream", "generate"): "LongStream",
+    ("java.util.stream.LongStream", "concat"): "LongStream",
+    ("java.util.stream.DoubleStream", "of"): "DoubleStream",
+    ("java.util.stream.DoubleStream", "iterate"): "DoubleStream",
+    ("java.util.stream.DoubleStream", "generate"): "DoubleStream",
+    ("java.lang.reflect.Modifier", "isPublic"): "boolean",
+    ("java.lang.reflect.Modifier", "isPrivate"): "boolean",
+    ("java.lang.reflect.Modifier", "isProtected"): "boolean",
+    ("java.lang.reflect.Modifier", "isStatic"): "boolean",
+    ("java.lang.reflect.Modifier", "isFinal"): "boolean",
+    ("java.lang.reflect.Modifier", "isAbstract"): "boolean",
+    ("java.lang.reflect.Modifier", "isInterface"): "boolean",
+    ("java.lang.reflect.Modifier", "isNative"): "boolean",
+    ("java.lang.reflect.Modifier", "isSynchronized"): "boolean",
+    ("java.lang.reflect.Modifier", "isTransient"): "boolean",
+    ("java.lang.reflect.Modifier", "isVolatile"): "boolean",
+    ("java.lang.reflect.Modifier", "toString"): "String",
+    ("java.util.Objects", "equals"): "boolean",
+    ("java.util.Objects", "deepEquals"): "boolean",
+    ("java.util.Objects", "isNull"): "boolean",
+    ("java.util.Objects", "nonNull"): "boolean",
+    ("java.util.Objects", "hash"): "int",
+    ("java.util.Objects", "hashCode"): "int",
+    ("java.util.Objects", "toString"): "String",
+    ("java.util.Arrays", "equals"): "boolean",
+    ("java.util.Arrays", "deepEquals"): "boolean",
+    ("java.util.Arrays", "toString"): "String",
+    ("java.util.Arrays", "deepToString"): "String",
+    ("java.util.Arrays", "hashCode"): "int",
+    ("java.util.Arrays", "deepHashCode"): "int",
+    ("java.util.Collections", "disjoint"): "boolean",
+    ("java.util.Collections", "addAll"): "boolean",
+    ("java.util.Collections", "frequency"): "int",
+    ("java.util.regex.Pattern", "compile"): "java.util.regex.Pattern",
+    ("java.util.regex.Pattern", "matches"): "boolean",
+    ("java.util.regex.Pattern", "quote"): "String",
+    ("java.nio.file.Path", "of"): "Path",
+    ("java.nio.file.Files", "createFile"): "Path",
+    ("java.nio.file.Files", "createDirectory"): "Path",
+    ("java.nio.file.Files", "createDirectories"): "Path",
+    ("java.nio.file.Files", "createTempFile"): "Path",
+    ("java.nio.file.Files", "createTempDirectory"): "Path",
+    ("java.nio.file.Files", "write"): "Path",
+    ("java.nio.file.Files", "writeString"): "Path",
+    ("java.nio.file.Files", "copy"): "Path",
+    ("java.nio.file.Files", "move"): "Path",
+    ("java.nio.file.Files", "walk"): "Stream<Path>",
+    ("java.nio.file.Files", "list"): "Stream<Path>",
+    ("java.nio.file.Files", "getLastModifiedTime"): "java.nio.file.attribute.FileTime",
+    # Every overload of Spring's `ClassUtils.getPackageName` (`Class<?>` or
+    # `String` FQN) is fixed to `String` regardless of the argument. Needed
+    # for overload narrowing (E3, JAVA_METRICS_SPRING_MODULITH_PRECISION_SAMPLE.md):
+    # `PackageName.of(ClassUtils.getPackageName(type))` fanned out between
+    # `of(String)`/`of(String[])` because the nested call's return type was
+    # unknown to the narrowing pass.
+    ("org.springframework.util.ClassUtils", "getPackageName"): "String",
+    ("org.springframework.util.ClassUtils", "resolveClassName"): "Class",
+    # Spring's AOP helpers return a JDK Class even though their declarations
+    # live outside the analyzed source. Without this exact external contract,
+    # `var listenerType = AopUtils.getTargetClass(initializer)` leaves
+    # `listenerType` unknown and later overload calls fan out across
+    # `of(Class)`/`of(JavaClass)`-style siblings.
+    ("org.springframework.aop.support.AopUtils", "getTargetClass"): "Class",
+}
+# Batch 24: declared types of a small set of external (JDK) static
+# constants, FQN-keyed exactly like `JAVA_STATIC_METHOD_STUB_RETURNS` so a
+# source class that shares the simple name is never stubbed. Used only by
+# overload-argument narrowing (`_external_static_field_arg_type`):
+# `assertEquals(Integer.MAX_VALUE, parseFastForwardLimit(...))` fanned out
+# across every numeric `assertEquals` overload, and `LogRecordListener.stream
+# (Level.WARNING)` between `stream(Level)`/`stream(Class)`.
+# Simple names of the JDK `Throwable` family: a source exception class
+# extending any of these inherits `Throwable`'s members (JLS 8.4.8), so the
+# `("Throwable", member)` facts above apply to it when its own hierarchy
+# declares no member of that name.
+JAVA_THROWABLE_SIMPLE_TYPES: FrozenSet[str] = frozenset({
+    "Throwable", "Exception", "RuntimeException", "Error", "AssertionError",
+    "IllegalArgumentException", "IllegalStateException",
+    "UnsupportedOperationException", "NullPointerException",
+    "IndexOutOfBoundsException", "ArithmeticException", "ClassCastException",
+    "NumberFormatException", "SecurityException", "IOException",
+    "UncheckedIOException", "InterruptedException", "ExecutionException",
+    "TimeoutException", "ReflectiveOperationException",
+    "ClassNotFoundException", "NoSuchMethodException", "NoSuchFieldException",
+    "IllegalAccessException", "InstantiationException",
+    "InvocationTargetException", "CloneNotSupportedException", "LinkageError",
+})
+JAVA_STATIC_FIELD_STUB_TYPES: Dict[Tuple[str, str], str] = {
+    ("java.lang.Double", "MIN_NORMAL"): "double",
+    ("java.lang.Float", "MIN_NORMAL"): "float",
+    ("java.lang.Double", "MAX_EXPONENT"): "int",
+    ("java.lang.Double", "MIN_EXPONENT"): "int",
+    ("java.lang.Float", "MAX_EXPONENT"): "int",
+    ("java.lang.Float", "MIN_EXPONENT"): "int",
+    ("java.lang.Integer", "SIZE"): "int",
+    ("java.lang.Integer", "BYTES"): "int",
+    ("java.lang.Long", "SIZE"): "int",
+    ("java.lang.Long", "BYTES"): "int",
+    ("java.lang.Double", "SIZE"): "int",
+    ("java.lang.Double", "BYTES"): "int",
+    ("java.lang.Float", "SIZE"): "int",
+    ("java.lang.Float", "BYTES"): "int",
+    ("java.lang.Short", "SIZE"): "int",
+    ("java.lang.Byte", "SIZE"): "int",
+    ("java.lang.Character", "SIZE"): "int",
+    **{("java.lang.Integer", name): "int" for name in ("MAX_VALUE", "MIN_VALUE", "SIZE", "BYTES")},
+    **{("java.lang.Long", name): "long" for name in ("MAX_VALUE", "MIN_VALUE")},
+    **{("java.lang.Short", name): "short" for name in ("MAX_VALUE", "MIN_VALUE")},
+    **{("java.lang.Byte", name): "byte" for name in ("MAX_VALUE", "MIN_VALUE")},
+    **{("java.lang.Character", name): "char" for name in ("MAX_VALUE", "MIN_VALUE")},
+    **{("java.lang.Double", name): "double" for name in (
+        "MAX_VALUE", "MIN_VALUE", "NaN", "POSITIVE_INFINITY", "NEGATIVE_INFINITY",
+    )},
+    **{("java.lang.Float", name): "float" for name in (
+        "MAX_VALUE", "MIN_VALUE", "NaN", "POSITIVE_INFINITY", "NEGATIVE_INFINITY",
+    )},
+    ("java.lang.Boolean", "TRUE"): "Boolean",
+    ("java.lang.Boolean", "FALSE"): "Boolean",
+    **{("java.util.logging.Level", name): "java.util.logging.Level" for name in (
+        "OFF", "SEVERE", "WARNING", "INFO", "CONFIG", "FINE", "FINER", "FINEST", "ALL",
+    )},
+    **{("java.nio.charset.StandardCharsets", name): "java.nio.charset.Charset" for name in (
+        "UTF_8", "UTF_16", "UTF_16BE", "UTF_16LE", "US_ASCII", "ISO_8859_1",
+    )},
+    **{("java.util.concurrent.TimeUnit", name): "java.util.concurrent.TimeUnit" for name in (
+        "NANOSECONDS", "MICROSECONDS", "MILLISECONDS", "SECONDS", "MINUTES", "HOURS", "DAYS",
+    )},
+    **{("java.util.Locale", name): "java.util.Locale" for name in (
+        "ROOT", "ENGLISH", "US", "UK", "GERMAN", "GERMANY", "FRENCH", "FRANCE",
+    )},
+}
+# JLS 4.3.2: every class inherits these zero-argument `Object` members and an
+# override cannot change their erased return type, so the invocation result is
+# known for any receiver, even an unresolvable one.
+JAVA_OBJECT_MEMBER_RETURNS: Dict[str, str] = {
+    "toString": "String",
+    "hashCode": "int",
+    "getClass": "Class",
+}
+# `java.time`'s immutable value types are fluent builders: every `plus*`/
+# `minus*`/`with*` mutator and `truncatedTo` is JavaDoc-guaranteed to return
+# the exact same type as the receiver — not a guess, a fixed JDK contract —
+# yet none of it lives in analyzed source, so a chain like
+# `now().minusHours(1)` used to go unknown past the first hop and force an
+# otherwise-resolvable sibling-overload call into P4.4's ambiguous fan-out
+# (`Moments.everyHour()`'s `emitEventsFor(now().minusHours(1))` fanning out
+# to both `emitEventsFor(LocalDateTime)` and `emitEventsFor(LocalDate)`,
+# wrongly reaching `DayHasPassed.of` — spring-modulith benchmark finding).
+JAVA_TIME_TEMPORAL_TYPES: FrozenSet[str] = frozenset({
+    "LocalDate", "LocalDateTime", "LocalTime", "Instant", "ZonedDateTime",
+    "OffsetDateTime", "OffsetTime", "Duration", "Period", "Year", "YearMonth",
+    "MonthDay",
+})
+JAVA_TIME_SELF_RETURNING_PREFIXES: Tuple[str, ...] = ("plus", "minus", "with")
+JAVA_TIME_SELF_RETURNING_EXACT: FrozenSet[str] = frozenset({"truncatedTo"})
+# A handful of zero-arg, single-overload cross-type conversions with one
+# fixed JDK-declared return type. Deliberately excludes any method with a
+# same-name overload whose return type differs by arity or argument type
+# (`LocalDate.atStartOfDay()` -> LocalDateTime vs.
+# `atStartOfDay(ZoneId)` -> ZonedDateTime stays unresolved rather than
+# guessed at the wrong overload).
+JAVA_TIME_CONVERSION_RETURNS: Dict[Tuple[str, str], str] = {
+    ("LocalDateTime", "toLocalDate"): "LocalDate",
+    ("LocalDateTime", "toLocalTime"): "LocalTime",
+    ("ZonedDateTime", "toLocalDate"): "LocalDate",
+    ("ZonedDateTime", "toLocalDateTime"): "LocalDateTime",
+    ("ZonedDateTime", "toLocalTime"): "LocalTime",
+    ("ZonedDateTime", "toInstant"): "Instant",
+    ("OffsetDateTime", "toLocalDate"): "LocalDate",
+    ("OffsetDateTime", "toLocalDateTime"): "LocalDateTime",
+    ("OffsetDateTime", "toLocalTime"): "LocalTime",
+    ("OffsetDateTime", "toInstant"): "Instant",
+}
+# `BeanFactory.getBean(Class<T>)` (and its context/test-runner subtypes)
+# returns exactly the argument's own `Class<T>` literal type — documented
+# Spring Framework contract, not a guess — but none of these interfaces have
+# source in an analyzed project, so `ctxt.getBean(Foo.class)` used to leave
+# the call's result unknown even when `Foo` itself is a source class
+# (spring-modulith benchmark finding: `KafkaEventExternalizerConfiguration
+# IntegrationTests`'s `ctxt.getBean(DelegatingEventExternalizer.class)`
+# never resolved, hiding 3 real transitive callers behind it). Deliberately
+# excludes `getBean(String)`/`getBean(String, Class<T>)` string-named lookup
+# and multi-arg constructor-arg forms; only the exact single-`Class<T>`-
+# literal overload has one unambiguous, name-independent target.
+SPRING_BEAN_CONTAINER_TYPES: FrozenSet[str] = frozenset({
+    "BeanFactory", "ListableBeanFactory", "ConfigurableListableBeanFactory",
+    "ApplicationContext", "ConfigurableApplicationContext",
+    "WebApplicationContext", "ConfigurableWebApplicationContext",
+    "AssertableApplicationContext", "AssertableWebApplicationContext",
+    "AssertableReactiveWebApplicationContext",
+})
+# Spring Boot Test's `AbstractApplicationContextRunner.run(ContextConsumer<?
+# super A>)` target-types its lambda/method-reference argument's single
+# parameter as the runner's own fixed assertable-context type `A` — a
+# documented, non-generic-inferred contract per runner subclass (each
+# subclass hard-codes its own `A`), not a project fact. None of these
+# classes have source in an analyzed project, so a lambda passed to `.run`
+# used to leave its parameter's type completely unknown (see
+# `SPRING_BEAN_CONTAINER_TYPES` above for why that mattered here).
+SPRING_CONTEXT_RUNNER_ASSERTABLE_CONTEXT: Dict[str, str] = {
+    "ApplicationContextRunner": "AssertableApplicationContext",
+    "WebApplicationContextRunner": "AssertableWebApplicationContext",
+    "ReactiveWebApplicationContextRunner": "AssertableReactiveWebApplicationContext",
+}
+# SAM parameter tables for a small set of well-known *external*
+# (non-JDK) functional interfaces, kept deliberately separate from
+# `_JDK_SAM_PARAMS`/`_JDK_SAM_RETURNS` above so that table's "derivable
+# without indexing JDK sources" invariant stays exactly JDK-only.
+# `ContextConsumer<C>`'s single abstract method is
+# `void accept(C context) throws Throwable` (Spring Boot Test).
+EXTERNAL_SAM_PARAMS: Dict[str, Tuple[Union[int, str], ...]] = {
+    "ContextConsumer": (0,),
+}
+EXTERNAL_SAM_RETURNS: Dict[str, Union[int, str]] = {
+    "ContextConsumer": "void",
+}
+# Small, exact JDK hierarchy facts used only when both sides resolve through
+# their file's explicit import context. This is not a simple-name fallback:
+# a project-local `HashMap` never matches `java.util.HashMap` here.
+JAVA_EXTERNAL_SUBTYPE_STUBS: FrozenSet[Tuple[str, str]] = frozenset({
+    # Batch 25: the JDK types the new fixed-return facts and static
+    # factories can now put *into* an argument position (`Arrays.asList(..)`
+    # -> `List`, `EnumSet.of(..)`, `Stack`, reflection/concurrency
+    # receivers, `Throwable.getCause()`), each with the supertypes a
+    # declared parameter is commonly spelled as. A newly typed argument
+    # that cannot reach its parameter here is a dropped candidate (FN),
+    # not an unknown, so every producible type needs its ancestry listed.
+    ("java.util.List", "java.util.SequencedCollection"),
+    ("java.util.ArrayList", "java.lang.Iterable"),
+    ("java.util.LinkedList", "java.util.List"),
+    ("java.util.LinkedList", "java.util.Collection"),
+    ("java.util.LinkedList", "java.lang.Iterable"),
+    ("java.util.LinkedList", "java.util.Deque"),
+    ("java.util.LinkedList", "java.util.Queue"),
+    ("java.util.Stack", "java.util.Vector"),
+    ("java.util.Stack", "java.util.List"),
+    ("java.util.Stack", "java.util.Collection"),
+    ("java.util.Stack", "java.lang.Iterable"),
+    ("java.util.Vector", "java.util.List"),
+    ("java.util.Vector", "java.util.Collection"),
+    ("java.util.Vector", "java.lang.Iterable"),
+    ("java.util.HashSet", "java.util.Collection"),
+    ("java.util.HashSet", "java.lang.Iterable"),
+    ("java.util.LinkedHashSet", "java.util.Set"),
+    ("java.util.LinkedHashSet", "java.util.Collection"),
+    ("java.util.LinkedHashSet", "java.lang.Iterable"),
+    ("java.util.TreeSet", "java.util.Set"),
+    ("java.util.TreeSet", "java.util.SortedSet"),
+    ("java.util.TreeSet", "java.util.NavigableSet"),
+    ("java.util.TreeSet", "java.util.Collection"),
+    ("java.util.TreeSet", "java.lang.Iterable"),
+    ("java.util.SortedSet", "java.util.Set"),
+    ("java.util.SortedSet", "java.util.Collection"),
+    ("java.util.SortedSet", "java.lang.Iterable"),
+    ("java.util.EnumSet", "java.util.Set"),
+    ("java.util.EnumSet", "java.util.Collection"),
+    ("java.util.EnumSet", "java.lang.Iterable"),
+    ("java.util.ArrayDeque", "java.util.Collection"),
+    ("java.util.ArrayDeque", "java.lang.Iterable"),
+    ("java.util.Deque", "java.util.Queue"),
+    ("java.util.Deque", "java.util.Collection"),
+    ("java.util.Deque", "java.lang.Iterable"),
+    ("java.util.Queue", "java.util.Collection"),
+    ("java.util.Queue", "java.lang.Iterable"),
+    ("java.util.concurrent.ConcurrentHashMap", "java.util.Map"),
+    ("java.util.concurrent.ConcurrentHashMap", "java.util.concurrent.ConcurrentMap"),
+    ("java.util.concurrent.ConcurrentMap", "java.util.Map"),
+    ("java.util.regex.Matcher", "java.util.regex.MatchResult"),
+    ("java.util.concurrent.locks.ReentrantLock", "java.util.concurrent.locks.Lock"),
+    ("java.util.concurrent.ForkJoinPool", "java.util.concurrent.ExecutorService"),
+    ("java.util.concurrent.ForkJoinPool", "java.util.concurrent.Executor"),
+    ("java.util.concurrent.ThreadPoolExecutor", "java.util.concurrent.ExecutorService"),
+    ("java.util.concurrent.ThreadPoolExecutor", "java.util.concurrent.Executor"),
+    ("java.util.concurrent.ScheduledExecutorService", "java.util.concurrent.ExecutorService"),
+    ("java.util.concurrent.ScheduledExecutorService", "java.util.concurrent.Executor"),
+    ("java.util.concurrent.ExecutorService", "java.util.concurrent.Executor"),
+    ("java.util.concurrent.CompletableFuture", "java.util.concurrent.Future"),
+    ("java.util.concurrent.CompletableFuture", "java.util.concurrent.CompletionStage"),
+    ("java.lang.Thread", "java.lang.Runnable"),
+    ("java.lang.reflect.Method", "java.lang.reflect.Executable"),
+    ("java.lang.reflect.Method", "java.lang.reflect.AccessibleObject"),
+    ("java.lang.reflect.Method", "java.lang.reflect.Member"),
+    ("java.lang.reflect.Method", "java.lang.reflect.AnnotatedElement"),
+    ("java.lang.reflect.Constructor", "java.lang.reflect.Executable"),
+    ("java.lang.reflect.Constructor", "java.lang.reflect.AccessibleObject"),
+    ("java.lang.reflect.Constructor", "java.lang.reflect.Member"),
+    ("java.lang.reflect.Constructor", "java.lang.reflect.AnnotatedElement"),
+    ("java.lang.reflect.Executable", "java.lang.reflect.AccessibleObject"),
+    ("java.lang.reflect.Executable", "java.lang.reflect.Member"),
+    ("java.lang.reflect.Executable", "java.lang.reflect.AnnotatedElement"),
+    ("java.lang.reflect.Field", "java.lang.reflect.AccessibleObject"),
+    ("java.lang.reflect.Field", "java.lang.reflect.Member"),
+    ("java.lang.reflect.Field", "java.lang.reflect.AnnotatedElement"),
+    ("java.lang.reflect.Parameter", "java.lang.reflect.AnnotatedElement"),
+    ("java.lang.Class", "java.lang.reflect.AnnotatedElement"),
+    ("java.lang.Class", "java.lang.reflect.Type"),
+    ("java.lang.Class", "java.lang.reflect.GenericDeclaration"),
+    ("java.lang.Module", "java.lang.reflect.AnnotatedElement"),
+    ("java.io.File", "java.lang.Comparable"),
+    ("java.io.File", "java.io.Serializable"),
+    ("java.nio.file.Path", "java.lang.Comparable"),
+    ("java.nio.file.Path", "java.lang.Iterable"),
+    ("java.nio.file.Path", "java.nio.file.Watchable"),
+    ("java.lang.IllegalArgumentException", "java.lang.RuntimeException"),
+    ("java.lang.IllegalArgumentException", "java.lang.Exception"),
+    ("java.lang.IllegalArgumentException", "java.lang.Throwable"),
+    ("java.lang.IllegalStateException", "java.lang.RuntimeException"),
+    ("java.lang.IllegalStateException", "java.lang.Exception"),
+    ("java.lang.IllegalStateException", "java.lang.Throwable"),
+    ("java.lang.UnsupportedOperationException", "java.lang.RuntimeException"),
+    ("java.lang.UnsupportedOperationException", "java.lang.Exception"),
+    ("java.lang.UnsupportedOperationException", "java.lang.Throwable"),
+    ("java.io.IOException", "java.lang.Exception"),
+    ("java.io.UncheckedIOException", "java.lang.RuntimeException"),
+    ("java.io.UncheckedIOException", "java.lang.Exception"),
+    ("java.io.UncheckedIOException", "java.lang.Throwable"),
+    ("java.lang.InterruptedException", "java.lang.Exception"),
+    ("java.lang.InterruptedException", "java.lang.Throwable"),
+    ("java.util.concurrent.ExecutionException", "java.lang.Exception"),
+    ("java.util.concurrent.ExecutionException", "java.lang.Throwable"),
+    ("java.util.concurrent.TimeoutException", "java.lang.Exception"),
+    ("java.util.concurrent.TimeoutException", "java.lang.Throwable"),
+    ("java.lang.ReflectiveOperationException", "java.lang.Exception"),
+    ("java.lang.ReflectiveOperationException", "java.lang.Throwable"),
+    ("java.lang.ClassNotFoundException", "java.lang.ReflectiveOperationException"),
+    ("java.lang.ClassNotFoundException", "java.lang.Exception"),
+    ("java.lang.ClassNotFoundException", "java.lang.Throwable"),
+    ("java.lang.NoSuchMethodException", "java.lang.ReflectiveOperationException"),
+    ("java.lang.NoSuchMethodException", "java.lang.Exception"),
+    ("java.lang.NoSuchMethodException", "java.lang.Throwable"),
+    ("java.lang.reflect.InvocationTargetException", "java.lang.ReflectiveOperationException"),
+    ("java.lang.reflect.InvocationTargetException", "java.lang.Exception"),
+    ("java.lang.reflect.InvocationTargetException", "java.lang.Throwable"),
+    ("java.io.StringReader", "java.io.Reader"),
+    ("java.lang.String", "java.lang.CharSequence"),
+    ("java.util.ArrayList", "java.util.List"),
+    ("java.util.ArrayList", "java.util.Collection"),
+    ("java.util.ArrayDeque", "java.util.Deque"),
+    ("java.util.ArrayDeque", "java.util.Queue"),
+    ("java.util.HashMap", "java.util.Map"),
+    ("java.util.LinkedHashMap", "java.util.Map"),
+    ("java.util.TreeMap", "java.util.Map"),
+    ("java.util.HashSet", "java.util.Set"),
+    ("java.util.List", "java.util.Collection"),
+    ("java.util.List", "java.lang.Iterable"),
+    ("java.util.Set", "java.util.Collection"),
+    ("java.util.Set", "java.lang.Iterable"),
+    ("java.util.Collection", "java.lang.Iterable"),
+    ("java.util.concurrent.LinkedBlockingQueue", "java.util.concurrent.BlockingQueue"),
+    ("java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy", "java.util.concurrent.RejectedExecutionHandler"),
+    ("java.lang.Exception", "java.lang.Throwable"),
+    ("java.lang.RuntimeException", "java.lang.Throwable"),
+    ("java.lang.RuntimeException", "java.lang.Exception"),
+    ("java.lang.Error", "java.lang.Throwable"),
+    ("java.lang.LinkageError", "java.lang.Error"),
+    ("java.lang.LinkageError", "java.lang.Throwable"),
+    ("java.lang.AssertionError", "java.lang.Error"),
+    ("java.lang.AssertionError", "java.lang.Throwable"),
+    ("java.lang.NullPointerException", "java.lang.RuntimeException"),
+    ("java.lang.NullPointerException", "java.lang.Exception"),
+    ("java.lang.NullPointerException", "java.lang.Throwable"),
+    ("java.io.IOException", "java.lang.Throwable"),
+    ("java.io.UnsupportedEncodingException", "java.io.IOException"),
+    ("java.io.UnsupportedEncodingException", "java.lang.Throwable"),
+    ("java.lang.CloneNotSupportedException", "java.lang.Exception"),
+    ("java.lang.CloneNotSupportedException", "java.lang.Throwable"),
+    ("java.lang.IllegalAccessException", "java.lang.Throwable"),
+    ("java.lang.InterruptedException", "java.lang.Throwable"),
+    ("java.net.URISyntaxException", "java.lang.Throwable"),
+    ("java.lang.Class", "java.lang.reflect.AnnotatedElement"),
+    ("java.lang.reflect.Constructor", "java.lang.reflect.AnnotatedElement"),
+    ("java.lang.reflect.Constructor", "java.lang.reflect.Member"),
+    # JDK reflection hierarchy: both Method and Constructor extend
+    # Executable. This lets an exactly typed Method select a source overload
+    # declared against Executable without treating unrelated Member values as
+    # executable.
+    ("java.lang.reflect.Constructor", "java.lang.reflect.Executable"),
+    ("java.lang.reflect.Executable", "java.lang.reflect.AnnotatedElement"),
+    ("java.lang.reflect.Field", "java.lang.reflect.AnnotatedElement"),
+    ("java.lang.reflect.Field", "java.lang.reflect.Member"),
+    ("java.lang.reflect.Method", "java.lang.reflect.AnnotatedElement"),
+    ("java.lang.reflect.Method", "java.lang.reflect.Member"),
+    ("java.lang.reflect.Method", "java.lang.reflect.Executable"),
+})
+JAVA_EXTERNAL_TYPES = frozenset(name for relation in JAVA_EXTERNAL_SUBTYPE_STUBS for name in relation)
+# Concrete `java_type_kind`s that can carry a runtime method body — the only
+# ones eligible to be a fan-out/DI target (an `interface`/`abstract class`
+# receiver is the *source* of the ambiguity, never a resolved target).
+_CONCRETE_TYPE_KINDS: FrozenSet[str] = frozenset({"class", "record", "enum"})
+
+# Precision↔recall dial (deep-dive §6.3), mirroring P2.21's `DRIFT_RECALL_MODE`.
+# `strict` keeps only the interface-declaration edge (P4.4's own result);
+# `balanced` (default, precision-first) fans out to concrete implementors but
+# caps emission above `_FANOUT_CAP` to avoid flooding; `recall` fans out to
+# every implementor as a low-confidence candidate regardless of count.
+_FANOUT_MODES = ("strict", "balanced", "recall")
+_DEFAULT_FANOUT_MODE = "balanced"
+_DEFAULT_FANOUT_CAP = 5
+
+# Per-edge confidence for each fan-out/DI strategy — the evidence table in
+# codegraph-java-deep-dive.md §6.3 / PROBLEMS.md P4.12. A single implementor is
+# effectively concrete (High band); many implementors are honest ambiguity
+# (Low band, <0.6). DI evidence tightens the score toward concrete.
+_CONF_SINGLE_IMPLEMENTOR = 0.85
+_CONF_MULTI_IMPLEMENTOR = 0.45
+_CONF_DI_SINGLE_COMPONENT = 0.85
+_CONF_SPRING_QUALIFIER = 0.95
+_CONF_SPRING_PRIMARY = 0.90
+
+
+# Matches the first string literal argument of an annotation, e.g.
+# `@Qualifier("stripe")` -> `stripe`, `@Service("fastPayment")` -> `fastPayment`.
+_ANNOTATION_STRING_ARG = re.compile(r'"((?:[^"\\]|\\.)*)"')