gitnexus 1.4.10 → 1.5.1

package/dist/core/ingestion/call-processor.js

@@ -3,12 +3,13 @@ import { TIER_CONFIDENCE } from './resolution-context.js';
 import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
 import { getProvider } from './languages/index.js';
 import { generateId } from '../../lib/utils.js';
-import { getLanguageFromFilename } from './utils/language-detection.js';
+import { getLanguageFromFilename } from 'gitnexus-shared';
 import { isVerboseIngestionEnabled } from './utils/verbose.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
-import { FUNCTION_NODE_TYPES, extractFunctionName, findEnclosingClassId } from './utils/ast-helpers.js';
-import { countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, extractMixedChain, } from './utils/call-analysis.js';
+import { FUNCTION_NODE_TYPES, extractFunctionName, findEnclosingClassId, } from './utils/ast-helpers.js';
+import { countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, extractMixedChain, extractCallArgTypes, } from './utils/call-analysis.js';
 import { buildTypeEnv, isSubclassOf } from './type-env.js';
+import { resolveExtendsType } from './heritage-processor.js';
 import { getTreeSitterBufferSize } from './constants.js';
 import { normalizeFetchURL, routeMatches } from './route-extractors/nextjs.js';
 import { extractReturnTypeName, stripNullable } from './type-extractors/shared.js';
@@ -75,7 +76,7 @@ function collectExportedBindings(typeEnv, filePath, symbolTable, graph) {
  *  exported symbols that have callables with known return types. */
 export function buildExportedTypeMapFromGraph(graph, symbolTable) {
     const result = new Map();
-    graph.forEachNode(node => {
+    graph.forEachNode((node) => {
         if (!node.properties?.isExported)
             return;
         if (!node.properties?.filePath || !node.properties?.name)
@@ -141,8 +142,17 @@ export function seedCrossFileReceiverTypes(calls, namedImportMap, exportedTypeMa
 // strips nullable wrappers (Option<User> → User), these chain steps are no-ops
 // for type resolution — the current type passes through unchanged.
 const TYPE_PRESERVING_METHODS = new Set([
-    'unwrap', 'expect', 'unwrap_or', 'unwrap_or_default', 'unwrap_or_else', // Rust Option/Result
-    'clone', 'to_owned', 'as_ref', 'as_mut', 'borrow', 'borrow_mut', // Rust clone/borrow
+    'unwrap',
+    'expect',
+    'unwrap_or',
+    'unwrap_or_default',
+    'unwrap_or_else', // Rust Option/Result
+    'clone',
+    'to_owned',
+    'as_ref',
+    'as_mut',
+    'borrow',
+    'borrow_mut', // Rust clone/borrow
     'get', // Kotlin/Java Optional.get()
     'orElseThrow', // Java Optional
 ]);
@@ -201,18 +211,18 @@ const verifyConstructorBindings = (bindings, filePath, ctx, graph) => {
     const verified = new Map();
     for (const { scope, varName, calleeName, receiverClassName } of bindings) {
         const tiered = ctx.resolve(calleeName, filePath);
-        const isClass = tiered?.candidates.some(def => def.type === 'Class') ?? false;
+        const isClass = tiered?.candidates.some((def) => def.type === 'Class') ?? false;
         if (isClass) {
             verified.set(receiverKey(scope, varName), calleeName);
         }
         else {
-            let callableDefs = tiered?.candidates.filter(d => d.type === 'Function' || d.type === 'Method');
+            let callableDefs = tiered?.candidates.filter((d) => d.type === 'Function' || d.type === 'Method');
             // When receiver class is known (e.g. $this->method() in PHP), narrow
             // candidates to methods owned by that class to avoid false disambiguation failures.
             if (callableDefs && callableDefs.length > 1 && receiverClassName) {
                 if (graph) {
                     // Worker path: use graph.getNode (fast, already in-memory)
-                    const narrowed = callableDefs.filter(d => {
+                    const narrowed = callableDefs.filter((d) => {
                         if (!d.ownerId)
                             return false;
                         const owner = graph.getNode(d.ownerId);
@@ -225,8 +235,8 @@ const verifyConstructorBindings = (bindings, filePath, ctx, graph) => {
                     // Sequential path: use ctx.resolve (no graph available)
                     const classResolved = ctx.resolve(receiverClassName, filePath);
                     if (classResolved && classResolved.candidates.length > 0) {
-                        const classNodeIds = new Set(classResolved.candidates.map(c => c.nodeId));
-                        const narrowed = callableDefs.filter(d => d.ownerId && classNodeIds.has(d.ownerId));
+                        const classNodeIds = new Set(classResolved.candidates.map((c) => c.nodeId));
+                        const narrowed = callableDefs.filter((d) => d.ownerId && classNodeIds.has(d.ownerId));
                         if (narrowed.length > 0)
                             callableDefs = narrowed;
                     }
@@ -242,6 +252,85 @@ const verifyConstructorBindings = (bindings, filePath, ctx, graph) => {
     }
     return verified;
 };
+/**
+ * Build an ImplementorMap from extracted heritage data.
+ * Only direct `implements` relationships are tracked (transitive not needed for
+ * the common Java/Kotlin/C# interface dispatch pattern).
+ * `extends` is ignored — dispatch keyed on abstract class bases is not modeled here.
+ */
+/**
+ * Maps interface name → file paths of classes that implement it (direct only).
+ * When `ctx` is set, `kind: 'extends'` rows are classified like heritage-processor
+ * (C#/Java base_list: class vs interface parents share one capture name).
+ */
+export const buildImplementorMap = (heritage, ctx) => {
+    const map = new Map();
+    for (const h of heritage) {
+        let record = false;
+        if (h.kind === 'implements') {
+            record = true;
+        }
+        else if (h.kind === 'extends' && ctx) {
+            const lang = getLanguageFromFilename(h.filePath);
+            if (lang) {
+                const { type } = resolveExtendsType(h.parentName, h.filePath, ctx, lang);
+                record = type === 'IMPLEMENTS';
+            }
+        }
+        if (record) {
+            let files = map.get(h.parentName);
+            if (!files) {
+                files = new Set();
+                map.set(h.parentName, files);
+            }
+            files.add(h.filePath);
+        }
+    }
+    return map;
+};
+/**
+ * Merge a chunk's implementor map into the global accumulator.
+ */
+export const mergeImplementorMaps = (target, source) => {
+    for (const [name, files] of source) {
+        let existing = target.get(name);
+        if (!existing) {
+            existing = new Set();
+            target.set(name, existing);
+        }
+        for (const f of files)
+            existing.add(f);
+    }
+};
+/**
+ * After resolving a call to an interface method, find additional targets
+ * in classes implementing that interface. Returns implementation method
+ * results with lower confidence ('interface-dispatch').
+ */
+function findInterfaceDispatchTargets(calledName, receiverTypeName, currentFile, ctx, implementorMap, primaryNodeId) {
+    const implFiles = implementorMap.get(receiverTypeName);
+    if (!implFiles || implFiles.size === 0)
+        return [];
+    const typeResolved = ctx.resolve(receiverTypeName, currentFile);
+    if (!typeResolved)
+        return [];
+    if (!typeResolved.candidates.some((c) => c.type === 'Interface'))
+        return [];
+    const results = [];
+    for (const implFile of implFiles) {
+        const methods = ctx.symbols.lookupExactAll(implFile, calledName);
+        for (const method of methods) {
+            if (method.nodeId !== primaryNodeId) {
+                results.push({
+                    nodeId: method.nodeId,
+                    confidence: 0.7,
+                    reason: 'interface-dispatch',
+                });
+            }
+        }
+    }
+    return results;
+}
 export const processCalls = async (graph, files, astCache, ctx, onProgress, exportedTypeMap, 
 /** Phase 14: pre-resolved cross-file bindings to seed into buildTypeEnv. Keyed by filePath → Map<localName, typeName>. */
 importedBindingsMap, 
@@ -249,7 +338,7 @@ importedBindingsMap,
  *  Consulted ONLY when SymbolTable has no unambiguous match (local-first principle). */
 importedReturnTypesMap, 
 /** Phase 14 E3: cross-file RAW return types for for-loop element extraction. Keyed by filePath → Map<calleeName, rawReturnType>. */
-importedRawReturnTypesMap) => {
+importedRawReturnTypesMap, implementorMap) => {
     const parser = await loadParser();
     const collectedHeritage = [];
     const pendingWrites = [];
@@ -283,7 +372,9 @@ importedRawReturnTypesMap) => {
         let tree = astCache.get(file.path);
         if (!tree) {
             try {
-                tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+                tree = parser.parse(file.content, undefined, {
+                    bufferSize: getTreeSitterBufferSize(file.content.length),
+                });
             }
             catch (parseError) {
                 continue;
@@ -306,7 +397,7 @@ importedRawReturnTypesMap) => {
         const fileParentMap = new Map();
         for (const match of matches) {
             const captureMap = {};
-            match.captures.forEach(c => captureMap[c.name] = c.node);
+            match.captures.forEach((c) => (captureMap[c.name] = c.node));
             if (captureMap['heritage.class'] && captureMap['heritage.extends']) {
                 const className = captureMap['heritage.class'].text;
                 const parentName = captureMap['heritage.extends'].text;
@@ -347,7 +438,14 @@ importedRawReturnTypesMap) => {
         const importedBindings = importedBindingsMap?.get(file.path);
         const importedReturnTypes = importedReturnTypesMap?.get(file.path);
         const importedRawReturnTypes = importedRawReturnTypesMap?.get(file.path);
-        const typeEnv = buildTypeEnv(tree, language, { symbolTable: ctx.symbols, parentMap, importedBindings, importedReturnTypes, importedRawReturnTypes, enclosingFunctionFinder: provider?.enclosingFunctionFinder });
+        const typeEnv = buildTypeEnv(tree, language, {
+            symbolTable: ctx.symbols,
+            parentMap,
+            importedBindings,
+            importedReturnTypes,
+            importedRawReturnTypes,
+            enclosingFunctionFinder: provider?.enclosingFunctionFinder,
+        });
         if (typeEnv && exportedTypeMap) {
             const fileExports = collectExportedBindings(typeEnv, file.path, ctx.symbols, graph);
             if (fileExports)
@@ -360,11 +458,13 @@ importedRawReturnTypesMap) => {
         const receiverIndex = buildReceiverTypeIndex(verifiedReceivers);
         ctx.enableCache(file.path);
         const widenCache = new Map();
-        matches.forEach(match => {
+        matches.forEach((match) => {
             const captureMap = {};
-            match.captures.forEach(c => captureMap[c.name] = c.node);
+            match.captures.forEach((c) => (captureMap[c.name] = c.node));
             // ── Write access: emit ACCESSES {reason: 'write'} for assignments to member fields ──
-            if (captureMap['assignment'] && captureMap['assignment.receiver'] && captureMap['assignment.property']) {
+            if (captureMap['assignment'] &&
+                captureMap['assignment.receiver'] &&
+                captureMap['assignment.property']) {
                 const receiverNode = captureMap['assignment.receiver'];
                 const propertyName = captureMap['assignment.property'].text;
                 // Resolve receiver type: simple identifier → TypeEnv lookup or class resolution
@@ -381,8 +481,12 @@ importedRawReturnTypesMap) => {
                 }
                 if (!receiverTypeName && receiverText) {
                     const resolved = ctx.resolve(receiverText, file.path);
-                    if (resolved?.candidates.some(d => d.type === 'Class' || d.type === 'Struct' || d.type === 'Interface'
-                        || d.type === 'Enum' || d.type === 'Record' || d.type === 'Impl')) {
+                    if (resolved?.candidates.some((d) => d.type === 'Class' ||
+                        d.type === 'Struct' ||
+                        d.type === 'Interface' ||
+                        d.type === 'Enum' ||
+                        d.type === 'Record' ||
+                        d.type === 'Impl')) {
                         receiverTypeName = receiverText;
                     }
                 }
@@ -430,9 +534,12 @@ importedRawReturnTypesMap) => {
                                 id: nodeId,
                                 label: 'Property',
                                 properties: {
-                                    name: item.propName, filePath: file.path,
-                                    startLine: item.startLine, endLine: item.endLine,
-                                    language, isExported: true,
+                                    name: item.propName,
+                                    filePath: file.path,
+                                    startLine: item.startLine,
+                                    endLine: item.endLine,
+                                    language,
+                                    isExported: true,
                                     description: item.accessorType,
                                 },
                             });
@@ -442,14 +549,21 @@ importedRawReturnTypesMap) => {
                             });
                             const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
                             graph.addRelationship({
-                                id: relId, sourceId: fileId, targetId: nodeId,
-                                type: 'DEFINES', confidence: 1.0, reason: '',
+                                id: relId,
+                                sourceId: fileId,
+                                targetId: nodeId,
+                                type: 'DEFINES',
+                                confidence: 1.0,
+                                reason: '',
                             });
                             if (propEnclosingClassId) {
                                 graph.addRelationship({
                                     id: generateId('HAS_PROPERTY', `${propEnclosingClassId}->${nodeId}`),
-                                    sourceId: propEnclosingClassId, targetId: nodeId,
-                                    type: 'HAS_PROPERTY', confidence: 1.0, reason: '',
+                                    sourceId: propEnclosingClassId,
+                                    targetId: nodeId,
+                                    type: 'HAS_PROPERTY',
+                                    confidence: 1.0,
+                                    reason: '',
                                 });
                             }
                         }
@@ -495,10 +609,14 @@ importedRawReturnTypesMap) => {
                     // when a type annotation AND constructor are both present (val x: Base = Sub()),
                     // confirming both are class-like types is sufficient — the original code would
                     // not compile if Sub didn't extend Base.
-                    if (isSubclassOf(ctorType, receiverTypeName, parentMap)
-                        || isSubclassOf(ctorType, receiverTypeName, globalParentMap)
-                        || (ctx.symbols.lookupFuzzy(ctorType).some(d => d.type === 'Class' || d.type === 'Struct')
-                            && ctx.symbols.lookupFuzzy(receiverTypeName).some(d => d.type === 'Class' || d.type === 'Struct' || d.type === 'Interface'))) {
+                    if (isSubclassOf(ctorType, receiverTypeName, parentMap) ||
+                        isSubclassOf(ctorType, receiverTypeName, globalParentMap) ||
+                        (ctx.symbols
+                            .lookupFuzzy(ctorType)
+                            .some((d) => d.type === 'Class' || d.type === 'Struct') &&
+                            ctx.symbols
+                                .lookupFuzzy(receiverTypeName)
+                                .some((d) => d.type === 'Class' || d.type === 'Struct' || d.type === 'Interface'))) {
                         receiverTypeName = ctorType;
                     }
                 }
@@ -514,7 +632,11 @@ importedRawReturnTypesMap) => {
             // through the standard tiered resolution, use it directly as the receiver type.
             if (!receiverTypeName && receiverName && callForm === 'member') {
                 const typeResolved = ctx.resolve(receiverName, file.path);
-                if (typeResolved && typeResolved.candidates.some(d => d.type === 'Class' || d.type === 'Interface' || d.type === 'Struct' || d.type === 'Enum')) {
+                if (typeResolved &&
+                    typeResolved.candidates.some((d) => d.type === 'Class' ||
+                        d.type === 'Interface' ||
+                        d.type === 'Struct' ||
+                        d.type === 'Enum')) {
                     receiverTypeName = receiverName;
                 }
             }
@@ -538,7 +660,10 @@ importedRawReturnTypesMap) => {
                         }
                         if (!currentType && extracted.baseReceiverName) {
                             const cr = ctx.resolve(extracted.baseReceiverName, file.path);
-                            if (cr?.candidates.some(d => d.type === 'Class' || d.type === 'Interface' || d.type === 'Struct' || d.type === 'Enum')) {
+                            if (cr?.candidates.some((d) => d.type === 'Class' ||
+                                d.type === 'Interface' ||
+                                d.type === 'Struct' ||
+                                d.type === 'Enum')) {
                                 currentType = extracted.baseReceiverName;
                             }
                         }
@@ -552,7 +677,7 @@ importedRawReturnTypesMap) => {
             // Only used when multiple candidates survive arity filtering — ~1-3% of calls.
             const langConfig = provider.typeConfig;
             const hints = langConfig?.inferLiteralType
-                ? { callNode, inferLiteralType: langConfig.inferLiteralType }
+                ? { callNode, inferLiteralType: langConfig.inferLiteralType, typeEnv }
                 : undefined;
             const resolved = resolveCallTarget({
                 calledName,
@@ -572,6 +697,19 @@ importedRawReturnTypesMap) => {
                 confidence: resolved.confidence,
                 reason: resolved.reason,
             });
+            if (implementorMap && callForm === 'member' && receiverTypeName) {
+                const implTargets = findInterfaceDispatchTargets(calledName, receiverTypeName, file.path, ctx, implementorMap, resolved.nodeId);
+                for (const impl of implTargets) {
+                    graph.addRelationship({
+                        id: generateId('CALLS', `${sourceId}:${calledName}->${impl.nodeId}`),
+                        sourceId,
+                        targetId: impl.nodeId,
+                        type: 'CALLS',
+                        confidence: impl.confidence,
+                        reason: impl.reason,
+                    });
+                }
+            }
         });
         ctx.clearCache();
     }
@@ -597,39 +735,34 @@ importedRawReturnTypesMap) => {
     }
     return collectedHeritage;
 };
-const CALLABLE_SYMBOL_TYPES = new Set([
-    'Function',
-    'Method',
-    'Constructor',
-    'Macro',
-    'Delegate',
-]);
+const CALLABLE_SYMBOL_TYPES = new Set(['Function', 'Method', 'Constructor', 'Macro', 'Delegate']);
 const CONSTRUCTOR_TARGET_TYPES = new Set(['Constructor', 'Class', 'Struct', 'Record']);
 const filterCallableCandidates = (candidates, argCount, callForm) => {
     let kindFiltered;
     if (callForm === 'constructor') {
-        const constructors = candidates.filter(c => c.type === 'Constructor');
+        const constructors = candidates.filter((c) => c.type === 'Constructor');
         if (constructors.length > 0) {
             kindFiltered = constructors;
         }
         else {
-            const types = candidates.filter(c => CONSTRUCTOR_TARGET_TYPES.has(c.type));
-            kindFiltered = types.length > 0 ? types : candidates.filter(c => CALLABLE_SYMBOL_TYPES.has(c.type));
+            const types = candidates.filter((c) => CONSTRUCTOR_TARGET_TYPES.has(c.type));
+            kindFiltered =
+                types.length > 0 ? types : candidates.filter((c) => CALLABLE_SYMBOL_TYPES.has(c.type));
         }
     }
     else {
-        kindFiltered = candidates.filter(c => CALLABLE_SYMBOL_TYPES.has(c.type));
+        kindFiltered = candidates.filter((c) => CALLABLE_SYMBOL_TYPES.has(c.type));
     }
     if (kindFiltered.length === 0)
         return [];
     if (argCount === undefined)
         return kindFiltered;
-    const hasParameterMetadata = kindFiltered.some(candidate => candidate.parameterCount !== undefined);
+    const hasParameterMetadata = kindFiltered.some((candidate) => candidate.parameterCount !== undefined);
     if (!hasParameterMetadata)
         return kindFiltered;
-    return kindFiltered.filter(candidate => candidate.parameterCount === undefined
-        || (argCount >= (candidate.requiredParameterCount ?? candidate.parameterCount)
-            && argCount <= candidate.parameterCount));
+    return kindFiltered.filter((candidate) => candidate.parameterCount === undefined ||
+        (argCount >= (candidate.requiredParameterCount ?? candidate.parameterCount) &&
+            argCount <= candidate.parameterCount));
 };
 const toResolveResult = (definition, tier) => ({
     nodeId: definition.nodeId,
@@ -638,13 +771,10 @@ const toResolveResult = (definition, tier) => ({
     returnType: definition.returnType,
 });
 /**
- * Kotlin (and JVM in general) uses boxed type names in parameter declarations
- * (e.g. `Int`, `Long`, `Boolean`) while inferJvmLiteralType returns unboxed
- * primitives (`int`, `long`, `boolean`). Normalise both sides to lowercase so
- * that the comparison `'Int' === 'int'` does not fail.
- *
- * Only applied to single-word identifiers that look like a JVM primitive alias;
- * multi-word or qualified names are left untouched.
+ * Kotlin often declares parameters with boxed names (`Int`, `Boolean`, …) while
+ * literal inference yields JVM primitives (`int`, `boolean`). This map aligns
+ * those for overload matching. Java parameter text is usually already primitive
+ * spellings, so lookups here are typically unchanged.
  */
 const KOTLIN_BOXED_TO_PRIMITIVE = {
     Int: 'int',
@@ -657,48 +787,10 @@ const KOTLIN_BOXED_TO_PRIMITIVE = {
     Char: 'char',
 };
 const normalizeJvmTypeName = (name) => KOTLIN_BOXED_TO_PRIMITIVE[name] ?? name;
-/**
- * Try to disambiguate overloaded candidates using argument literal types.
- * Only invoked when filteredCandidates.length > 1 and at least one has parameterTypes.
- * Returns the single matching candidate, or null if ambiguous/inconclusive.
- */
-const tryOverloadDisambiguation = (candidates, hints) => {
-    if (!candidates.some(c => c.parameterTypes))
+const matchCandidatesByArgTypes = (candidates, argTypes) => {
+    if (!candidates.some((c) => c.parameterTypes))
         return null;
-    // Find the argument list node in the call expression.
-    // Kotlin wraps value_arguments inside a call_suffix child, so we must also
-    // search one level deeper when a direct match is not found.
-    let argList = hints.callNode.childForFieldName?.('arguments')
-        ?? hints.callNode.children.find((c) => c.type === 'arguments' || c.type === 'argument_list' || c.type === 'value_arguments');
-    if (!argList) {
-        // Kotlin: call_expression → call_suffix → value_arguments
-        const callSuffix = hints.callNode.children.find((c) => c.type === 'call_suffix');
-        if (callSuffix) {
-            argList = callSuffix.children.find((c) => c.type === 'value_arguments');
-        }
-    }
-    if (!argList)
-        return null;
-    const argTypes = [];
-    for (const arg of argList.namedChildren) {
-        if (arg.type === 'comment')
-            continue;
-        // Unwrap argument wrapper nodes before passing to inferLiteralType:
-        //   - Kotlin value_argument: has 'value' field containing the literal
-        //   - C# argument: has 'expression' field (handles named args like `name: "alice"`
-        //     where firstNamedChild would return name_colon instead of the value)
-        //   - Java/others: arg IS the literal directly (no unwrapping needed)
-        const valueNode = arg.childForFieldName?.('value')
-            ?? arg.childForFieldName?.('expression')
-            ?? (arg.type === 'argument' || arg.type === 'value_argument'
-                ? arg.firstNamedChild ?? arg
-                : arg);
-        argTypes.push(hints.inferLiteralType(valueNode));
-    }
-    // If no literal types could be inferred, can't disambiguate
-    if (argTypes.every(t => t === undefined))
-        return null;
-    const matched = candidates.filter(c => {
+    const matched = candidates.filter((c) => {
         // Keep candidates without type info — conservative: partially-annotated codebases
         // (e.g. C++ with some missing declarations) may have mixed typed/untyped overloads.
         // If one typed and one untyped both survive, matched.length > 1 → returns null (no edge).
@@ -718,13 +810,24 @@ const tryOverloadDisambiguation = (candidates, hints) => {
     // implementation body all collide via generateId). Deduplicate by nodeId — if all
     // matched candidates resolve to the same graph node, disambiguation succeeded.
     if (matched.length > 1) {
-        const uniqueIds = new Set(matched.map(c => c.nodeId));
+        const uniqueIds = new Set(matched.map((c) => c.nodeId));
         if (uniqueIds.size === 1)
             return matched[0];
     }
     return null;
 };
-const resolveCallTarget = (call, currentFile, ctx, overloadHints, widenCache) => {
+/**
+ * Try to disambiguate overloaded candidates using argument literal types.
+ * Only invoked when filteredCandidates.length > 1 and at least one has parameterTypes.
+ * Returns the single matching candidate, or null if ambiguous/inconclusive.
+ */
+const tryOverloadDisambiguation = (candidates, hints) => {
+    const argTypes = extractCallArgTypes(hints.callNode, hints.inferLiteralType, hints.typeEnv ? (varName, cn) => hints.typeEnv.lookup(varName, cn) : undefined);
+    if (!argTypes)
+        return null;
+    return matchCandidatesByArgTypes(candidates, argTypes);
+};
+const resolveCallTarget = (call, currentFile, ctx, overloadHints, widenCache, preComputedArgTypes) => {
     const tiered = ctx.resolve(call.calledName, currentFile);
     if (!tiered)
         return null;
@@ -733,7 +836,7 @@ const resolveCallTarget = (call, currentFile, ctx, overloadHints, widenCache) =>
     // If free-form filtering found no callable candidates but the symbol resolves to a
     // Class/Struct, retry with constructor form so CONSTRUCTOR_TARGET_TYPES applies.
     if (filteredCandidates.length === 0 && call.callForm === 'free') {
-        const hasTypeTarget = tiered.candidates.some(c => c.type === 'Class' || c.type === 'Struct' || c.type === 'Enum');
+        const hasTypeTarget = tiered.candidates.some((c) => c.type === 'Class' || c.type === 'Struct' || c.type === 'Enum');
         if (hasTypeTarget) {
             filteredCandidates = filterCallableCandidates(tiered.candidates, call.argCount, 'constructor');
         }
@@ -754,7 +857,7 @@ const resolveCallTarget = (call, currentFile, ctx, overloadHints, widenCache) =>
         if (aliasMap) {
             const moduleFile = aliasMap.get(call.receiverName);
             if (moduleFile) {
-                const aliasFiltered = filteredCandidates.filter(c => c.filePath === moduleFile);
+                const aliasFiltered = filteredCandidates.filter((c) => c.filePath === moduleFile);
                 if (aliasFiltered.length > 0) {
                     filteredCandidates = aliasFiltered;
                 }
@@ -769,8 +872,7 @@ const resolveCallTarget = (call, currentFile, ctx, overloadHints, widenCache) =>
                         fuzzyDefs = ctx.symbols.lookupFuzzy(call.calledName);
                         widenCache?.set(cacheKey, fuzzyDefs);
                     }
-                    const widened = filterCallableCandidates(fuzzyDefs, call.argCount, call.callForm)
-                        .filter(c => c.filePath === moduleFile);
+                    const widened = filterCallableCandidates(fuzzyDefs, call.argCount, call.callForm).filter((c) => c.filePath === moduleFile);
                     if (widened.length > 0)
                         filteredCandidates = widened;
                 }
@@ -789,8 +891,8 @@ const resolveCallTarget = (call, currentFile, ctx, overloadHints, widenCache) =>
         // D1. Resolve the receiver type
         const typeResolved = ctx.resolve(call.receiverTypeName, currentFile);
         if (typeResolved && typeResolved.candidates.length > 0) {
-            const typeNodeIds = new Set(typeResolved.candidates.map(d => d.nodeId));
-            const typeFiles = new Set(typeResolved.candidates.map(d => d.filePath));
+            const typeNodeIds = new Set(typeResolved.candidates.map((d) => d.nodeId));
+            const typeFiles = new Set(typeResolved.candidates.map((d) => d.filePath));
             // D2. Widen candidates: same-file tier may miss the parent's method when
             //     it lives in another file. Query the symbol table directly for all
             //     global methods with this name, then apply arity/kind filtering.
@@ -798,32 +900,39 @@ const resolveCallTarget = (call, currentFile, ctx, overloadHints, widenCache) =>
                 ? filterCallableCandidates(ctx.symbols.lookupFuzzy(call.calledName), call.argCount, call.callForm)
                 : filteredCandidates;
             // D3. File-based: prefer candidates whose filePath matches the resolved type's file
-            const fileFiltered = methodPool.filter(c => typeFiles.has(c.filePath));
+            const fileFiltered = methodPool.filter((c) => typeFiles.has(c.filePath));
             if (fileFiltered.length === 1) {
                 return toResolveResult(fileFiltered[0], tiered.tier);
             }
             // D4. ownerId fallback: narrow by ownerId matching the type's nodeId
             const pool = fileFiltered.length > 0 ? fileFiltered : methodPool;
-            const ownerFiltered = pool.filter(c => c.ownerId && typeNodeIds.has(c.ownerId));
+            const ownerFiltered = pool.filter((c) => c.ownerId && typeNodeIds.has(c.ownerId));
             if (ownerFiltered.length === 1) {
                 return toResolveResult(ownerFiltered[0], tiered.tier);
             }
             // E. Try overload disambiguation on the narrowed pool
-            if ((fileFiltered.length > 1 || ownerFiltered.length > 1) && overloadHints) {
+            if (fileFiltered.length > 1 || ownerFiltered.length > 1) {
                 const overloadPool = ownerFiltered.length > 1 ? ownerFiltered : fileFiltered;
-                const disambiguated = tryOverloadDisambiguation(overloadPool, overloadHints);
+                const disambiguated = overloadHints
+                    ? tryOverloadDisambiguation(overloadPool, overloadHints)
+                    : preComputedArgTypes
+                        ? matchCandidatesByArgTypes(overloadPool, preComputedArgTypes)
+                        : null;
                 if (disambiguated)
                     return toResolveResult(disambiguated, tiered.tier);
-            }
-            if (fileFiltered.length > 1 || ownerFiltered.length > 1)
                 return null;
+            }
         }
     }
     // E. Overload disambiguation: when multiple candidates survive arity + receiver filtering,
-    // try matching argument literal types against parameter types (Phase P).
-    // Only available on sequential path (has AST); worker path falls through gracefully.
-    if (filteredCandidates.length > 1 && overloadHints) {
-        const disambiguated = tryOverloadDisambiguation(filteredCandidates, overloadHints);
+    // try matching argument types against parameter types (Phase P).
+    // Sequential path uses AST-based hints; worker path uses pre-computed argTypes.
+    if (filteredCandidates.length > 1) {
+        const disambiguated = overloadHints
+            ? tryOverloadDisambiguation(filteredCandidates, overloadHints)
+            : preComputedArgTypes
+                ? matchCandidatesByArgTypes(filteredCandidates, preComputedArgTypes)
+                : null;
         if (disambiguated)
             return toResolveResult(disambiguated, tiered.tier);
     }
@@ -833,8 +942,9 @@ const resolveCallTarget = (call, currentFile, ctx, overloadHints, widenCache) =>
         // primary definition), they represent the same symbol. Prefer the primary
         // definition (shortest file path: Product.swift over ProductExtension.swift).
         if (filteredCandidates.length > 1) {
-            const allSameType = filteredCandidates.every(c => c.type === filteredCandidates[0].type);
-            if (allSameType && (filteredCandidates[0].type === 'Class' || filteredCandidates[0].type === 'Struct')) {
+            const allSameType = filteredCandidates.every((c) => c.type === filteredCandidates[0].type);
+            if (allSameType &&
+                (filteredCandidates[0].type === 'Class' || filteredCandidates[0].type === 'Struct')) {
                 const sorted = [...filteredCandidates].sort((a, b) => a.filePath.length - b.filePath.length);
                 return toResolveResult(sorted[0], tiered.tier);
             }
@@ -948,8 +1058,12 @@ const resolveFieldOwnership = (receiverName, fieldName, filePath, ctx) => {
     const typeResolved = ctx.resolve(receiverName, filePath);
     if (!typeResolved)
         return undefined;
-    const classDef = typeResolved.candidates.find(d => d.type === 'Class' || d.type === 'Struct' || d.type === 'Interface'
-        || d.type === 'Enum' || d.type === 'Record' || d.type === 'Impl');
+    const classDef = typeResolved.candidates.find((d) => d.type === 'Class' ||
+        d.type === 'Struct' ||
+        d.type === 'Interface' ||
+        d.type === 'Enum' ||
+        d.type === 'Record' ||
+        d.type === 'Impl');
     if (!classDef)
         return undefined;
     return ctx.symbols.lookupFieldByOwner(classDef.nodeId, fieldName) ?? undefined;
@@ -1025,7 +1139,7 @@ const walkMixedChain = (chain, startType, filePath, ctx, onFieldResolved) => {
  * Fast path: resolve pre-extracted call sites from workers.
  * No AST parsing — workers already extracted calledName + sourceId.
  */
-export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onProgress, constructorBindings) => {
+export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onProgress, constructorBindings, implementorMap) => {
     // Scope-aware receiver types: keyed by filePath → "funcName\0varName" → typeName.
     // The scope dimension prevents collisions when two functions in the same file
     // have same-named locals pointing to different constructor types.
@@ -1069,9 +1183,15 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
                 }
             }
             // Step 1b: class-as-receiver for static method calls (e.g. UserService.find_user())
-            if (!effectiveCall.receiverTypeName && effectiveCall.receiverName && effectiveCall.callForm === 'member') {
+            if (!effectiveCall.receiverTypeName &&
+                effectiveCall.receiverName &&
+                effectiveCall.callForm === 'member') {
                 const typeResolved = ctx.resolve(effectiveCall.receiverName, effectiveCall.filePath);
-                if (typeResolved && typeResolved.candidates.some(d => d.type === 'Class' || d.type === 'Interface' || d.type === 'Struct' || d.type === 'Enum')) {
+                if (typeResolved &&
+                    typeResolved.candidates.some((d) => d.type === 'Class' ||
+                        d.type === 'Interface' ||
+                        d.type === 'Struct' ||
+                        d.type === 'Enum')) {
                     effectiveCall = { ...effectiveCall, receiverTypeName: effectiveCall.receiverName };
                 }
             }
@@ -1087,7 +1207,10 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
                 }
                 if (!currentType && effectiveCall.receiverName) {
                     const typeResolved = ctx.resolve(effectiveCall.receiverName, effectiveCall.filePath);
-                    if (typeResolved?.candidates.some(d => d.type === 'Class' || d.type === 'Interface' || d.type === 'Struct' || d.type === 'Enum')) {
+                    if (typeResolved?.candidates.some((d) => d.type === 'Class' ||
+                        d.type === 'Interface' ||
+                        d.type === 'Struct' ||
+                        d.type === 'Enum')) {
                         currentType = effectiveCall.receiverName;
                     }
                 }
@@ -1098,7 +1221,7 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
                     }
                 }
             }
-            const resolved = resolveCallTarget(effectiveCall, effectiveCall.filePath, ctx, undefined, widenCache);
+            const resolved = resolveCallTarget(effectiveCall, effectiveCall.filePath, ctx, undefined, widenCache, effectiveCall.argTypes);
             if (!resolved)
                 continue;
             const relId = generateId('CALLS', `${effectiveCall.sourceId}:${effectiveCall.calledName}->${resolved.nodeId}`);
@@ -1110,6 +1233,19 @@ export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onPr
                 confidence: resolved.confidence,
                 reason: resolved.reason,
             });
+            if (implementorMap && effectiveCall.callForm === 'member' && effectiveCall.receiverTypeName) {
+                const implTargets = findInterfaceDispatchTargets(effectiveCall.calledName, effectiveCall.receiverTypeName, effectiveCall.filePath, ctx, implementorMap, resolved.nodeId);
+                for (const impl of implTargets) {
+                    graph.addRelationship({
+                        id: generateId('CALLS', `${effectiveCall.sourceId}:${effectiveCall.calledName}->${impl.nodeId}`),
+                        sourceId: effectiveCall.sourceId,
+                        targetId: impl.nodeId,
+                        type: 'CALLS',
+                        confidence: impl.confidence,
+                        reason: impl.reason,
+                    });
+                }
+            }
         }
         ctx.clearCache();
     }
@@ -1145,8 +1281,12 @@ export const processAssignmentsFromExtracted = (graph, assignments, ctx, constru
         // Tier 3: static class-as-receiver fallback
         if (!receiverTypeName) {
             const resolved = ctx.resolve(asn.receiverText, asn.filePath);
-            if (resolved?.candidates.some(d => d.type === 'Class' || d.type === 'Struct' || d.type === 'Interface'
-                || d.type === 'Enum' || d.type === 'Record' || d.type === 'Impl')) {
+            if (resolved?.candidates.some((d) => d.type === 'Class' ||
+                d.type === 'Struct' ||
+                d.type === 'Interface' ||
+                d.type === 'Enum' ||
+                d.type === 'Record' ||
+                d.type === 'Impl')) {
                 receiverTypeName = asn.receiverText;
             }
         }
@@ -1232,25 +1372,82 @@ export const processRoutesFromExtracted = async (graph, extractedRoutes, ctx, on
 // that happen to share names with response variables (data, result, response, etc.).
 const RESPONSE_ACCESS_BLOCKLIST = new Set([
     // Fetch/Response API
-    'json', 'text', 'blob', 'arrayBuffer', 'formData', 'ok', 'status', 'headers', 'clone',
+    'json',
+    'text',
+    'blob',
+    'arrayBuffer',
+    'formData',
+    'ok',
+    'status',
+    'headers',
+    'clone',
     // Promise
-    'then', 'catch', 'finally',
+    'then',
+    'catch',
+    'finally',
     // Array
-    'map', 'filter', 'forEach', 'reduce', 'find', 'some', 'every',
-    'push', 'pop', 'shift', 'unshift', 'splice', 'slice', 'concat', 'join',
-    'sort', 'reverse', 'includes', 'indexOf',
+    'map',
+    'filter',
+    'forEach',
+    'reduce',
+    'find',
+    'some',
+    'every',
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'slice',
+    'concat',
+    'join',
+    'sort',
+    'reverse',
+    'includes',
+    'indexOf',
     // Object
-    'length', 'toString', 'valueOf', 'keys', 'values', 'entries',
+    'length',
+    'toString',
+    'valueOf',
+    'keys',
+    'values',
+    'entries',
     // DOM methods — file-download patterns often reuse `data`/`response` variable names
-    'appendChild', 'removeChild', 'insertBefore', 'replaceChild', 'replaceChildren',
-    'createElement', 'getElementById', 'querySelector', 'querySelectorAll',
-    'setAttribute', 'getAttribute', 'removeAttribute', 'hasAttribute',
-    'addEventListener', 'removeEventListener', 'dispatchEvent',
-    'classList', 'className',
-    'parentNode', 'parentElement', 'childNodes', 'children',
-    'nextSibling', 'previousSibling', 'firstChild', 'lastChild',
-    'click', 'focus', 'blur', 'submit', 'reset',
-    'innerHTML', 'outerHTML', 'textContent', 'innerText',
+    'appendChild',
+    'removeChild',
+    'insertBefore',
+    'replaceChild',
+    'replaceChildren',
+    'createElement',
+    'getElementById',
+    'querySelector',
+    'querySelectorAll',
+    'setAttribute',
+    'getAttribute',
+    'removeAttribute',
+    'hasAttribute',
+    'addEventListener',
+    'removeEventListener',
+    'dispatchEvent',
+    'classList',
+    'className',
+    'parentNode',
+    'parentElement',
+    'childNodes',
+    'children',
+    'nextSibling',
+    'previousSibling',
+    'firstChild',
+    'lastChild',
+    'click',
+    'focus',
+    'blur',
+    'submit',
+    'reset',
+    'innerHTML',
+    'outerHTML',
+    'textContent',
+    'innerText',
 ]);
 export const extractConsumerAccessedKeys = (content) => {
     const keys = new Set();
@@ -1370,7 +1567,9 @@ export const extractFetchCallsFromFiles = async (files, astCache) => {
         let tree = astCache.get(file.path);
         if (!tree) {
             try {
-                tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+                tree = parser.parse(file.content, undefined, {
+                    bufferSize: getTreeSitterBufferSize(file.content.length),
+                });
             }
             catch {
                 continue;
@@ -1388,7 +1587,7 @@ export const extractFetchCallsFromFiles = async (files, astCache) => {
         }
         for (const match of matches) {
             const captureMap = {};
-            match.captures.forEach(c => captureMap[c.name] = c.node);
+            match.captures.forEach((c) => (captureMap[c.name] = c.node));
             if (captureMap['route.fetch']) {
                 const urlNode = captureMap['route.url'] ?? captureMap['route.template_url'];
                 if (urlNode) {
@@ -1404,7 +1603,11 @@ export const extractFetchCallsFromFiles = async (files, astCache) => {
                 const url = captureMap['http_client.url'].text;
                 const HTTP_CLIENT_ONLY = new Set(['head', 'options', 'request', 'ajax']);
                 if (method && HTTP_CLIENT_ONLY.has(method) && url.startsWith('/')) {
-                    result.push({ filePath: file.path, fetchURL: url, lineNumber: captureMap['http_client'].startPosition.row });
+                    result.push({
+                        filePath: file.path,
+                        fetchURL: url,
+                        lineNumber: captureMap['http_client'].startPosition.row,
+                    });
                 }
             }
         }