gitnexus 1.4.1 → 1.4.6

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

@@ -1,161 +1,114 @@
 import Parser from 'tree-sitter';
-import { loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+import { TIER_CONFIDENCE } from './resolution-context.js';
+import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
-import { getLanguageFromFilename, yieldToEventLoop } from './utils.js';
-/**
- * Node types that represent function/method definitions across languages.
- * Used to find the enclosing function for a call site.
- */
-const FUNCTION_NODE_TYPES = new Set([
-    // TypeScript/JavaScript
-    'function_declaration',
-    'arrow_function',
-    'function_expression',
-    'method_definition',
-    'generator_function_declaration',
-    // Python
-    'function_definition',
-    // Common async variants
-    'async_function_declaration',
-    'async_arrow_function',
-    // Java
-    'method_declaration',
-    'constructor_declaration',
-    // C/C++
-    // 'function_definition' already included above
-    // Go
-    // 'method_declaration' already included from Java
-    // C#
-    'local_function_statement',
-    // Rust
-    'function_item',
-    'impl_item', // Methods inside impl blocks
-    // Kotlin (function_declaration already included above via JS/TS)
-    'anonymous_function',
-    'lambda_literal',
-    // PHP — no additional node types needed
-    // Swift
-    'init_declaration',
-    'deinit_declaration',
-]);
+import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop, FUNCTION_NODE_TYPES, extractFunctionName, isBuiltInOrNoise, countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, findEnclosingClassId, CALL_EXPRESSION_TYPES, extractCallChain, } from './utils.js';
+import { buildTypeEnv } from './type-env.js';
+import { getTreeSitterBufferSize } from './constants.js';
+import { callRouters } from './call-routing.js';
+import { extractReturnTypeName } from './type-extractors/shared.js';
 /**
  * Walk up the AST from a node to find the enclosing function/method.
  * Returns null if the call is at module/file level (top-level code).
  */
-const findEnclosingFunction = (node, filePath, symbolTable) => {
+const findEnclosingFunction = (node, filePath, ctx) => {
     let current = node.parent;
     while (current) {
         if (FUNCTION_NODE_TYPES.has(current.type)) {
-            // Found enclosing function - try to get its name
-            let funcName = null;
-            let label = 'Function';
-            // Different node types have different name locations
-            // Swift init/deinit — handle before generic cases (more specific)
-            if (current.type === 'init_declaration' || current.type === 'deinit_declaration') {
-                const funcName = current.type === 'init_declaration' ? 'init' : 'deinit';
-                const startLine = current.startPosition?.row ?? 0;
-                return generateId('Constructor', `${filePath}:${funcName}:${startLine}`);
-            }
-            if (current.type === 'function_declaration' ||
-                current.type === 'function_definition' ||
-                current.type === 'async_function_declaration' ||
-                current.type === 'generator_function_declaration' ||
-                current.type === 'function_item') { // Rust function
-                // Named function: function foo() {}
-                const nameNode = current.childForFieldName?.('name') ||
-                    current.children?.find((c) => c.type === 'identifier' || c.type === 'property_identifier');
-                funcName = nameNode?.text;
-            }
-            else if (current.type === 'impl_item') {
-                // Rust method inside impl block: wrapper around function_item or const_item
-                // We need to look inside for the function_item
-                const funcItem = current.children?.find((c) => c.type === 'function_item');
-                if (funcItem) {
-                    const nameNode = funcItem.childForFieldName?.('name') ||
-                        funcItem.children?.find((c) => c.type === 'identifier');
-                    funcName = nameNode?.text;
-                    label = 'Method';
+            const { funcName, label } = extractFunctionName(current);
+            if (funcName) {
+                const resolved = ctx.resolve(funcName, filePath);
+                if (resolved?.tier === 'same-file' && resolved.candidates.length > 0) {
+                    return resolved.candidates[0].nodeId;
                 }
+                return generateId(label, `${filePath}:${funcName}`);
             }
-            else if (current.type === 'method_definition') {
-                // Method: foo() {} inside class (JS/TS)
-                const nameNode = current.childForFieldName?.('name') ||
-                    current.children?.find((c) => c.type === 'property_identifier');
-                funcName = nameNode?.text;
-                label = 'Method';
-            }
-            else if (current.type === 'method_declaration') {
-                // Java method: public void foo() {}
-                const nameNode = current.childForFieldName?.('name') ||
-                    current.children?.find((c) => c.type === 'identifier');
-                funcName = nameNode?.text;
-                label = 'Method';
-            }
-            else if (current.type === 'constructor_declaration') {
-                // Java constructor: public ClassName() {}
-                const nameNode = current.childForFieldName?.('name') ||
-                    current.children?.find((c) => c.type === 'identifier');
-                funcName = nameNode?.text;
-                label = 'Method'; // Treat constructors as methods for process detection
-            }
-            else if (current.type === 'arrow_function' || current.type === 'function_expression') {
-                // Arrow/expression: const foo = () => {} - check parent variable declarator
-                const parent = current.parent;
-                if (parent?.type === 'variable_declarator') {
-                    const nameNode = parent.childForFieldName?.('name') ||
-                        parent.children?.find((c) => c.type === 'identifier');
-                    funcName = nameNode?.text;
+        }
+        current = current.parent;
+    }
+    return null;
+};
+/**
+ * Verify constructor bindings against SymbolTable and infer receiver types.
+ * Shared between sequential (processCalls) and worker (processCallsFromExtracted) paths.
+ */
+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;
+        if (isClass) {
+            verified.set(receiverKey(scope, varName), calleeName);
+        }
+        else {
+            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 => {
+                        if (!d.ownerId)
+                            return false;
+                        const owner = graph.getNode(d.ownerId);
+                        return owner?.properties.name === receiverClassName;
+                    });
+                    if (narrowed.length > 0)
+                        callableDefs = narrowed;
+                }
+                else {
+                    // 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));
+                        if (narrowed.length > 0)
+                            callableDefs = narrowed;
+                    }
                 }
             }
-            if (funcName) {
-                // Look up the function in symbol table to get its node ID
-                // Try exact match first
-                const nodeId = symbolTable.lookupExact(filePath, funcName);
-                if (nodeId)
-                    return nodeId;
-                // Try construct ID manually if lookup fails (common for non-exported internal functions)
-                // Format must match parsing-processor: "Label:path/to/file:funcName:startLine"
-                const startLine = current.startPosition?.row ?? 0;
-                return generateId(label, `${filePath}:${funcName}:${startLine}`);
+            if (callableDefs && callableDefs.length === 1 && callableDefs[0].returnType) {
+                const typeName = extractReturnTypeName(callableDefs[0].returnType);
+                if (typeName) {
+                    verified.set(receiverKey(scope, varName), typeName);
+                }
             }
-            // Couldn't determine function name - try parent (might be nested)
         }
-        current = current.parent;
     }
-    return null; // Top-level call (not inside any function)
+    return verified;
 };
-export const processCalls = async (graph, files, astCache, symbolTable, importMap, onProgress) => {
+export const processCalls = async (graph, files, astCache, ctx, onProgress) => {
     const parser = await loadParser();
+    const collectedHeritage = [];
+    const logSkipped = isVerboseIngestionEnabled();
+    const skippedByLang = logSkipped ? new Map() : null;
     for (let i = 0; i < files.length; i++) {
         const file = files[i];
         onProgress?.(i + 1, files.length);
         if (i % 20 === 0)
             await yieldToEventLoop();
-        // 1. Check language support first
         const language = getLanguageFromFilename(file.path);
         if (!language)
             continue;
+        if (!isLanguageAvailable(language)) {
+            if (skippedByLang) {
+                skippedByLang.set(language, (skippedByLang.get(language) ?? 0) + 1);
+            }
+            continue;
+        }
         const queryStr = LANGUAGE_QUERIES[language];
         if (!queryStr)
             continue;
-        // 2. ALWAYS load the language before querying (parser is stateful)
         await loadLanguage(language, file.path);
-        // 3. Get AST (Try Cache First)
         let tree = astCache.get(file.path);
-        let wasReparsed = false;
         if (!tree) {
-            // Cache Miss: Re-parse
-            // Use larger bufferSize for files > 32KB
             try {
-                tree = parser.parse(file.content, undefined, { bufferSize: 1024 * 256 });
+                tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
             }
             catch (parseError) {
-                // Skip files that can't be parsed
                 continue;
             }
-            wasReparsed = true;
-            // Cache re-parsed tree so heritage phase gets hits
             astCache.set(file.path, tree);
         }
         let query;
@@ -169,28 +122,130 @@ export const processCalls = async (graph, files, astCache, symbolTable, importMa
             console.warn(`Query error for ${file.path}:`, queryError);
             continue;
         }
-        // 3. Process each call match
+        const lang = getLanguageFromFilename(file.path);
+        const typeEnv = lang ? buildTypeEnv(tree, lang, ctx.symbols) : null;
+        const callRouter = callRouters[language];
+        const verifiedReceivers = typeEnv && typeEnv.constructorBindings.length > 0
+            ? verifyConstructorBindings(typeEnv.constructorBindings, file.path, ctx)
+            : new Map();
+        ctx.enableCache(file.path);
         matches.forEach(match => {
             const captureMap = {};
             match.captures.forEach(c => captureMap[c.name] = c.node);
-            // Only process @call captures
             if (!captureMap['call'])
                 return;
             const nameNode = captureMap['call.name'];
             if (!nameNode)
                 return;
             const calledName = nameNode.text;
-            // Skip common built-ins and noise
+            const routed = callRouter(calledName, captureMap['call']);
+            if (routed) {
+                switch (routed.kind) {
+                    case 'skip':
+                    case 'import':
+                        return;
+                    case 'heritage':
+                        for (const item of routed.items) {
+                            collectedHeritage.push({
+                                filePath: file.path,
+                                className: item.enclosingClass,
+                                parentName: item.mixinName,
+                                kind: item.heritageKind,
+                            });
+                        }
+                        return;
+                    case 'properties': {
+                        const fileId = generateId('File', file.path);
+                        const propEnclosingClassId = findEnclosingClassId(captureMap['call'], file.path);
+                        for (const item of routed.items) {
+                            const nodeId = generateId('Property', `${file.path}:${item.propName}`);
+                            graph.addNode({
+                                id: nodeId,
+                                label: 'Property',
+                                properties: {
+                                    name: item.propName, filePath: file.path,
+                                    startLine: item.startLine, endLine: item.endLine,
+                                    language, isExported: true,
+                                    description: item.accessorType,
+                                },
+                            });
+                            ctx.symbols.add(file.path, item.propName, nodeId, 'Property', propEnclosingClassId ? { ownerId: propEnclosingClassId } : undefined);
+                            const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
+                            graph.addRelationship({
+                                id: relId, sourceId: fileId, targetId: nodeId,
+                                type: 'DEFINES', confidence: 1.0, reason: '',
+                            });
+                            if (propEnclosingClassId) {
+                                graph.addRelationship({
+                                    id: generateId('HAS_METHOD', `${propEnclosingClassId}->${nodeId}`),
+                                    sourceId: propEnclosingClassId, targetId: nodeId,
+                                    type: 'HAS_METHOD', confidence: 1.0, reason: '',
+                                });
+                            }
+                        }
+                        return;
+                    }
+                    case 'call':
+                        break;
+                }
+            }
             if (isBuiltInOrNoise(calledName))
                 return;
-            // 4. Resolve the target using priority strategy (returns confidence)
-            const resolved = resolveCallTarget(calledName, file.path, symbolTable, importMap);
+            const callNode = captureMap['call'];
+            const callForm = inferCallForm(callNode, nameNode);
+            const receiverName = callForm === 'member' ? extractReceiverName(nameNode) : undefined;
+            let receiverTypeName = receiverName && typeEnv ? typeEnv.lookup(receiverName, callNode) : undefined;
+            // Fall back to verified constructor bindings for return type inference
+            if (!receiverTypeName && receiverName && verifiedReceivers.size > 0) {
+                const enclosingFunc = findEnclosingFunction(callNode, file.path, ctx);
+                const funcName = enclosingFunc ? extractFuncNameFromSourceId(enclosingFunc) : '';
+                receiverTypeName = lookupReceiverType(verifiedReceivers, funcName, receiverName);
+            }
+            // Fall back to class-as-receiver for static method calls (e.g. UserService.find_user()).
+            // When the receiver name is not a variable in TypeEnv but resolves to a Class/Struct/Interface
+            // 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')) {
+                    receiverTypeName = receiverName;
+                }
+            }
+            // Fall back to chained call resolution when the receiver is a call expression
+            // (e.g. svc.getUser().save() — receiver of save() is getUser(), not a simple identifier).
+            if (callForm === 'member' && !receiverTypeName && !receiverName) {
+                const receiverNode = extractReceiverNode(nameNode);
+                if (receiverNode && CALL_EXPRESSION_TYPES.has(receiverNode.type)) {
+                    const extracted = extractCallChain(receiverNode);
+                    if (extracted) {
+                        // Resolve the base receiver type if possible
+                        let baseType = extracted.baseReceiverName && typeEnv
+                            ? typeEnv.lookup(extracted.baseReceiverName, callNode)
+                            : undefined;
+                        if (!baseType && extracted.baseReceiverName && verifiedReceivers.size > 0) {
+                            const enclosingFunc = findEnclosingFunction(callNode, file.path, ctx);
+                            const funcName = enclosingFunc ? extractFuncNameFromSourceId(enclosingFunc) : '';
+                            baseType = lookupReceiverType(verifiedReceivers, funcName, extracted.baseReceiverName);
+                        }
+                        // Class-as-receiver for chain base (e.g. UserService.find_user().save())
+                        if (!baseType && 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')) {
+                                baseType = extracted.baseReceiverName;
+                            }
+                        }
+                        receiverTypeName = resolveChainedReceiver(extracted.chain, baseType, file.path, ctx);
+                    }
+                }
+            }
+            const resolved = resolveCallTarget({
+                calledName,
+                argCount: countCallArguments(callNode),
+                callForm,
+                receiverTypeName,
+            }, file.path, ctx);
             if (!resolved)
                 return;
-            // 5. Find the enclosing function (caller)
-            const callNode = captureMap['call'];
-            const enclosingFuncId = findEnclosingFunction(callNode, file.path, symbolTable);
-            // Use enclosing function as source, fallback to file for top-level calls
+            const enclosingFuncId = findEnclosingFunction(callNode, file.path, ctx);
             const sourceId = enclosingFuncId || generateId('File', file.path);
             const relId = generateId('CALLS', `${sourceId}:${calledName}->${resolved.nodeId}`);
             graph.addRelationship({
@@ -202,152 +257,216 @@ export const processCalls = async (graph, files, astCache, symbolTable, importMa
                 reason: resolved.reason,
             });
         });
-        // Tree is now owned by the LRU cache — no manual delete needed
+        ctx.clearCache();
+    }
+    if (skippedByLang && skippedByLang.size > 0) {
+        for (const [lang, count] of skippedByLang.entries()) {
+            console.warn(`[ingestion] Skipped ${count} ${lang} file(s) in call processing — ${lang} parser not available.`);
+        }
+    }
+    return collectedHeritage;
+};
+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');
+        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));
+        }
+    }
+    else {
+        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);
+    if (!hasParameterMetadata)
+        return kindFiltered;
+    return kindFiltered.filter(candidate => candidate.parameterCount === undefined || candidate.parameterCount === argCount);
 };
+const toResolveResult = (definition, tier) => ({
+    nodeId: definition.nodeId,
+    confidence: TIER_CONFIDENCE[tier],
+    reason: tier === 'same-file' ? 'same-file' : tier === 'import-scoped' ? 'import-resolved' : 'global',
+});
 /**
- * Resolve a function call to its target node ID using priority strategy:
- * A. Check imported files first (highest confidence)
- * B. Check local file definitions
- * C. Fuzzy global search (lowest confidence)
+ * Resolve a chain of intermediate method calls to find the receiver type for a
+ * final member call.  Called when the receiver of a call is itself a call
+ * expression (e.g. `svc.getUser().save()`).
  *
- * Returns confidence score so agents know what to trust.
+ * @param chainNames  Ordered list of method names from outermost to innermost
+ *                    intermediate call (e.g. ['getUser'] for `svc.getUser().save()`).
+ * @param baseReceiverTypeName  The already-resolved type of the base receiver
+ *                              (e.g. 'UserService' for `svc`), or undefined.
+ * @param currentFile  The file path for resolution context.
+ * @param ctx  The resolution context for symbol lookup.
+ * @returns The type name of the final intermediate call's return type, or undefined
+ *          if resolution fails at any step.
  */
-const resolveCallTarget = (calledName, currentFile, symbolTable, importMap) => {
-    // Strategy B first (cheapest — single map lookup): Check local file
-    const localNodeId = symbolTable.lookupExact(currentFile, calledName);
-    if (localNodeId) {
-        return { nodeId: localNodeId, confidence: 0.85, reason: 'same-file' };
+function resolveChainedReceiver(chainNames, baseReceiverTypeName, currentFile, ctx) {
+    let currentType = baseReceiverTypeName;
+    for (const name of chainNames) {
+        const resolved = resolveCallTarget({ calledName: name, callForm: 'member', receiverTypeName: currentType }, currentFile, ctx);
+        if (!resolved)
+            return undefined;
+        const candidates = ctx.symbols.lookupFuzzy(name);
+        const symDef = candidates.find(c => c.nodeId === resolved.nodeId);
+        if (!symDef?.returnType)
+            return undefined;
+        const returnTypeName = extractReturnTypeName(symDef.returnType);
+        if (!returnTypeName)
+            return undefined;
+        currentType = returnTypeName;
     }
-    // Strategy A: Check if any definition of calledName is in an imported file
-    // Reversed: instead of iterating all imports and checking each, get all definitions
-    // and check if any is imported. O(definitions) instead of O(imports).
-    const allDefs = symbolTable.lookupFuzzy(calledName);
-    if (allDefs.length > 0) {
-        const importedFiles = importMap.get(currentFile);
-        if (importedFiles) {
-            for (const def of allDefs) {
-                if (importedFiles.has(def.filePath)) {
-                    return { nodeId: def.nodeId, confidence: 0.9, reason: 'import-resolved' };
-                }
+    return currentType;
+}
+/**
+ * Resolve a function call to its target node ID using priority strategy:
+ * A. Narrow candidates by scope tier via ctx.resolve()
+ * B. Filter to callable symbol kinds (constructor-aware when callForm is set)
+ * C. Apply arity filtering when parameter metadata is available
+ * D. Apply receiver-type filtering for member calls with typed receivers
+ *
+ * If filtering still leaves multiple candidates, refuse to emit a CALLS edge.
+ */
+const resolveCallTarget = (call, currentFile, ctx) => {
+    const tiered = ctx.resolve(call.calledName, currentFile);
+    if (!tiered)
+        return null;
+    const filteredCandidates = filterCallableCandidates(tiered.candidates, call.argCount, call.callForm);
+    // D. Receiver-type filtering: for member calls with a known receiver type,
+    // resolve the type through the same tiered import infrastructure, then
+    // filter method candidates to the type's defining file. Fall back to
+    // fuzzy ownerId matching only when file-based narrowing is inconclusive.
+    //
+    // Applied regardless of candidate count — the sole same-file candidate may
+    // belong to the wrong class (e.g. super.save() should hit the parent's save,
+    // not the child's own save method in the same file).
+    if (call.callForm === 'member' && call.receiverTypeName) {
+        // 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));
+            // 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.
+            const methodPool = filteredCandidates.length <= 1
+                ? 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));
+            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));
+            if (ownerFiltered.length === 1) {
+                return toResolveResult(ownerFiltered[0], tiered.tier);
             }
+            if (fileFiltered.length > 1 || ownerFiltered.length > 1)
+                return null;
         }
-        // Strategy C: Fuzzy global (no import match found)
-        const confidence = allDefs.length === 1 ? 0.5 : 0.3;
-        return { nodeId: allDefs[0].nodeId, confidence, reason: 'fuzzy-global' };
     }
-    return null;
+    if (filteredCandidates.length !== 1)
+        return null;
+    return toResolveResult(filteredCandidates[0], tiered.tier);
+};
+// ── Scope key helpers ────────────────────────────────────────────────────
+// Scope keys use the format "funcName@startIndex" (produced by type-env.ts).
+// Source IDs use "Label:filepath:funcName" (produced by parse-worker.ts).
+// NUL (\0) is used as a composite-key separator because it cannot appear
+// in source-code identifiers, preventing ambiguous concatenation.
+//
+// receiverKey stores the FULL scope (funcName@startIndex) to prevent
+// collisions between overloaded methods with the same name in different
+// classes (e.g. User.save@100 and Repo.save@200 are distinct keys).
+// Lookup uses a secondary funcName-only index built in lookupReceiverType.
+/** Extract the function name from a scope key ("funcName@startIndex" → "funcName"). */
+const extractFuncNameFromScope = (scope) => scope.slice(0, scope.indexOf('@'));
+/** Extract the trailing function name from a sourceId ("Function:filepath:funcName" → "funcName"). */
+const extractFuncNameFromSourceId = (sourceId) => {
+    const lastColon = sourceId.lastIndexOf(':');
+    return lastColon >= 0 ? sourceId.slice(lastColon + 1) : '';
 };
 /**
- * Filter out common built-in functions and noise
- * that shouldn't be tracked as calls
+ * Build a composite key for receiver type storage.
+ * Uses the full scope string (e.g. "save@100") to distinguish overloaded
+ * methods with the same name in different classes.
  */
-/** Pre-built set (module-level singleton) to avoid re-creating per call */
-const BUILT_IN_NAMES = new Set([
-    // JavaScript/TypeScript built-ins
-    'console', 'log', 'warn', 'error', 'info', 'debug',
-    'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval',
-    'parseInt', 'parseFloat', 'isNaN', 'isFinite',
-    'encodeURI', 'decodeURI', 'encodeURIComponent', 'decodeURIComponent',
-    'JSON', 'parse', 'stringify',
-    'Object', 'Array', 'String', 'Number', 'Boolean', 'Symbol', 'BigInt',
-    'Map', 'Set', 'WeakMap', 'WeakSet',
-    'Promise', 'resolve', 'reject', 'then', 'catch', 'finally',
-    'Math', 'Date', 'RegExp', 'Error',
-    'require', 'import', 'export',
-    'fetch', 'Response', 'Request',
-    // React hooks and common functions
-    'useState', 'useEffect', 'useCallback', 'useMemo', 'useRef', 'useContext',
-    'useReducer', 'useLayoutEffect', 'useImperativeHandle', 'useDebugValue',
-    'createElement', 'createContext', 'createRef', 'forwardRef', 'memo', 'lazy',
-    // Common array/object methods
-    'map', 'filter', 'reduce', 'forEach', 'find', 'findIndex', 'some', 'every',
-    'includes', 'indexOf', 'slice', 'splice', 'concat', 'join', 'split',
-    'push', 'pop', 'shift', 'unshift', 'sort', 'reverse',
-    'keys', 'values', 'entries', 'assign', 'freeze', 'seal',
-    'hasOwnProperty', 'toString', 'valueOf',
-    // Python built-ins
-    'print', 'len', 'range', 'str', 'int', 'float', 'list', 'dict', 'set', 'tuple',
-    'open', 'read', 'write', 'close', 'append', 'extend', 'update',
-    'super', 'type', 'isinstance', 'issubclass', 'getattr', 'setattr', 'hasattr',
-    'enumerate', 'zip', 'sorted', 'reversed', 'min', 'max', 'sum', 'abs',
-    // Kotlin stdlib (IMPORTANT: keep in sync with parse-worker.ts BUILT_IN_NAMES)
-    'println', 'print', 'readLine', 'require', 'requireNotNull', 'check', 'assert', 'lazy', 'error',
-    'listOf', 'mapOf', 'setOf', 'mutableListOf', 'mutableMapOf', 'mutableSetOf',
-    'arrayOf', 'sequenceOf', 'also', 'apply', 'run', 'with', 'takeIf', 'takeUnless',
-    'TODO', 'buildString', 'buildList', 'buildMap', 'buildSet',
-    'repeat', 'synchronized',
-    // Kotlin coroutine builders & scope functions
-    'launch', 'async', 'runBlocking', 'withContext', 'coroutineScope',
-    'supervisorScope', 'delay',
-    // Kotlin Flow operators
-    'flow', 'flowOf', 'collect', 'emit', 'onEach', 'catch',
-    'buffer', 'conflate', 'distinctUntilChanged',
-    'flatMapLatest', 'flatMapMerge', 'combine',
-    'stateIn', 'shareIn', 'launchIn',
-    // Kotlin infix stdlib functions
-    'to', 'until', 'downTo', 'step',
-    // C/C++ standard library and common kernel helpers
-    'printf', 'fprintf', 'sprintf', 'snprintf', 'vprintf', 'vfprintf', 'vsprintf', 'vsnprintf',
-    'scanf', 'fscanf', 'sscanf',
-    'malloc', 'calloc', 'realloc', 'free', 'memcpy', 'memmove', 'memset', 'memcmp',
-    'strlen', 'strcpy', 'strncpy', 'strcat', 'strncat', 'strcmp', 'strncmp', 'strstr', 'strchr', 'strrchr',
-    'atoi', 'atol', 'atof', 'strtol', 'strtoul', 'strtoll', 'strtoull', 'strtod',
-    'sizeof', 'offsetof', 'typeof',
-    'assert', 'abort', 'exit', '_exit',
-    'fopen', 'fclose', 'fread', 'fwrite', 'fseek', 'ftell', 'rewind', 'fflush', 'fgets', 'fputs',
-    // Linux kernel common macros/helpers (not real call targets)
-    'likely', 'unlikely', 'BUG', 'BUG_ON', 'WARN', 'WARN_ON', 'WARN_ONCE',
-    'IS_ERR', 'PTR_ERR', 'ERR_PTR', 'IS_ERR_OR_NULL',
-    'ARRAY_SIZE', 'container_of', 'list_for_each_entry', 'list_for_each_entry_safe',
-    'min', 'max', 'clamp', 'abs', 'swap',
-    'pr_info', 'pr_warn', 'pr_err', 'pr_debug', 'pr_notice', 'pr_crit', 'pr_emerg',
-    'printk', 'dev_info', 'dev_warn', 'dev_err', 'dev_dbg',
-    'GFP_KERNEL', 'GFP_ATOMIC',
-    'spin_lock', 'spin_unlock', 'spin_lock_irqsave', 'spin_unlock_irqrestore',
-    'mutex_lock', 'mutex_unlock', 'mutex_init',
-    'kfree', 'kmalloc', 'kzalloc', 'kcalloc', 'krealloc', 'kvmalloc', 'kvfree',
-    'get', 'put',
-    // Swift/iOS built-ins and standard library
-    'print', 'debugPrint', 'dump', 'fatalError', 'precondition', 'preconditionFailure',
-    'assert', 'assertionFailure', 'NSLog',
-    'abs', 'min', 'max', 'zip', 'stride', 'sequence', 'repeatElement',
-    'swap', 'withUnsafePointer', 'withUnsafeMutablePointer', 'withUnsafeBytes',
-    'autoreleasepool', 'unsafeBitCast', 'unsafeDowncast', 'numericCast',
-    'type', 'MemoryLayout',
-    // Swift collection/string methods (common noise)
-    'map', 'flatMap', 'compactMap', 'filter', 'reduce', 'forEach', 'contains',
-    'first', 'last', 'prefix', 'suffix', 'dropFirst', 'dropLast',
-    'sorted', 'reversed', 'enumerated', 'joined', 'split',
-    'append', 'insert', 'remove', 'removeAll', 'removeFirst', 'removeLast',
-    'isEmpty', 'count', 'index', 'startIndex', 'endIndex',
-    // UIKit/Foundation common methods (noise in call graph)
-    'addSubview', 'removeFromSuperview', 'layoutSubviews', 'setNeedsLayout',
-    'layoutIfNeeded', 'setNeedsDisplay', 'invalidateIntrinsicContentSize',
-    'addTarget', 'removeTarget', 'addGestureRecognizer',
-    'addConstraint', 'addConstraints', 'removeConstraint', 'removeConstraints',
-    'NSLocalizedString', 'Bundle',
-    'reloadData', 'reloadSections', 'reloadRows', 'performBatchUpdates',
-    'register', 'dequeueReusableCell', 'dequeueReusableSupplementaryView',
-    'beginUpdates', 'endUpdates', 'insertRows', 'deleteRows', 'insertSections', 'deleteSections',
-    'present', 'dismiss', 'pushViewController', 'popViewController', 'popToRootViewController',
-    'performSegue', 'prepare',
-    // GCD / async
-    'DispatchQueue', 'async', 'sync', 'asyncAfter',
-    'Task', 'withCheckedContinuation', 'withCheckedThrowingContinuation',
-    // Combine
-    'sink', 'store', 'assign', 'receive', 'subscribe',
-    // Notification / KVO
-    'addObserver', 'removeObserver', 'post', 'NotificationCenter',
-]);
-const isBuiltInOrNoise = (name) => BUILT_IN_NAMES.has(name);
+const receiverKey = (scope, varName) => `${scope}\0${varName}`;
+/**
+ * Look up a receiver type from a verified receiver map.
+ * The map is keyed by `scope\0varName` (full scope with @startIndex).
+ * Since the lookup side only has `funcName` (no startIndex), we scan for
+ * all entries whose key starts with `funcName@` and has the matching varName.
+ * If exactly one unique type is found, return it. If multiple distinct types
+ * exist (true overload collision), return undefined (refuse to guess).
+ * Falls back to the file-level scope key `\0varName` (empty funcName).
+ */
+const lookupReceiverType = (map, funcName, varName) => {
+    // Fast path: file-level scope (empty funcName — used as fallback)
+    const fileLevelKey = receiverKey('', varName);
+    const prefix = `${funcName}@`;
+    const suffix = `\0${varName}`;
+    let found;
+    let ambiguous = false;
+    for (const [key, value] of map) {
+        if (key === fileLevelKey)
+            continue; // handled separately below
+        if (key.startsWith(prefix) && key.endsWith(suffix)) {
+            // Verify the key is exactly "funcName@<digits>\0varName" with no extra chars.
+            // The part between prefix and suffix should be the startIndex (digits only),
+            // but we accept any non-empty segment to be forward-compatible.
+            const middle = key.slice(prefix.length, key.length - suffix.length);
+            if (middle.length === 0)
+                continue; // malformed key — skip
+            if (found === undefined) {
+                found = value;
+            }
+            else if (found !== value) {
+                ambiguous = true;
+                break;
+            }
+        }
+    }
+    if (!ambiguous && found !== undefined)
+        return found;
+    // Fallback: file-level scope (bindings outside any function)
+    return map.get(fileLevelKey);
+};
 /**
  * Fast path: resolve pre-extracted call sites from workers.
  * No AST parsing — workers already extracted calledName + sourceId.
- * This function only does symbol table lookups + graph mutations.
  */
-export const processCallsFromExtracted = async (graph, extractedCalls, symbolTable, importMap, onProgress) => {
-    // Group by file for progress reporting
+export const processCallsFromExtracted = async (graph, extractedCalls, ctx, onProgress, constructorBindings) => {
+    // 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.
+    const fileReceiverTypes = new Map();
+    if (constructorBindings) {
+        for (const { filePath, bindings } of constructorBindings) {
+            const verified = verifyConstructorBindings(bindings, filePath, ctx, graph);
+            if (verified.size > 0) {
+                fileReceiverTypes.set(filePath, verified);
+            }
+        }
+    }
     const byFile = new Map();
     for (const call of extractedCalls) {
         let list = byFile.get(call.filePath);
@@ -359,33 +478,72 @@ export const processCallsFromExtracted = async (graph, extractedCalls, symbolTab
     }
     const totalFiles = byFile.size;
     let filesProcessed = 0;
-    for (const [_filePath, calls] of byFile) {
+    for (const [filePath, calls] of byFile) {
         filesProcessed++;
         if (filesProcessed % 100 === 0) {
             onProgress?.(filesProcessed, totalFiles);
             await yieldToEventLoop();
         }
+        ctx.enableCache(filePath);
+        const receiverMap = fileReceiverTypes.get(filePath);
         for (const call of calls) {
-            const resolved = resolveCallTarget(call.calledName, call.filePath, symbolTable, importMap);
+            let effectiveCall = call;
+            // Step 1: resolve receiver type from constructor bindings
+            if (!call.receiverTypeName && call.receiverName && receiverMap) {
+                const callFuncName = extractFuncNameFromSourceId(call.sourceId);
+                const resolvedType = lookupReceiverType(receiverMap, callFuncName, call.receiverName);
+                if (resolvedType) {
+                    effectiveCall = { ...call, receiverTypeName: resolvedType };
+                }
+            }
+            // Step 1b: class-as-receiver for static method calls (e.g. UserService.find_user())
+            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')) {
+                    effectiveCall = { ...effectiveCall, receiverTypeName: effectiveCall.receiverName };
+                }
+            }
+            // Step 2: if the call has a receiver call chain (e.g. svc.getUser().save()),
+            // resolve the chain to determine the final receiver type.
+            // This runs whenever receiverCallChain is present — even when Step 1 set a
+            // receiverTypeName, that type is the BASE receiver (e.g. UserService for svc),
+            // and the chain must be walked to produce the FINAL receiver (e.g. User from
+            // getUser() : User).
+            if (effectiveCall.receiverCallChain?.length) {
+                // Step 1 may have resolved the base receiver type (e.g. svc → UserService).
+                // Use it as the starting point for chain resolution.
+                let baseType = effectiveCall.receiverTypeName;
+                // If Step 1 didn't resolve it, try the receiver map directly.
+                if (!baseType && effectiveCall.receiverName && receiverMap) {
+                    const callFuncName = extractFuncNameFromSourceId(effectiveCall.sourceId);
+                    baseType = lookupReceiverType(receiverMap, callFuncName, effectiveCall.receiverName);
+                }
+                const chainedType = resolveChainedReceiver(effectiveCall.receiverCallChain, baseType, effectiveCall.filePath, ctx);
+                if (chainedType) {
+                    effectiveCall = { ...effectiveCall, receiverTypeName: chainedType };
+                }
+            }
+            const resolved = resolveCallTarget(effectiveCall, effectiveCall.filePath, ctx);
             if (!resolved)
                 continue;
-            const relId = generateId('CALLS', `${call.sourceId}:${call.calledName}->${resolved.nodeId}`);
+            const relId = generateId('CALLS', `${effectiveCall.sourceId}:${effectiveCall.calledName}->${resolved.nodeId}`);
             graph.addRelationship({
                 id: relId,
-                sourceId: call.sourceId,
+                sourceId: effectiveCall.sourceId,
                 targetId: resolved.nodeId,
                 type: 'CALLS',
                 confidence: resolved.confidence,
                 reason: resolved.reason,
             });
         }
+        ctx.clearCache();
     }
     onProgress?.(totalFiles, totalFiles);
 };
 /**
  * Resolve pre-extracted Laravel routes to CALLS edges from route files to controller methods.
  */
-export const processRoutesFromExtracted = async (graph, extractedRoutes, symbolTable, importMap, onProgress) => {
+export const processRoutesFromExtracted = async (graph, extractedRoutes, ctx, onProgress) => {
     for (let i = 0; i < extractedRoutes.length; i++) {
         const route = extractedRoutes[i];
         if (i % 50 === 0) {
@@ -394,28 +552,17 @@ export const processRoutesFromExtracted = async (graph, extractedRoutes, symbolT
         }
         if (!route.controllerName || !route.methodName)
             continue;
-        // Resolve controller class in symbol table
-        const controllerDefs = symbolTable.lookupFuzzy(route.controllerName);
-        if (controllerDefs.length === 0)
+        const controllerResolved = ctx.resolve(route.controllerName, route.filePath);
+        if (!controllerResolved || controllerResolved.candidates.length === 0)
             continue;
-        // Prefer import-resolved match
-        const importedFiles = importMap.get(route.filePath);
-        let controllerDef = controllerDefs[0];
-        let confidence = controllerDefs.length === 1 ? 0.7 : 0.5;
-        if (importedFiles) {
-            for (const def of controllerDefs) {
-                if (importedFiles.has(def.filePath)) {
-                    controllerDef = def;
-                    confidence = 0.9;
-                    break;
-                }
-            }
-        }
-        // Find the method on the controller
-        const methodId = symbolTable.lookupExact(controllerDef.filePath, route.methodName);
+        if (controllerResolved.tier === 'global' && controllerResolved.candidates.length > 1)
+            continue;
+        const controllerDef = controllerResolved.candidates[0];
+        const confidence = TIER_CONFIDENCE[controllerResolved.tier];
+        const methodResolved = ctx.resolve(route.methodName, controllerDef.filePath);
+        const methodId = methodResolved?.tier === 'same-file' ? methodResolved.candidates[0]?.nodeId : undefined;
         const sourceId = generateId('File', route.filePath);
         if (!methodId) {
-            // Construct method ID manually
             const guessedId = generateId('Method', `${controllerDef.filePath}:${route.methodName}`);
             const relId = generateId('CALLS', `${sourceId}:route->${guessedId}`);
             graph.addRelationship({