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

Both the WASM and native C# extractors were skipping variable declarations
with `var`/`implicit_type` type nodes entirely, so `var service = new
UserService(repo)` never added `service → UserService` to the typeMap.  The
call-edge resolver therefore could not resolve `service.AddUser()` or
`service.GetUser()` to the qualified methods on `UserService`.

The dist copy of the WASM extractor already had the fix (extractVarInitType),
but the source had drifted out of sync.  This commit re-introduces the logic
in both engines:

WASM (TypeScript): add `extractVarInitType(declarator)` that walks the
variable_declarator children looking for an `object_creation_expression` (or
one inside an `equals_value_clause`), then reads the `type` field via
`extractCSharpTypeName`.  `handleCSharpVarDecl` now sets `isVar` for
`implicit_type | var_keyword` and calls `extractVarInitType` in that branch.

Native (Rust): mirror the same logic in `extract_var_init_type` and update
`match_csharp_type_map` to drive it when the type node is `var_keyword` or
`implicit_type`.

Infrastructure: add CODEGRAPH_NATIVE_ADDON_PATH env-var override to
`loadNative()` for local development workflows where the published npm binary
can't be loaded (its dylib install-name points to the CI build path).  Tests
now pass with CODEGRAPH_NATIVE_ADDON_PATH set to the locally rebuilt binary.

Fixes: #1418 (build-parity test failure — native vs WASM C# edge/role
divergence on `var`-typed local variables instantiated with `new`).

Author: carlos-alm

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 {