fix: resolve merge conflicts with main

Author: carlos-alm

src/domain/graph/builder/call-resolver.ts

@@ -198,7 +198,11 @@ export function resolveByMethodOrGlobal(
     if (call.receiver && callerName) {
       const dotIdx = callerName.lastIndexOf('.');
       if (dotIdx > -1) {
-        const callerClass = callerName.slice(0, dotIdx);
+        // Extract only the segment immediately before the method name so that
+        // 'Namespace.ClassName.method' yields 'ClassName', not 'Namespace.ClassName'.
+        // Symbols are stored under their bare class name, not their qualified path.
+        const prevDot = callerName.lastIndexOf('.', dotIdx - 1);
+        const callerClass = callerName.slice(prevDot + 1, dotIdx);
         const qualifiedName = `${callerClass}.${call.name}`;
         const sameClass = lookup
           .byName(qualifiedName)

src/domain/graph/builder/incremental.ts

@@ -538,14 +538,15 @@ function buildCallEdges(
     if (call.receiver && BUILTIN_RECEIVERS.has(call.receiver)) continue;
 
     const caller = findCaller(lookup, call, symbols.definitions, relPath, fileNodeRow);
-    let { targets, importedFrom } = resolveCallTargets(
+    const { targets: initialTargets, importedFrom } = resolveCallTargets(
       lookup,
       call,
       relPath,
       importedNames,
       typeMap,
       caller.callerName,
     );
+    let targets = initialTargets;
 
     if (targets.length === 0 && call.receiver === 'this' && caller.callerName != null) {
       const dotIdx = caller.callerName.indexOf('.');
@@ -583,7 +584,11 @@ function buildCallEdges(
           }
         }
         if (targets.length === 0) {
-          const sameFile = lookup.byNameAndFile(call.name, relPath);
+          // Narrow to function/method kinds only to avoid matching unrelated
+          // variables or classes that share a name in the same file.
+          const sameFile = lookup
+            .byNameAndFile(call.name, relPath)
+            .filter((n) => n.kind === 'function' || n.kind === 'method');
           if (sameFile.length > 0) {
             targets = [...sameFile];
           }

src/domain/graph/builder/stages/native-orchestrator.ts

@@ -669,6 +669,51 @@ async function runPostNativePrototypeMethods(
 
   db.transaction(() => batchInsertNodes(db, newNodeRows))();
 
+  // ── Caller-only second pass (#1371) ──────────────────────────────────────
+  // `wasmResults` only covers `protoFiles` (definition files). A file that
+  // only *calls* a newly-inserted method (e.g. `f.method()`) was excluded from
+  // the pre-filter, so its call edges to the new nodes are silently dropped.
+  // After node insertion we know the method name suffixes; text-search the
+  // remaining JS/TS files and WASM-parse any that contain a matching call.
+  const newMethodSuffixes = new Set(
+    newDefs.map((d) => {
+      const dotIdx = d.name.indexOf('.');
+      return dotIdx !== -1 ? d.name.slice(dotIdx + 1) : d.name;
+    }),
+  );
+
+  let mergedWasmResults = wasmResults;
+  if (newMethodSuffixes.size > 0) {
+    // Pre-compile patterns once — avoids re-compiling up to newMethodSuffixes.size
+    // regexes on every file in the scan loop.
+    const suffixPatterns = [...newMethodSuffixes].map((m) => {
+      const escaped = m.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      return new RegExp(`\\.${escaped}\\s*\\(`);
+    });
+    const protoFileSet = new Set(protoFiles);
+    const callerCandidateAbs: string[] = [];
+    for (const relPath of jsFiles) {
+      if (protoFileSet.has(relPath)) continue; // already parsed in first pass
+      try {
+        const content = readFileSafe(path.join(rootDir, relPath));
+        const matchesAny = suffixPatterns.some((re) => re.test(content));
+        if (matchesAny) callerCandidateAbs.push(path.join(rootDir, relPath));
+      } catch {
+        /* skip unreadable files */
+      }
+    }
+    if (callerCandidateAbs.length > 0) {
+      try {
+        const callerWasmResults = await parseFilesWasmForBackfill(callerCandidateAbs, rootDir);
+        if (callerWasmResults.size > 0) {
+          mergedWasmResults = new Map([...wasmResults, ...callerWasmResults]);
+        }
+      } catch (e) {
+        debug(`runPostNativePrototypeMethods: caller-only WASM parse failed: ${toErrorMessage(e)}`);
+      }
+    }
+  }
+
   // Build a name → node lookup from all DB nodes (including newly inserted ones).
   type NodeEntry = { id: number; file: string; kind: string };
   const byNameMap = new Map<string, NodeEntry[]>();
@@ -716,14 +761,13 @@ async function runPostNativePrototypeMethods(
   // zero benefit and could OOM on large repositories.
   const seenByPair = new Set<string>();
 
-  // Resolve call edges in every file — not just those that define new func-prop
-  // methods. A caller in app.js calling a method defined in lib.js
-  // would be silently missed if we only scanned definition files.
-  // The newNodeIds guard inside the loop already prevents duplicate edges.
+  // Resolve call edges across all parsed files (definition files + caller-only
+  // files discovered in the second WASM pass above). The newNodeIds guard inside
+  // the loop prevents emitting duplicate edges for nodes the Rust engine already built.
   const newEdgeRows: unknown[][] = [];
   const fileNodeStmt = db.prepare(`SELECT id FROM nodes WHERE kind = 'file' AND file = ?`);
 
-  for (const [relPath, symbols] of wasmResults) {
+  for (const [relPath, symbols] of mergedWasmResults) {
     const fileNodeRow = fileNodeStmt.get(relPath) as { id: number } | undefined;
     if (!fileNodeRow) continue;
 
@@ -734,14 +778,32 @@ async function runPostNativePrototypeMethods(
 
       const caller = findCaller(lookup, call, symbols.definitions ?? [], relPath, fileNodeRow);
 
-      const targets = resolveByMethodOrGlobal(
+      let targets = resolveByMethodOrGlobal(
         lookup,
         call,
         relPath,
         typeMap as Map<string, unknown>,
         caller.callerName,
       );
 
+      // Direct receiver.method fallback: caller-only files often lack typeMap entries
+      // for the receiver (e.g. `f.process()` where `f` isn't declared in the file).
+      // Try qualified-name lookup scoped to newly-inserted nodes to avoid false positives.
+      // Note: `call.receiver` is always truthy here — the `if (!call.receiver) continue`
+      // guard above ensures we never reach this point with a falsy receiver.
+      if (
+        targets.length === 0 &&
+        call.receiver !== 'this' &&
+        call.receiver !== 'super' &&
+        call.receiver !== 'self'
+      ) {
+        const qualifiedName = `${call.receiver}.${call.name}`;
+        const direct = lookup
+          .byName(qualifiedName)
+          .filter((n) => n.kind === 'method' && newNodeIds.has(n.id));
+        if (direct.length > 0) targets = direct;
+      }
+
       for (const t of targets) {
         // Only emit edges to newly-inserted func-prop nodes to avoid
         // duplicating edges the Rust engine already built.

src/domain/graph/resolver/points-to.ts

@@ -185,11 +185,29 @@ export function buildPointsToMap(
   // `function f({ ...rest }) {}` + `f(obj)` + `const obj = { prop: fn }` →
   // seed pts["rest.prop"] = {"fn"} so that `rest.prop()` resolves to `fn`.
   if (objectRestParamBindings && objectPropBindings && paramBindings) {
+    // Index paramBindings: "callee::argIndex" → argName[] (O(|paramBindings|) build,
+    // O(1) lookup — avoids scanning paramBindings for each rest binding).
+    const paramByCalleeIdx = new Map<string, string[]>();
+    for (const { callee, argIndex, argName } of paramBindings) {
+      const k = `${callee}::${argIndex}`;
+      const list = paramByCalleeIdx.get(k);
+      if (list) list.push(argName);
+      else paramByCalleeIdx.set(k, [argName]);
+    }
+
+    // Index objectPropBindings: objectName → {propName, valueName}[]
+    const propsByObject = new Map<string, Array<{ propName: string; valueName: string }>>();
+    for (const { objectName, propName, valueName } of objectPropBindings) {
+      const list = propsByObject.get(objectName);
+      if (list) list.push({ propName, valueName });
+      else propsByObject.set(objectName, [{ propName, valueName }]);
+    }
+
     for (const { callee, restName, argIndex } of objectRestParamBindings) {
-      for (const { callee: pbCallee, argIndex: pbArgIdx, argName } of paramBindings) {
-        if (pbCallee !== callee || pbArgIdx !== argIndex) continue;
-        for (const { objectName, propName, valueName } of objectPropBindings) {
-          if (objectName !== argName) continue;
+      const argNames = paramByCalleeIdx.get(`${callee}::${argIndex}`) ?? [];
+      for (const argName of argNames) {
+        const props = propsByObject.get(argName) ?? [];
+        for (const { propName, valueName } of props) {
           if (!definitionNames.has(valueName) && !importedNames.has(valueName)) continue;
           const key = `${restName}.${propName}`;
           if (!pts.has(key)) pts.set(key, new Set());

src/extractors/javascript.ts

@@ -2143,6 +2143,31 @@ function extractParamBindingsWalk(rootNode: TreeSitterNode, paramBindings: Param
           if (ct === ',' || ct === '(' || ct === ')') continue;
           if (ct === 'identifier' && !BUILTIN_GLOBALS.has(child.text)) {
             paramBindings.push({ callee: fn.text, argIndex: argIdx, argName: child.text });
+          } else if (ct === 'spread_element') {
+            // f(...[a, b]) — inline array literal: expand each element as a direct param binding.
+            const inner =
+              child.childForFieldName('argument') ?? (child.childCount > 1 ? child.child(1) : null);
+            if (inner?.type === 'array') {
+              let elemCount = 0;
+              for (let j = 0; j < inner.childCount; j++) {
+                const elem = inner.child(j);
+                if (!elem) continue;
+                if (elem.type === ',' || elem.type === '[' || elem.type === ']') continue;
+                if (elem.type === 'identifier' && !BUILTIN_GLOBALS.has(elem.text)) {
+                  paramBindings.push({
+                    callee: fn.text,
+                    argIndex: argIdx + elemCount,
+                    argName: elem.text,
+                  });
+                }
+                elemCount++;
+              }
+              // Advance by the exact number of slots this spread occupies and skip
+              // the unconditional argIdx++ below so that zero-element spreads (...[])
+              // do not shift subsequent argument indices.
+              argIdx += elemCount;
+              continue;
+            }
           }
           argIdx++;
         }
@@ -2259,6 +2284,29 @@ function extractSpreadForOfWalk(
         funcStack.push(nameNode.text);
         pushedFunc = true;
       }
+    } else if (node.type === 'assignment_expression') {
+      // `obj.method = function() { ... }` — func-prop assignment.
+      // Mirror handleFuncPropAssignment's logic so for-of loops inside the
+      // body get the correct enclosingFunc (e.g. 'obj.method') instead of
+      // '<module>' or the wrong outer function name.
+      const lhs = node.childForFieldName('left');
+      const rhs = node.childForFieldName('right');
+      if (
+        lhs?.type === 'member_expression' &&
+        (rhs?.type === 'function_expression' || rhs?.type === 'arrow_function')
+      ) {
+        const obj = lhs.childForFieldName('object');
+        const prop = lhs.childForFieldName('property');
+        if (
+          obj?.type === 'identifier' &&
+          (prop?.type === 'property_identifier' || prop?.type === 'identifier') &&
+          !BUILTIN_GLOBALS.has(obj.text) &&
+          prop.text !== 'prototype'
+        ) {
+          funcStack.push(`${obj.text}.${prop.text}`);
+          pushedFunc = true;
+        }
+      }
     }
 
     if (node.type === 'call_expression') {

src/infrastructure/native.ts

@@ -6,6 +6,7 @@
  * to the existing WASM pipeline.
  */
 
+import { existsSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import os from 'node:os';
 import { fileURLToPath } from 'node:url';
@@ -112,17 +113,27 @@ export function loadNative(): NativeAddon | null {
 
   // 2. Locally compiled dev binary — preferred over npm package so that Rust
   //    changes are visible without publishing. Only used when the file exists.
+  //    If the file exists but fails to load (e.g. stale ABI), we warn and halt
+  //    rather than silently falling through to the npm package — that would
+  //    defeat the purpose of this priority order.
   const localFile = PLATFORM_LOCAL_BINARIES[platformKey];
   if (localFile) {
-    try {
-      const localPath = fileURLToPath(
-        new URL(`../../crates/codegraph-core/${localFile}`, import.meta.url),
-      );
-      _cached = _require(localPath) as NativeAddon;
-      debug(`loadNative: loaded local dev binary: ${localPath}`);
-      return _cached;
-    } catch (err) {
-      debug(`loadNative: local dev binary not available: ${toErrorMessage(err as Error)}`);
+    const localPath = fileURLToPath(
+      new URL(`../../crates/codegraph-core/${localFile}`, import.meta.url),
+    );
+    if (existsSync(localPath)) {
+      try {
+        _cached = _require(localPath) as NativeAddon;
+        debug(`loadNative: loaded local dev binary: ${localPath}`);
+        return _cached;
+      } catch (err) {
+        _loadError = err as Error;
+        warn(
+          `loadNative: local dev binary exists but failed to load "${localPath}": ${toErrorMessage(err as Error)}`,
+        );
+        _cached = null;
+        return null;
+      }
     }
   }
 
@@ -131,6 +142,7 @@ export function loadNative(): NativeAddon | null {
   if (pkg) {
     try {
       _cached = _require(pkg) as NativeAddon;
+      debug(`loadNative: loaded npm package: ${pkg}`);
       return _cached;
     } catch (err) {
       _loadError = err as Error;
@@ -154,6 +166,10 @@ export function isNativeAvailable(): boolean {
 /**
  * Read the version from the platform-specific npm package.json.
  * Returns null if the package is not installed or has no version.
+ *
+ * Note: always reports the npm package version. When the local dev binary or
+ * NAPI_RS_NATIVE_LIBRARY_PATH is loaded instead, this version may not match
+ * the running binary.
  */
 export function getNativePackageVersion(): string | null {
   const pkg = resolvePlatformPackage();