fix: resolve merge conflicts with main

Author: carlos-alm

crates/codegraph-core/src/extractors/csharp.rs

@@ -455,7 +455,27 @@ fn match_csharp_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbols,
         "variable_declaration" => {
             let type_node = node.child_by_field_name("type").or_else(|| node.child(0));
             if let Some(type_node) = type_node {
-                if type_node.kind() != "var_keyword" && type_node.kind() != "implicit_type" {
+                if type_node.kind() == "implicit_type" {
+                    // var x = new Foo() — infer type from object_creation_expression initializer
+                    for i in 0..node.child_count() {
+                        if let Some(declarator) = node.child(i) {
+                            if declarator.kind() != "variable_declarator" { continue; }
+                            let name_node = declarator.child_by_field_name("name")
+                                .or_else(|| declarator.child(0));
+                            let Some(name_node) = name_node else { continue };
+                            if name_node.kind() != "identifier" { continue; }
+                            let Some(obj_creation) = find_child(&declarator, "object_creation_expression") else { continue };
+                            let Some(ctor_type_node) = obj_creation.child_by_field_name("type") else { continue };
+                            if let Some(ctor_type) = extract_csharp_type_name(&ctor_type_node, source) {
+                                symbols.type_map.push(TypeMapEntry {
+                                    name: node_text(&name_node, source).to_string(),
+                                    type_name: ctor_type.to_string(),
+                                    confidence: 1.0,
+                                });
+                            }
+                        }
+                    }
+                } else if type_node.kind() != "var_keyword" {
                     if let Some(type_name) = extract_csharp_type_name(&type_node, source) {
                         for i in 0..node.child_count() {
                             if let Some(child) = node.child(i) {

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

@@ -23,6 +23,28 @@ export interface CallNodeLookup {
 
 export const RECEIVER_KINDS = new Set(['class', 'struct', 'interface', 'type', 'module']);
 
+/**
+ * Languages where bare `foo()` calls inside a class method are lexically scoped
+ * to the module, not the class — there is no implicit this/class binding.
+ * For these languages, the same-class fallback must not run for bare (no-receiver)
+ * calls that found no exact same-file match.
+ */
+const MODULE_SCOPED_BARE_CALL_EXTENSIONS = new Set([
+  '.js',
+  '.mjs',
+  '.cjs',
+  '.jsx',
+  '.ts',
+  '.tsx',
+  '.mts',
+  '.cts',
+]);
+
+export function isModuleScopedLanguage(relPath: string): boolean {
+  const ext = relPath.slice(relPath.lastIndexOf('.'));
+  return MODULE_SCOPED_BARE_CALL_EXTENSIONS.has(ext);
+}
+
 // ── Shared resolution functions ──────────────────────────────────────────
 
 export function findCaller(
@@ -94,12 +116,15 @@ export function resolveByMethodOrGlobal(
         : (typeEntry as { type?: string }).type
       : null;
 
-    // Handle inline new-expression receivers: `(new Foo).bar()` or `(new Foo()).bar()`.
-    // extractReceiverName returns the raw node text for non-identifier nodes, so `(new A).t()`
-    // produces receiver='(new A)'. Extract the constructor name directly.
-    // The regex intentionally restricts to uppercase-initial names ([A-Z_$]) as a heuristic
-    // to distinguish constructors (PascalCase) from regular functions — avoiding false positives
-    // on `(new xmlParser()).parse()` style calls which are rare in practice.
+    // Belt-and-suspenders fallback for inline new-expression receivers that
+    // extractReceiverName did not normalise (e.g. raw text leaked from an
+    // unhandled AST node type).  extractReceiverName already handles the common
+    // `new_expression` / `parenthesized_expression(new_expression)` shapes by
+    // returning the constructor name directly, so this branch is exercised only
+    // by future node types or constructs that fall through to the raw-text path.
+    // The uppercase-initial restriction ([A-Z_$]) is a heuristic to distinguish
+    // constructors (PascalCase) from regular functions and avoids false positives
+    // on `(new xmlParser()).parse()` style calls.
     if (!typeName && call.receiver) {
       const m = /^\(?\s*new\s+([A-Z_$][A-Za-z0-9_$]*)/.exec(call.receiver);
       if (m?.[1]) typeName = m[1];
@@ -203,7 +228,14 @@ export function resolveByMethodOrGlobal(
     // Also covers no-receiver calls inside class methods, e.g. `IsValidEmail(x)` inside
     // `Validators.ValidateUser` → try `Validators.IsValidEmail` (C#/Java static siblings).
     // This seeds the initial edge that runChaPostPass later expands to subclass overrides.
-    if (callerName) {
+    //
+    // For JS/TS, bare (no-receiver) calls are module-scoped — there is no implicit class
+    // binding. Skip the same-class fallback for bare calls in those languages to prevent
+    // false positives (e.g. `flush()` inside `Processor.run` must not resolve to
+    // `Processor.flush`). this.method() calls are unaffected: they still reach the fallback
+    // because `call.receiver === 'this'` is truthy, not a bare call.
+    const isBareCall = !call.receiver;
+    if (callerName && !(isBareCall && isModuleScopedLanguage(relPath))) {
       const dotIdx = callerName.lastIndexOf('.');
       if (dotIdx > -1) {
         // Extract only the segment immediately before the method name so that

src/domain/graph/builder/stages/build-edges.ts

@@ -30,6 +30,7 @@ import { enrichTypeMapWithTsc } from '../../resolver/ts-resolver.js';
 import {
   type CallNodeLookup,
   findCaller,
+  isModuleScopedLanguage,
   resolveCallTargets,
   resolveReceiverEdge,
 } from '../call-resolver.js';
@@ -1340,9 +1341,35 @@ function buildFileCallEdges(
     // not the enclosing class, so qualifying with the child class name would
     // produce a false edge when the child also defines a same-named method.
     if (targets.length === 0 && call.receiver === 'this' && caller.callerName != null) {
-      const dotIdx = caller.callerName.indexOf('.');
-      if (dotIdx > 0) {
-        const className = caller.callerName.slice(0, dotIdx);
+      const lastDot = caller.callerName.lastIndexOf('.');
+      if (lastDot > 0) {
+        const prevDot = caller.callerName.lastIndexOf('.', lastDot - 1);
+        const className = caller.callerName.slice(prevDot + 1, lastDot);
+        const qualifiedName = `${className}.${call.name}`;
+        const qualified = lookup
+          .byNameAndFile(qualifiedName, relPath)
+          .filter((n) => n.kind === 'method');
+        if (qualified.length > 0) {
+          targets = qualified;
+        }
+      }
+    }
+
+    // Same-class bare-call fallback: when a no-receiver call can't be resolved
+    // globally, try the caller's own class as a qualifier. Handles C# static
+    // sibling calls: `IsValidEmail()` inside `Validators.ValidateUser` resolves
+    // to `Validators.IsValidEmail`. Skipped for JS/TS where bare calls are
+    // module-scoped, not class-scoped.
+    if (
+      targets.length === 0 &&
+      !call.receiver &&
+      caller.callerName != null &&
+      !isModuleScopedLanguage(relPath)
+    ) {
+      const lastDot = caller.callerName.lastIndexOf('.');
+      if (lastDot > 0) {
+        const prevDot = caller.callerName.lastIndexOf('.', lastDot - 1);
+        const className = caller.callerName.slice(prevDot + 1, lastDot);
         const qualifiedName = `${className}.${call.name}`;
         const qualified = lookup
           .byNameAndFile(qualifiedName, relPath)

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

@@ -402,9 +402,9 @@ async function runPostNativeAnalysis(
  * Note: `this`/`super` dispatch is handled separately by `runPostNativeThisDispatch`,
  * which WASM-re-parses JS/TS files to obtain raw call site receiver info.
  *
- * Returns the set of target node IDs for newly inserted CHA edges so the caller
- * can re-classify roles for the affected implementation files.  An empty set
- * means no edges were added and role re-classification is unnecessary.
+ * Returns the count of newly inserted CHA edges so the caller can determine
+ * whether a full role re-classification is needed.  Zero means no edges were
+ * added and role re-classification is unnecessary.
  */
 function runPostNativeCha(db: BetterSqlite3Database): number {
   // Fast guard: no hierarchy edges → no CHA work
@@ -1607,37 +1607,9 @@ export async function tryNativeOrchestrator(
   }
 
   // Phase 8.5: expand CHA call edges (interface dispatch → concrete implementations).
-  // The Rust orchestrator ran role classification BEFORE this post-pass, so without
-  // a re-run the newly-called implementor methods stay classified as `dead-ffi`.
-  //
-  // CHA also changes the global fan-out distribution (callee files gain fan_in, and
-  // new edges shift the median). A full re-classification is required — not just the
-  // callee files — because the median shift can change roles in unrelated files whose
-  // fan-out sits near the old median. (Example: a method that called two siblings
-  // pre-CHA might be near the median, but post-CHA the median is higher, changing
-  // its role from utility → core.) Using an incremental pass with a stale median
-  // cache would produce incorrect roles outside the CHA-affected file set.
-  //
-  // Performance: classifyNodeRoles is O(all_nodes). For most repos this is sub-100ms;
-  // on very large codebases (100k+ nodes) it may add a few hundred ms per build.
-  // If this becomes a bottleneck, consider a two-pass strategy: incremental first
-  // (fast, slightly inaccurate), then full only when the median shifts by >N%.
+  // Returns the count of newly inserted edges; used to determine whether
+  // a full role re-classification is needed after all edge-writing post-passes complete.
   const chaEdgeCount = runPostNativeCha(ctx.db as unknown as BetterSqlite3Database);
-  if (chaEdgeCount > 0) {
-    try {
-      const db = ctx.db as unknown as BetterSqlite3Database;
-      const { classifyNodeRoles } = (await import('../../../../features/structure.js')) as {
-        classifyNodeRoles: (
-          db: BetterSqlite3Database,
-          changedFiles?: string[] | null,
-        ) => Record<string, number>;
-      };
-      classifyNodeRoles(db);
-      debug(`CHA post-pass: full role re-classification after ${chaEdgeCount} new CHA edges`);
-    } catch (err) {
-      debug(`CHA post-pass role re-classification failed: ${toErrorMessage(err)}`);
-    }
-  }
 
   // Function-as-object-property post-pass: the Rust engine does not yet recognise
   // `fn.method = function() {}` patterns. Re-parse only those JS/TS files via
@@ -1659,51 +1631,23 @@ export async function tryNativeOrchestrator(
       !!result.isFullBuild,
     );
 
-  // Re-classify roles for methods that gained incoming this/super dispatch edges.
-  // The Rust orchestrator classifies roles BEFORE this post-pass, so target methods
-  // (e.g. Animal.speak, ConcreteWorker.prepare) that had no callers at Rust time
-  // are classified `dead` or `dead-ffi`.  Inserting the new call edges does not
-  // automatically update those role labels — without a re-run the stale labels
-  // propagate to dead-code detection and API boundary analysis.
-  if (thisDispatchTargetIds.size > 0) {
+  // Full role re-classification after JS edge-writing post-passes.
+  // The Rust orchestrator classifies roles before these post-passes (CHA,
+  // this-dispatch) add edges, so the Rust-computed roles and the cached
+  // fan-out medians are stale. A full re-classification ensures the final
+  // roles reflect the true fan-in/out with all edges in place.
+  if (chaEdgeCount > 0 || thisDispatchTargetIds.size > 0) {
     try {
-      const db = ctx.db as unknown as BetterSqlite3Database;
-      const idArray = Array.from(thisDispatchTargetIds);
-      const CHUNK_SIZE = 500;
-      const seenFiles = new Set<string>();
-      const affectedFiles: Array<{ file: string }> = [];
-      for (let i = 0; i < idArray.length; i += CHUNK_SIZE) {
-        const chunk = idArray.slice(i, i + CHUNK_SIZE);
-        const placeholders = chunk.map(() => '?').join(',');
-        const rows = db
-          .prepare(
-            `SELECT DISTINCT file FROM nodes WHERE id IN (${placeholders}) AND file IS NOT NULL`,
-          )
-          .all(...chunk) as Array<{ file: string }>;
-        for (const row of rows) {
-          if (!seenFiles.has(row.file)) {
-            seenFiles.add(row.file);
-            affectedFiles.push(row);
-          }
-        }
-      }
-      if (affectedFiles.length > 0) {
-        const { classifyNodeRoles } = (await import('../../../../features/structure.js')) as {
-          classifyNodeRoles: (
-            db: BetterSqlite3Database,
-            changedFiles?: string[] | null,
-          ) => Record<string, number>;
-        };
-        classifyNodeRoles(
-          db,
-          affectedFiles.map((r) => r.file),
-        );
-        debug(
-          `this/super dispatch post-pass: re-classified roles for ${affectedFiles.length} target file(s)`,
-        );
-      }
+      const { classifyNodeRoles } = (await import('../../../../features/structure.js')) as {
+        classifyNodeRoles: (
+          db: BetterSqlite3Database,
+          changedFiles?: string[] | null,
+        ) => Record<string, number>;
+      };
+      classifyNodeRoles(ctx.db as unknown as BetterSqlite3Database, null);
+      debug(`Post-pass full role re-classification complete`);
     } catch (err) {
-      debug(`this/super dispatch post-pass role re-classification failed: ${toErrorMessage(err)}`);
+      debug(`Post-pass full role re-classification failed: ${toErrorMessage(err)}`);
     }
   }
 

src/extractors/csharp.ts

@@ -332,16 +332,34 @@ function extractCSharpTypeMap(node: TreeSitterNode, ctx: ExtractorOutput): void
 /** Extract type info from a variable_declaration node (local vars with explicit types). */
 function handleCSharpVarDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const typeNode = node.childForFieldName('type') || node.child(0);
-  if (!typeNode || typeNode.type === 'var_keyword') return;
+  if (!typeNode) return;
+
+  if (typeNode.type === 'implicit_type') {
+    // var x = new Foo() — infer type from object_creation_expression initializer
+    if (!ctx.typeMap) return;
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (child?.type !== 'variable_declarator') continue;
+      const nameNode = child.childForFieldName('name') || child.child(0);
+      if (nameNode?.type !== 'identifier') continue;
+      const objCreation = findChild(child, 'object_creation_expression');
+      if (!objCreation) continue;
+      const ctorTypeNode = objCreation.childForFieldName('type');
+      if (!ctorTypeNode) continue;
+      const ctorType = extractCSharpTypeName(ctorTypeNode);
+      if (ctorType) setTypeMapEntry(ctx.typeMap, nameNode.text, ctorType, 1.0);
+    }
+    return;
+  }
+
   const typeName = extractCSharpTypeName(typeNode);
   if (!typeName) return;
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (child?.type !== 'variable_declarator') continue;
     const nameNode = child.childForFieldName('name') || child.child(0);
-    if (nameNode && nameNode.type === 'identifier' && ctx.typeMap) {
-      setTypeMapEntry(ctx.typeMap, nameNode.text, typeName, 0.9);
-    }
+    if (nameNode?.type !== 'identifier' || !ctx.typeMap) continue;
+    if (typeName) setTypeMapEntry(ctx.typeMap, nameNode.text, typeName, 0.9);
   }
 }
 

src/extractors/javascript.ts

@@ -2676,6 +2676,25 @@ function extractReceiverName(objNode: TreeSitterNode | null): string | undefined
   if (!objNode) return undefined;
   const t = objNode.type;
   if (t === 'identifier' || t === 'this' || t === 'super') return objNode.text;
+  // `(new Foo(...)).method()` — extract the constructor name so the resolver can
+  // look up `Foo.method` directly without relying on a text-based regex heuristic.
+  if (t === 'new_expression') {
+    const name = extractNewExprTypeName(objNode);
+    if (name) return name;
+  }
+  if (t === 'parenthesized_expression') {
+    // Only one level of parentheses is unwrapped here. Doubly-nested parens
+    // (e.g. `((new Dog())).bark()`) and cast expressions inside parens
+    // (e.g. `(new Dog() as Animal).bark()`) fall through to raw-text handling
+    // below and are caught by the regex fallback in call-resolver.ts.
+    for (let i = 0; i < objNode.childCount; i++) {
+      const child = objNode.child(i);
+      if (child?.type === 'new_expression') {
+        const name = extractNewExprTypeName(child);
+        if (name) return name;
+      }
+    }
+  }
   return objNode.text;
 }
 

tests/benchmarks/resolution/fixtures/javascript/class-scope.js

@@ -0,0 +1,21 @@
+// Regression guard: bare function calls in JS class methods must NOT resolve
+// to same-named class methods. In JS/TS, bare foo() is lexically scoped to
+// the module, not the class — there is no implicit this binding on bare calls.
+//
+// If the call.receiver guard in resolveByMethodOrGlobal (call-resolver.ts) is
+// ever removed, the resolver would incorrectly emit Processor.run → Processor.flush
+// (a false positive). The 1.0 precision floor on the JS fixture catches that
+// regression immediately.
+
+export function processData(x) {
+  return x * 2;
+}
+
+export class Processor {
+  run(x) {
+    processData(x); // same-file module-level function — resolves correctly
+    flush(); // bare call; no module-level 'flush' in scope — must NOT resolve to Processor.flush
+  }
+
+  flush() {} // Processor.flush exists; bare flush() in run() must not target it
+}

tests/benchmarks/resolution/fixtures/javascript/expected-edges.json

@@ -289,6 +289,13 @@
       "kind": "calls",
       "mode": "receiver-typed",
       "notes": "this.service.doB() — receiver-typed via ClassB.service = new ServiceB() (class-scoped typeMap key prevents collision with ClassA.service)"
+    },
+    {
+      "source": { "name": "Processor.run", "file": "class-scope.js" },
+      "target": { "name": "processData", "file": "class-scope.js" },
+      "kind": "calls",
+      "mode": "same-file",
+      "notes": "Bare call to same-file module-level function — regression guard: bare flush() in run() must NOT resolve to Processor.flush (class-scoped lookup must be receiver-gated)"
     }
   ]
 }