gitnexus 1.6.8-rc.2 → 1.6.8-rc.21

package/dist/core/ingestion/route-extractors/spring-shared.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Shared Spring route-annotation primitives.
+ *
+ * These are the low-level building blocks the two Spring route extractors —
+ * the ingestion-layer `route-extractors/spring.ts` (produces graph `Route`
+ * nodes) and the group-layer `group/extractors/http-patterns/java.ts`
+ * (produces cross-repo HTTP contracts) — would otherwise each maintain
+ * independently. Centralising the annotation→method map, the enclosing-class
+ * lookup, and the route-key filter keeps those semantics in one place so the
+ * two extractors can't drift apart.
+ *
+ * This module lives in `ingestion/` (the lower layer); the group layer imports
+ * from it, matching the existing `group → ingestion` dependency direction
+ * (e.g. `group/extractors/include-extractor.ts` already imports
+ * `ingestion/import-resolvers/utils.ts`). It MUST NOT import anything from
+ * `group/` to avoid a dependency cycle.
+ */
+import type Parser from 'tree-sitter';
+/**
+ * Spring shortcut method-annotation → HTTP verb.
+ *
+ * `@RequestMapping` is intentionally absent: on a method it carries no implicit
+ * verb (the verb lives in its `method = RequestMethod.X` attribute), and on a
+ * class it is a URL prefix rather than a route. Callers handle `@RequestMapping`
+ * separately.
+ */
+export declare const METHOD_ANNOTATION_TO_HTTP: Record<string, string>;
+/**
+ * A named annotation argument contributes a route only when its member key is
+ * `path` or `value`; a positional argument (no key node) always qualifies.
+ * Drops Spring's non-route string attributes (`produces`, `consumes`,
+ * `headers`, `name`, `params`) that would otherwise be mis-read as routes.
+ */
+export declare function isRouteMemberKey(keyNode: Parser.SyntaxNode | undefined): boolean;
+/**
+ * Find the nearest enclosing `class_declaration` ancestor for a node, or null
+ * if the node is top-level. Tree-sitter's `SyntaxNode.parent` walks one level
+ * at a time.
+ */
+export declare function findEnclosingClass(node: Parser.SyntaxNode): Parser.SyntaxNode | null;
+/**
+ * Strip enclosing quotes from a tree-sitter string-literal node's text.
+ * Handles single / double / template (backtick) quotes and triple-quoted
+ * strings. Mirrors the safer semantics of the group layer's `unquoteLiteral`:
+ * returns `null` for empty / nullish input so callers can uniformly skip
+ * captures whose value is missing, and returns the text unchanged when it
+ * carries no recognisable surrounding quotes (some grammars expose string
+ * content without quotes already).
+ */
+export declare function unquoteSpringLiteral(raw: string): string | null;

package/dist/core/ingestion/route-extractors/spring-shared.js

@@ -0,0 +1,80 @@
+/**
+ * Shared Spring route-annotation primitives.
+ *
+ * These are the low-level building blocks the two Spring route extractors —
+ * the ingestion-layer `route-extractors/spring.ts` (produces graph `Route`
+ * nodes) and the group-layer `group/extractors/http-patterns/java.ts`
+ * (produces cross-repo HTTP contracts) — would otherwise each maintain
+ * independently. Centralising the annotation→method map, the enclosing-class
+ * lookup, and the route-key filter keeps those semantics in one place so the
+ * two extractors can't drift apart.
+ *
+ * This module lives in `ingestion/` (the lower layer); the group layer imports
+ * from it, matching the existing `group → ingestion` dependency direction
+ * (e.g. `group/extractors/include-extractor.ts` already imports
+ * `ingestion/import-resolvers/utils.ts`). It MUST NOT import anything from
+ * `group/` to avoid a dependency cycle.
+ */
+/**
+ * Spring shortcut method-annotation → HTTP verb.
+ *
+ * `@RequestMapping` is intentionally absent: on a method it carries no implicit
+ * verb (the verb lives in its `method = RequestMethod.X` attribute), and on a
+ * class it is a URL prefix rather than a route. Callers handle `@RequestMapping`
+ * separately.
+ */
+export const METHOD_ANNOTATION_TO_HTTP = {
+    GetMapping: 'GET',
+    PostMapping: 'POST',
+    PutMapping: 'PUT',
+    DeleteMapping: 'DELETE',
+    PatchMapping: 'PATCH',
+};
+/**
+ * A named annotation argument contributes a route only when its member key is
+ * `path` or `value`; a positional argument (no key node) always qualifies.
+ * Drops Spring's non-route string attributes (`produces`, `consumes`,
+ * `headers`, `name`, `params`) that would otherwise be mis-read as routes.
+ */
+export function isRouteMemberKey(keyNode) {
+    if (!keyNode)
+        return true;
+    return keyNode.text === 'path' || keyNode.text === 'value';
+}
+/**
+ * Find the nearest enclosing `class_declaration` ancestor for a node, or null
+ * if the node is top-level. Tree-sitter's `SyntaxNode.parent` walks one level
+ * at a time.
+ */
+export function findEnclosingClass(node) {
+    let cur = node.parent;
+    while (cur) {
+        if (cur.type === 'class_declaration')
+            return cur;
+        cur = cur.parent;
+    }
+    return null;
+}
+/**
+ * Strip enclosing quotes from a tree-sitter string-literal node's text.
+ * Handles single / double / template (backtick) quotes and triple-quoted
+ * strings. Mirrors the safer semantics of the group layer's `unquoteLiteral`:
+ * returns `null` for empty / nullish input so callers can uniformly skip
+ * captures whose value is missing, and returns the text unchanged when it
+ * carries no recognisable surrounding quotes (some grammars expose string
+ * content without quotes already).
+ */
+export function unquoteSpringLiteral(raw) {
+    if (!raw)
+        return null;
+    if ((raw.startsWith('"""') && raw.endsWith('"""')) ||
+        (raw.startsWith("'''") && raw.endsWith("'''"))) {
+        return raw.slice(3, -3);
+    }
+    const first = raw[0];
+    const last = raw[raw.length - 1];
+    if ((first === '"' || first === "'" || first === '`') && last === first && raw.length >= 2) {
+        return raw.slice(1, -1);
+    }
+    return raw;
+}

package/dist/core/ingestion/route-extractors/spring.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Spring route annotation extractor for the ingestion pipeline.
+ *
+ * Extracts `@GetMapping`, `@PostMapping`, `@PutMapping`, `@DeleteMapping`,
+ * `@PatchMapping`, and `@RequestMapping` annotations from Java source files
+ * and returns `ExtractedDecoratorRoute[]` with class-level `@RequestMapping`
+ * prefixes already resolved per-class.
+ *
+ * This module is the ingestion-layer counterpart of
+ * `group/extractors/http-patterns/java.ts` (which extracts HTTP contracts
+ * for cross-repo matching). It uses the same tree-sitter capture approach:
+ * a single predicate-free query matches all route annotations generically,
+ * then a for-loop discriminates class-level prefixes from method-level routes
+ * by reading `@node.type` and the annotation name.
+ *
+ * The query is predicate-free to avoid the tree-sitter 0.21.x hazard where
+ * `#match?` / `#eq?` predicates in a top-level `[...]` alternation silently
+ * drop sibling-branch matches (see group-layer `JAVA_ROUTE_ANNOTATION_PATTERNS`
+ * header comment for details).
+ */
+import Parser from 'tree-sitter';
+import type { ExtractedDecoratorRoute } from '../workers/parse-worker.js';
+/**
+ * Extract Spring route annotations from a parsed Java file.
+ *
+ * Uses a single tree-sitter query pass to capture all annotations, then
+ * discriminates class-level prefixes from method-level routes in a loop.
+ * Handles multiple classes per file, each with its own prefix.
+ *
+ * @param tree - tree-sitter parse tree
+ * @param filePath - relative file path (for `ExtractedDecoratorRoute.filePath`)
+ * @param lineOffset - line offset for pre-processing (usually 0)
+ * @returns Decorator routes with prefix already set per-class
+ */
+export declare function extractSpringRoutes(tree: Parser.Tree, filePath: string, lineOffset?: number): ExtractedDecoratorRoute[];

package/dist/core/ingestion/route-extractors/spring.js

@@ -0,0 +1,136 @@
+/**
+ * Spring route annotation extractor for the ingestion pipeline.
+ *
+ * Extracts `@GetMapping`, `@PostMapping`, `@PutMapping`, `@DeleteMapping`,
+ * `@PatchMapping`, and `@RequestMapping` annotations from Java source files
+ * and returns `ExtractedDecoratorRoute[]` with class-level `@RequestMapping`
+ * prefixes already resolved per-class.
+ *
+ * This module is the ingestion-layer counterpart of
+ * `group/extractors/http-patterns/java.ts` (which extracts HTTP contracts
+ * for cross-repo matching). It uses the same tree-sitter capture approach:
+ * a single predicate-free query matches all route annotations generically,
+ * then a for-loop discriminates class-level prefixes from method-level routes
+ * by reading `@node.type` and the annotation name.
+ *
+ * The query is predicate-free to avoid the tree-sitter 0.21.x hazard where
+ * `#match?` / `#eq?` predicates in a top-level `[...]` alternation silently
+ * drop sibling-branch matches (see group-layer `JAVA_ROUTE_ANNOTATION_PATTERNS`
+ * header comment for details).
+ */
+import Parser from 'tree-sitter';
+import Java from 'tree-sitter-java';
+import { METHOD_ANNOTATION_TO_HTTP, isRouteMemberKey, findEnclosingClass, unquoteSpringLiteral, } from './spring-shared.js';
+/**
+ * Single predicate-free tree-sitter query that captures all route annotations
+ * on classes and methods. Discrimination by annotation name and node type
+ * happens in the loop below.
+ *
+ * Captures:
+ *   @ann   → annotation name identifier (RequestMapping, GetMapping, etc.)
+ *   @node  → enclosing declaration (class_declaration | method_declaration)
+ *   @value → the string-literal argument
+ *   @key   → the named-argument member key (absent for positional form)
+ */
+const ROUTE_ANNOTATION_QUERY = new Parser.Query(Java, `
+  [
+    (class_declaration
+      (modifiers
+        (annotation
+          name: (identifier) @ann
+          arguments: (annotation_argument_list (string_literal) @value)))) @node
+    (class_declaration
+      (modifiers
+        (annotation
+          name: (identifier) @ann
+          arguments: (annotation_argument_list
+            (element_value_pair
+              key: (identifier) @key
+              value: (string_literal) @value))))) @node
+    (method_declaration
+      (modifiers
+        (annotation
+          name: (identifier) @ann
+          arguments: (annotation_argument_list (string_literal) @value)))) @node
+    (method_declaration
+      (modifiers
+        (annotation
+          name: (identifier) @ann
+          arguments: (annotation_argument_list
+            (element_value_pair
+              key: (identifier) @key
+              value: (string_literal) @value))))) @node
+  ]
+`);
+/**
+ * Extract Spring route annotations from a parsed Java file.
+ *
+ * Uses a single tree-sitter query pass to capture all annotations, then
+ * discriminates class-level prefixes from method-level routes in a loop.
+ * Handles multiple classes per file, each with its own prefix.
+ *
+ * @param tree - tree-sitter parse tree
+ * @param filePath - relative file path (for `ExtractedDecoratorRoute.filePath`)
+ * @param lineOffset - line offset for pre-processing (usually 0)
+ * @returns Decorator routes with prefix already set per-class
+ */
+export function extractSpringRoutes(tree, filePath, lineOffset = 0) {
+    const matches = ROUTE_ANNOTATION_QUERY.matches(tree.rootNode);
+    // Phase 1: collect class-level @RequestMapping prefixes keyed by node id
+    const prefixByClassId = new Map();
+    for (const match of matches) {
+        const caps = {};
+        for (const { name, node } of match.captures) {
+            caps[name] = node;
+        }
+        const annNode = caps['ann'];
+        const node = caps['node'];
+        const valueNode = caps['value'];
+        const keyNode = caps['key'];
+        if (!annNode || !node || !valueNode)
+            continue;
+        if (node.type === 'class_declaration' && annNode.text === 'RequestMapping') {
+            if (!isRouteMemberKey(keyNode))
+                continue;
+            const prefix = unquoteSpringLiteral(valueNode.text);
+            if (prefix !== null)
+                prefixByClassId.set(node.id, prefix);
+        }
+    }
+    // Phase 2: collect method-level routes and resolve their class prefix
+    const routes = [];
+    for (const match of matches) {
+        const caps = {};
+        for (const { name, node } of match.captures) {
+            caps[name] = node;
+        }
+        const annNode = caps['ann'];
+        const node = caps['node'];
+        const valueNode = caps['value'];
+        const keyNode = caps['key'];
+        if (!annNode || !node || !valueNode)
+            continue;
+        if (node.type !== 'method_declaration')
+            continue;
+        const ann = annNode.text;
+        const httpMethod = METHOD_ANNOTATION_TO_HTTP[ann];
+        if (!httpMethod)
+            continue; // skip @RequestMapping on methods (ambiguous verb)
+        if (!isRouteMemberKey(keyNode))
+            continue;
+        const routePath = unquoteSpringLiteral(valueNode.text);
+        if (routePath === null)
+            continue;
+        const enclosingClass = findEnclosingClass(node);
+        const classPrefix = enclosingClass ? (prefixByClassId.get(enclosingClass.id) ?? '') : '';
+        routes.push({
+            filePath,
+            routePath,
+            httpMethod,
+            decoratorName: ann,
+            lineNumber: annNode.startPosition.row + lineOffset,
+            ...(classPrefix ? { prefix: classPrefix } : {}),
+        });
+    }
+    return routes;
+}

package/dist/core/ingestion/scope-extractor.js

@@ -399,6 +399,7 @@ function buildDefFromDeclarationMatch(match, anchor, filePath) {
     const returnType = match['@declaration.return-type']?.text;
     const templateConstraints = parseJsonCapture(match['@declaration.template-constraints']);
     const isExplicit = parseBooleanCapture(match['@declaration.is-explicit']);
+    const isDeleted = parseBooleanCapture(match['@declaration.is-deleted']);
     return {
         nodeId: makeDefId(filePath, anchor.range, type, nameCap.text),
         filePath,
@@ -413,6 +414,7 @@ function buildDefFromDeclarationMatch(match, anchor, filePath) {
         ...(templateArguments !== undefined ? { templateArguments } : {}),
         ...(templateConstraints !== undefined ? { templateConstraints } : {}),
         ...(isExplicit === true ? { isExplicit: true } : {}),
+        ...(isDeleted === true ? { isDeleted: true } : {}),
     };
 }
 /** Parse an opaque JSON payload synthesized by per-language captures
@@ -922,6 +924,7 @@ const KNOWN_SUB_TAGS = new Set([
     '@declaration.return-type',
     '@declaration.template-constraints',
     '@declaration.is-explicit',
+    '@declaration.is-deleted',
 ]);
 /**
  * Return the anchor capture for a match — the one whose name begins with

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.js

@@ -289,6 +289,18 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             }
             if (fnDef === undefined)
                 continue;
+            if (fnDef.isDeleted === true) {
+                recordSuppressedOutcome(options.recordResolutionOutcome, {
+                    phase: 'free-call-fallback',
+                    filePath: parsed.filePath,
+                    name: site.name,
+                    range: site.atRange,
+                    reason: 'selected-callable-deleted',
+                    candidates: [fnDef],
+                });
+                handledSites.add(siteKey(parsed.filePath, site));
+                continue;
+            }
             if ((fnDefFromImplicitThis || fnDef.type === 'Method' || fnDef.type === 'Constructor') &&
                 options.isCallableVisibleFromCaller !== undefined &&
                 !options.isCallableVisibleFromCaller({

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.js

@@ -138,9 +138,12 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
             return 0;
         let n = 0;
         for (const implDef of impls) {
-            const implMember = findOwnedMember(implDef.nodeId, memberName, model);
-            if (implMember === undefined)
+            const implMember = pickOverload(implDef.nodeId, memberName, site, model, provider);
+            if (implMember === undefined ||
+                implMember === OVERLOAD_AMBIGUOUS ||
+                implMember.isDeleted === true) {
                 continue;
+            }
             if (implMember.nodeId === primaryMemberDef.nodeId)
                 continue;
             const ok = tryEmitEdge(graph, scopes, nodeLookup, site, implMember, 'interface-dispatch', seen, confidence, collapse);
@@ -179,12 +182,30 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                         ? extendsOnly(enclosingClass.nodeId)
                         : scopes.methodDispatch.mroFor(enclosingClass.nodeId);
                     let memberDef;
+                    let ambiguousOwnerId;
                     for (const ownerId of ancestors) {
-                        memberDef = findOwnedMember(ownerId, memberName, model);
-                        if (memberDef !== undefined)
+                        const picked = site.kind === 'call'
+                            ? pickOverload(ownerId, memberName, site, model, provider)
+                            : findOwnedMember(ownerId, memberName, model);
+                        if (picked === OVERLOAD_AMBIGUOUS) {
+                            ambiguousOwnerId = ownerId;
+                            break;
+                        }
+                        if (picked !== undefined) {
+                            memberDef = picked;
                             break;
+                        }
+                    }
+                    if (ambiguousOwnerId !== undefined) {
+                        recordReceiverOverloadSuppression(options.recordResolutionOutcome, parsed.filePath, site, ambiguousOwnerId, memberName, model, provider);
+                        handledSites.add(siteKey);
+                        continue;
                     }
                     if (memberDef !== undefined) {
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
                         // Super/base calls resolve through the MRO chain, not
                         // through imports — the ancestor method is found by
                         // walking `methodDispatch.mroFor(enclosingClass)`, which
@@ -219,9 +240,9 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                 if (currentClass !== undefined) {
                     const chain = [currentClass.nodeId, ...scopes.methodDispatch.mroFor(currentClass.nodeId)];
                     let memberDef;
+                    let ambiguousOwnerId;
                     // Static-only filter (#1756 / U3): same shape as Case 4's
-                    // chain walk (skip-and-walk-on) but without overload
-                    // narrowing — Case 0 uses `findOwnedMember` directly. When
+                    // overload-aware chain walk (skip-and-walk-on). When
                     // an owner's resolved candidate is static-only (Kotlin
                     // companion-promoted), continue to the next ancestor in
                     // the MRO chain so a legitimate instance member can bind.
@@ -233,17 +254,29 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     // shapes like `Logger.create("a")`), so there's no wrong
                     // target to suppress.
                     for (const ownerId of chain) {
-                        const candidate = findOwnedMember(ownerId, memberName, model);
-                        if (candidate === undefined)
-                            continue;
-                        if (provider.isStaticOnly?.(candidate) === true) {
-                            // Skip static-only candidate; walk to next ancestor.
+                        const picked = site.kind === 'call'
+                            ? pickFirstNonStaticOnly(ownerId, memberName, site, model, provider)
+                            : findOwnedMember(ownerId, memberName, model);
+                        if (picked === OVERLOAD_AMBIGUOUS) {
+                            ambiguousOwnerId = ownerId;
+                            break;
+                        }
+                        if (picked === STATIC_ONLY_FILTERED || picked === undefined) {
                             continue;
                         }
-                        memberDef = candidate;
+                        memberDef = picked;
                         break;
                     }
+                    if (ambiguousOwnerId !== undefined) {
+                        recordReceiverOverloadSuppression(options.recordResolutionOutcome, parsed.filePath, site, ambiguousOwnerId, memberName, model, provider);
+                        handledSites.add(siteKey);
+                        continue;
+                    }
                     if (memberDef !== undefined) {
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
                         const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse);
                         if (ok)
                             emitted++;
@@ -290,6 +323,10 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     }
                     if (languageResolution?.kind === 'resolved') {
                         const memberDef = languageResolution.definition;
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
                         const reason = site.kind === 'write' || site.kind === 'read'
                             ? site.kind
                             : memberDef.filePath !== parsed.filePath
@@ -357,6 +394,10 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                         continue;
                     }
                     if (memberDef !== undefined) {
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
                         const reason = site.kind === 'write' || site.kind === 'read'
                             ? site.kind
                             : memberDef.filePath !== parsed.filePath
@@ -373,11 +414,16 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
             }
             // ── Case 1: namespace receiver ───────────────────────────────
             const targetFiles = namespaceTargets.get(receiverName);
-            if (targetFiles !== undefined) {
+            if (targetFiles !== undefined && provider.resolveQualifiedReceiverMember === undefined) {
                 let found = false;
                 for (const targetFile of targetFiles) {
                     const memberDef = findExportedDef(targetFile, memberName, index);
                     if (memberDef !== undefined) {
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            found = true;
+                            break;
+                        }
                         const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse);
                         if (ok)
                             emitted++;
@@ -413,6 +459,10 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     continue;
                 }
                 if (memberDef !== undefined) {
+                    if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                        handledSites.add(siteKey);
+                        continue;
+                    }
                     const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse);
                     if (ok)
                         emitted++;
@@ -425,9 +475,17 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
             if (classDef !== undefined) {
                 const chain = [classDef.nodeId, ...scopes.methodDispatch.mroFor(classDef.nodeId)];
                 let memberDef;
+                let ambiguousOwnerId;
                 for (const ownerId of chain) {
-                    memberDef = findOwnedMember(ownerId, memberName, model);
-                    if (memberDef !== undefined) {
+                    const picked = site.kind === 'call'
+                        ? pickOverload(ownerId, memberName, site, model, provider)
+                        : findOwnedMember(ownerId, memberName, model);
+                    if (picked === OVERLOAD_AMBIGUOUS) {
+                        ambiguousOwnerId = ownerId;
+                        break;
+                    }
+                    if (picked !== undefined) {
+                        memberDef = picked;
                         // The MRO chain is most-derived-first ([classDef, ...ancestors]).
                         // If the most-derived definition is arity-incompatible with the
                         // call site, PHP throws ArgumentCountError at runtime — it does
@@ -441,7 +499,16 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                         break;
                     }
                 }
+                if (ambiguousOwnerId !== undefined) {
+                    recordReceiverOverloadSuppression(options.recordResolutionOutcome, parsed.filePath, site, ambiguousOwnerId, memberName, model, provider);
+                    handledSites.add(siteKey);
+                    continue;
+                }
                 if (memberDef !== undefined) {
+                    if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                        handledSites.add(siteKey);
+                        continue;
+                    }
                     const reason = site.kind === 'write' || site.kind === 'read'
                         ? site.kind
                         : memberDef.filePath !== parsed.filePath
@@ -466,8 +533,22 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     for (const targetFile3 of targetFiles3) {
                         const classDef3 = findExportedDef(targetFile3, className, index);
                         if (classDef3 !== undefined) {
-                            const memberDef = findOwnedMember(classDef3.nodeId, memberName, model);
-                            if (memberDef !== undefined) {
+                            const picked = site.kind === 'call'
+                                ? pickOverload(classDef3.nodeId, memberName, site, model, provider)
+                                : findOwnedMember(classDef3.nodeId, memberName, model);
+                            if (picked === OVERLOAD_AMBIGUOUS) {
+                                recordReceiverOverloadSuppression(options.recordResolutionOutcome, parsed.filePath, site, classDef3.nodeId, memberName, model, provider);
+                                handledSites.add(siteKey);
+                                found3 = true;
+                                break;
+                            }
+                            if (picked !== undefined) {
+                                const memberDef = picked;
+                                if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                                    handledSites.add(siteKey);
+                                    found3 = true;
+                                    break;
+                                }
                                 const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen);
                                 if (ok) {
                                     emitted++;
@@ -504,8 +585,9 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                 if (ownerDef !== undefined) {
                     const chain = [ownerDef.nodeId, ...scopes.methodDispatch.mroFor(ownerDef.nodeId)];
                     let memberDef;
-                    // Static-only filter (#1756 / U3): mirrors Case 0's chain
-                    // walk — `findOwnedMember` without overload narrowing. When
+                    let ambiguousOwnerId;
+                    // Static-only filter (#1756 / U3): mirrors Case 0's
+                    // overload-aware chain walk. When
                     // a static-only candidate is found at an ancestor, walk on
                     // so a legitimate instance member can bind. If the entire
                     // chain is static-only, no edge is emitted (Case 3b is fed
@@ -513,16 +595,29 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     // `emitReferencesViaLookup` for compound shapes, so no
                     // handled-site marker is needed for chain-only-static).
                     for (const ownerId of chain) {
-                        const candidate = findOwnedMember(ownerId, memberName, model);
-                        if (candidate === undefined)
-                            continue;
-                        if (provider.isStaticOnly?.(candidate) === true) {
+                        const picked = site.kind === 'call'
+                            ? pickFirstNonStaticOnly(ownerId, memberName, site, model, provider)
+                            : findOwnedMember(ownerId, memberName, model);
+                        if (picked === OVERLOAD_AMBIGUOUS) {
+                            ambiguousOwnerId = ownerId;
+                            break;
+                        }
+                        if (picked === STATIC_ONLY_FILTERED || picked === undefined) {
                             continue;
                         }
-                        memberDef = candidate;
+                        memberDef = picked;
                         break;
                     }
+                    if (ambiguousOwnerId !== undefined) {
+                        recordReceiverOverloadSuppression(options.recordResolutionOutcome, parsed.filePath, site, ambiguousOwnerId, memberName, model, provider);
+                        handledSites.add(siteKey);
+                        continue;
+                    }
                     if (memberDef !== undefined) {
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
                         const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse);
                         if (ok)
                             emitted++;
@@ -574,6 +669,10 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     }
                     if (languageResolution?.kind === 'resolved') {
                         const memberDef = languageResolution.definition;
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
                         const reason = site.kind === 'write' || site.kind === 'read'
                             ? site.kind
                             : memberDef.filePath !== parsed.filePath
@@ -657,6 +756,10 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                         continue;
                     }
                     if (memberDef !== undefined) {
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
                         // For read/write ACCESSES, mirror the legacy DAG's reason
                         // convention so consumers asserting `reason === 'write'`
                         // keep working.
@@ -713,6 +816,10 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     continue;
                 }
                 if (picked !== undefined) {
+                    if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, picked)) {
+                        handledSites.add(siteKey);
+                        continue;
+                    }
                     // Static-only filter (#1756 / U3): unlike Case 4 there's no
                     // MRO chain to walk here — Case 5 dispatches on a single
                     // owner via `pickOverload`. When the picked candidate is
@@ -873,6 +980,20 @@ function pickFirstNonStaticOnly(ownerId, memberName, site, model, provider) {
         return OVERLOAD_AMBIGUOUS;
     return candidates[0] ?? overloads[0];
 }
+function suppressDeletedCallTarget(record, filePath, site, target) {
+    if (site.kind !== 'call' || target.isDeleted !== true)
+        return false;
+    record?.({
+        kind: 'suppressed',
+        phase: 'receiver-bound-calls',
+        filePath,
+        name: site.name,
+        range: site.atRange,
+        reason: 'selected-callable-deleted',
+        candidateIds: [target.nodeId],
+    });
+    return true;
+}
 function recordReceiverOverloadSuppression(record, filePath, site, ownerId, memberName, model, provider) {
     if (record === undefined)
         return;