fix(parity): infer var-typed local types from new-expression initializers in C#

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

@@ -450,26 +450,55 @@ fn extract_csharp_type_name<'a>(type_node: &Node<'a>, source: &'a [u8]) -> Optio
     }
 }
 
+/// Extract the constructor type from a `var x = new Foo()` initializer.
+fn extract_var_init_type<'a>(declarator: &Node<'a>, source: &'a [u8]) -> Option<&'a str> {
+    for i in 0..declarator.child_count() {
+        let Some(child) = declarator.child(i) else { continue };
+        if child.kind() == "object_creation_expression" {
+            if let Some(t) = child.child_by_field_name("type") {
+                return extract_csharp_type_name(&t, source);
+            }
+        }
+        if child.kind() == "equals_value_clause" {
+            for j in 0..child.child_count() {
+                let Some(expr) = child.child(j) else { continue };
+                if expr.kind() == "object_creation_expression" {
+                    if let Some(t) = expr.child_by_field_name("type") {
+                        return extract_csharp_type_name(&t, source);
+                    }
+                }
+            }
+        }
+    }
+    None
+}
+
 fn match_csharp_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbols, _depth: usize) {
     match node.kind() {
         "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 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) {
-                                if child.kind() == "variable_declarator" {
-                                    let name_node = child.child_by_field_name("name")
-                                        .or_else(|| child.child(0));
-                                    if let Some(name_node) = name_node {
-                                        if name_node.kind() == "identifier" {
-                                            symbols.type_map.push(TypeMapEntry {
-                                                name: node_text(&name_node, source).to_string(),
-                                                type_name: type_name.to_string(),
-                                                confidence: 0.9,
-                                            });
-                                        }
+                let is_var = type_node.kind() == "var_keyword" || type_node.kind() == "implicit_type";
+                let explicit_type = if is_var { None } else { extract_csharp_type_name(&type_node, source) };
+                if !is_var && explicit_type.is_none() { return; }
+                for i in 0..node.child_count() {
+                    if let Some(child) = node.child(i) {
+                        if child.kind() == "variable_declarator" {
+                            let name_node = child.child_by_field_name("name")
+                                .or_else(|| child.child(0));
+                            if let Some(name_node) = name_node {
+                                if name_node.kind() == "identifier" {
+                                    let type_name = if is_var {
+                                        extract_var_init_type(&child, source)
+                                    } else {
+                                        explicit_type
+                                    };
+                                    if let Some(type_name) = type_name {
+                                        symbols.type_map.push(TypeMapEntry {
+                                            name: node_text(&name_node, source).to_string(),
+                                            type_name: type_name.to_string(),
+                                            confidence: 0.9,
+                                        });
                                     }
                                 }
                             }

src/extractors/csharp.ts

@@ -329,19 +329,41 @@ function extractCSharpTypeMap(node: TreeSitterNode, ctx: ExtractorOutput): void
   extractCSharpTypeMapDepth(node, ctx, 0);
 }
 
-/** Extract type info from a variable_declaration node (local vars with explicit types). */
+/** Extract the constructor type from a `var x = new Foo()` initializer. */
+function extractVarInitType(declarator: TreeSitterNode): string | null {
+  for (let i = 0; i < declarator.childCount; i++) {
+    const child = declarator.child(i);
+    if (child?.type === 'object_creation_expression') {
+      const tNode = child.childForFieldName('type');
+      if (tNode) return extractCSharpTypeName(tNode);
+    }
+    if (child?.type === 'equals_value_clause') {
+      for (let j = 0; j < child.childCount; j++) {
+        const expr = child.child(j);
+        if (expr?.type === 'object_creation_expression') {
+          const tNode = expr.childForFieldName('type');
+          if (tNode) return extractCSharpTypeName(tNode);
+        }
+      }
+    }
+  }
+  return null;
+}
+
+/** Extract type info from a variable_declaration node (local vars with explicit or inferred types). */
 function handleCSharpVarDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const typeNode = node.childForFieldName('type') || node.child(0);
-  if (!typeNode || typeNode.type === 'var_keyword') return;
-  const typeName = extractCSharpTypeName(typeNode);
-  if (!typeName) return;
+  if (!typeNode) return;
+  const isVar = typeNode.type === 'implicit_type' || typeNode.type === 'var_keyword';
+  const explicitTypeName = isVar ? null : extractCSharpTypeName(typeNode);
+  if (!isVar && !explicitTypeName) 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;
+    const typeName = isVar ? extractVarInitType(child) : explicitTypeName;
+    if (typeName) setTypeMapEntry(ctx.typeMap, nameNode.text, typeName, 0.9);
   }
 }
 

src/infrastructure/native.ts

@@ -58,10 +58,26 @@ function resolvePlatformPackage(): string | null {
 /**
  * Try to load the native napi addon.
  * Returns the module on success, null on failure.
+ *
+ * Dev override: CODEGRAPH_NATIVE_ADDON_PATH can point to a locally built
+ * .node file (e.g. crates/codegraph-core/index.node from `cargo build`).
+ * Only honoured when set explicitly — never falls back to it implicitly.
  */
 export function loadNative(): NativeAddon | null {
   if (_cached !== undefined) return _cached;
 
+  const devOverride = process.env.CODEGRAPH_NATIVE_ADDON_PATH;
+  if (devOverride) {
+    try {
+      _cached = _require(devOverride) as NativeAddon;
+      return _cached;
+    } catch (err) {
+      _loadError = err as Error;
+      _cached = null;
+      return null;
+    }
+  }
+
   const pkg = resolvePlatformPackage();
   if (pkg) {
     try {

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

@@ -275,6 +275,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)"
     }
   ]
 }

tests/benchmarks/resolution/resolution-benchmark.test.ts

@@ -125,7 +125,8 @@ const THRESHOLDS: Record<string, { precision: number; recall: number }> = {
   //   adds bind/call/apply resolution (3 new edges in bind-call-apply.js), total expected now 33.
   //   Phase 8.3f adds Object.defineProperty accessor this-dispatch (#1335): getter→baz in
   //   define-property.js and accessorGetter→accessorTarget.accessMethod in define-property-accessor.js,
-  //   total expected now 35.
+  //   total expected now 35. multi-class.js adds 4 class-scoped typeMap edges → 39.
+  //   #1407 adds class-scope.js (bare-call guard), +1 → total 40.
   javascript: { precision: 1.0, recall: 0.9 },
   // pts-javascript: hand-authored points-to JS fixture (for-of, Set, Array.from, spread) — patterns
   //   too broad for the main JS fixture. Patterns split per file to prevent intra-fixture FPs.