@optave/codegraph 3.11.2 → 3.13.0

package/src/domain/parser.ts

@@ -152,10 +152,13 @@ interface WasmExtractResult {
 // Shared patterns for all JS/TS/TSX (class_declaration excluded — name type differs)
 const COMMON_QUERY_PATTERNS: string[] = [
   '(function_declaration name: (identifier) @fn_name) @fn_node',
+  '(generator_function_declaration name: (identifier) @fn_name) @fn_node',
   '(variable_declarator name: (identifier) @varfn_name value: (arrow_function) @varfn_value)',
   '(variable_declarator name: (identifier) @varfn_name value: (function_expression) @varfn_value)',
+  '(variable_declarator name: (identifier) @varfn_name value: (generator_function) @varfn_value)',
   '(method_definition name: (property_identifier) @meth_name) @meth_node',
   '(method_definition name: (private_property_identifier) @meth_name) @meth_node',
+  '(method_definition name: (computed_property_name) @meth_name) @meth_node',
   '(import_statement source: (string) @imp_source) @imp_node',
   '(export_statement) @exp_node',
   '(call_expression function: (identifier) @callfn_name) @callfn_node',
@@ -166,12 +169,20 @@ const COMMON_QUERY_PATTERNS: string[] = [
   '(expression_statement (assignment_expression left: (member_expression) @assign_left right: (_) @assign_right)) @assign_node',
 ];
 
-// JS: class name is (identifier)
-const JS_CLASS_PATTERN: string = '(class_declaration name: (identifier) @cls_name) @cls_node';
+// JS: class name is (identifier) — declarations and expressions
+const JS_CLASS_PATTERNS: string[] = [
+  '(class_declaration name: (identifier) @cls_name) @cls_node',
+  // class expressions: `return class Foo extends Bar { ... }` or `const X = class Foo { ... }`
+  '(class name: (identifier) @cls_name) @cls_node',
+];
 
 // TS/TSX: class name is (type_identifier), plus interface and type alias
+// abstract_class_declaration is a separate node type in tree-sitter-typescript
 const TS_EXTRA_PATTERNS: string[] = [
   '(class_declaration name: (type_identifier) @cls_name) @cls_node',
+  '(abstract_class_declaration name: (type_identifier) @cls_name) @cls_node',
+  // class expressions: `return class Foo extends Bar { ... }`
+  '(class name: (type_identifier) @cls_name) @cls_node',
   '(interface_declaration name: (type_identifier) @iface_name) @iface_node',
   '(type_alias_declaration name: (type_identifier) @type_name) @type_node',
 ];
@@ -202,7 +213,7 @@ async function doLoadLanguage(entry: LanguageRegistryEntry): Promise<void> {
       const isTS = entry.id === 'typescript' || entry.id === 'tsx';
       const patterns = isTS
         ? [...COMMON_QUERY_PATTERNS, ...TS_EXTRA_PATTERNS]
-        : [...COMMON_QUERY_PATTERNS, JS_CLASS_PATTERN];
+        : [...COMMON_QUERY_PATTERNS, ...JS_CLASS_PATTERNS];
       _queryCache.set(entry.id, new Query(lang, patterns.join('\n')));
     }
   } catch (e: unknown) {
@@ -211,7 +222,9 @@ async function doLoadLanguage(entry: LanguageRegistryEntry): Promise<void> {
         file: entry.grammarFile,
         cause: e as Error,
       });
-    warn(
+    const isEnoent = (e as NodeJS.ErrnoException).code === 'ENOENT';
+    const log = isEnoent ? debug : warn;
+    log(
       `${entry.id} parser failed to initialize: ${(e as Error).message}. ${entry.id} files will be skipped.`,
     );
     _cachedParsers!.set(entry.id, null);
@@ -455,7 +468,7 @@ export function getInstalledWasmExtensions(): Set<string> {
  * Lowercase file extensions covered by the native Rust addon.
  *
  * Mirrors `LanguageKind::from_extension` in
- * `crates/codegraph-core/src/parser_registry.rs`. Used to classify why the
+ * `crates/codegraph-core/src/domain/parser.rs`. Used to classify why the
  * native orchestrator dropped a file: extensions outside this set are a
  * legitimate parser limit (no Rust extractor exists), while extensions inside
  * it indicate a real native bug (parse/read/extract failure).
@@ -684,6 +697,24 @@ function patchTypeMap(r: any): void {
   }
 }
 
+/** Normalize native returnTypeMap array to a Map instance, keeping highest-confidence entry per key. */
+function patchReturnTypeMap(r: any): void {
+  if (!r.returnTypeMap || r.returnTypeMap instanceof Map) return;
+  const map = new Map<string, TypeMapEntry>();
+  for (const e of r.returnTypeMap as Array<{
+    name: string;
+    typeName: string;
+    confidence?: number;
+  }>) {
+    const conf = e.confidence ?? 1.0;
+    const existing = map.get(e.name);
+    if (!existing || conf > existing.confidence) {
+      map.set(e.name, { type: e.typeName, confidence: conf });
+    }
+  }
+  r.returnTypeMap = map.size > 0 ? map : new Map();
+}
+
 /** Wrap bindingType into binding object for dataflow argFlows and mutations. */
 function patchDataflow(dataflow: any): void {
   if (dataflow.argFlows) {
@@ -706,6 +737,7 @@ function patchNativeResult(r: any): ExtractorOutput {
   if (r.definitions) patchDefinitions(r.definitions);
   if (r.imports) patchImports(r.imports);
   patchTypeMap(r);
+  patchReturnTypeMap(r);
   if (r.dataflow) patchDataflow(r.dataflow);
 
   return r;
@@ -1127,6 +1159,7 @@ async function backfillTypeMapBatch(
 async function parseFilesWasm(
   filePaths: string[],
   rootDir: string,
+  analysis: WorkerAnalysisOpts = FULL_ANALYSIS,
 ): Promise<Map<string, ExtractorOutput>> {
   const result = new Map<string, ExtractorOutput>();
   const pool = getWasmWorkerPool();
@@ -1139,7 +1172,7 @@ async function parseFilesWasm(
       warn(`Skipping ${path.relative(rootDir, filePath)}: ${(err as Error).message}`);
       continue;
     }
-    const output = await pool.parse(filePath, code, FULL_ANALYSIS);
+    const output = await pool.parse(filePath, code, analysis);
     if (output) {
       const relPath = path.relative(rootDir, filePath).split(path.sep).join('/');
       result.set(relPath, output);
@@ -1151,12 +1184,25 @@ async function parseFilesWasm(
 /**
  * Files at or below this count use the inline parse path (no worker spawn).
  *
- * Sized for typical engine-parity drops: a handful of fixture files in one
- * or two languages (the recurring HCL case is 4 files). Above this, the
- * worker-pool's IPC + crash-isolation cost (#965) is amortized over enough
- * parse work to be worth paying; below it, the ~1–2s cold-start dominates.
+ * The worker pool exists for crash safety (#965): exotic (non-required) WASM
+ * grammars can trigger uncatchable V8 fatal errors that would kill the main
+ * process. Running them in a worker means only the worker dies; the pool
+ * detects the exit, skips the file, respawns, and continues.
+ *
+ * JS/TS/TSX are required-tier grammars — they have never triggered the V8
+ * fatal crash class and are safe to run inline. The primary hot caller
+ * (this/super dispatch post-pass) exclusively handles JS/TS/TSX files and
+ * measured ~55–64ms/file through the pool vs ~8–10ms/file inline (#1435);
+ * IPC overhead scales linearly with file count, not amortised.
+ *
+ * The threshold is set high enough to keep typical this-dispatch batches
+ * (≤ 18 files on the codegraph corpus) on the inline path, while still
+ * routing truly large exotic-language drops (rare; typical HCL case is 4
+ * files) through the pool for crash isolation. Exotic-language drops are
+ * almost always well under this limit anyway, so they benefit from the
+ * inline fast path too without meaningful crash risk increase.
  */
-const INLINE_BACKFILL_THRESHOLD = 16;
+const INLINE_BACKFILL_THRESHOLD = 32;
 
 /**
  * Inline WASM parse (no worker) for small file batches.
@@ -1168,11 +1214,16 @@ const INLINE_BACKFILL_THRESHOLD = 16;
  *
  * Returns symbols with `_tree` set so `runAnalyses` can run AST/CFG/dataflow
  * visitors via the unified walker (mirrors how WASM-engine results behaved
- * before the worker pool was introduced).
+ * before the worker pool was introduced), unless `symbolsOnly` is true — in
+ * that case `_tree` is not set, skipping all analysis visitor walks. Use
+ * `symbolsOnly` when only definitions/calls/typeMap are needed (e.g. the
+ * this/super dispatch post-pass) to avoid the analysis overhead on the inline
+ * path, matching the optimization already applied to the worker-pool path.
  */
 async function parseFilesWasmInline(
   filePaths: string[],
   rootDir: string,
+  symbolsOnly = false,
 ): Promise<Map<string, ExtractorOutput>> {
   const result = new Map<string, ExtractorOutput>();
   if (filePaths.length === 0) return result;
@@ -1190,7 +1241,18 @@ async function parseFilesWasmInline(
     if (!extracted) continue;
     const relPath = path.relative(rootDir, filePath).split(path.sep).join('/');
     const symbols = extracted.symbols as ExtractorOutput & { _tree?: unknown; _langId?: string };
-    symbols._tree = extracted.tree;
+    // When symbolsOnly=true, skip setting _tree so runAnalyses does not run
+    // AST/complexity/CFG/dataflow visitor walks — only definitions/calls/typeMap
+    // are needed by callers like the this/super dispatch post-pass.
+    if (!symbolsOnly) {
+      symbols._tree = extracted.tree;
+    } else if (typeof (extracted.tree as any)?.delete === 'function') {
+      // Free the WASM-backed tree immediately — web-tree-sitter trees are backed
+      // by WASM linear memory and require explicit disposal.  When symbolsOnly is
+      // true the tree is never stored anywhere, so we must delete it here to
+      // avoid leaking WASM heap on every incremental rebuild.
+      (extracted.tree as any).delete();
+    }
     symbols._langId = extracted.langId;
     result.set(relPath, symbols);
   }
@@ -1200,17 +1262,24 @@ async function parseFilesWasmInline(
 /**
  * Backfill helper: small batches use the inline (main-thread) path; larger
  * batches keep the worker-pool isolation against tree-sitter WASM crashes
- * (#965). Threshold matches typical engine-parity drop sizes (a few fixture
- * files in one or two languages).
+ * (#965). See INLINE_BACKFILL_THRESHOLD for threshold rationale.
+ *
+ * `opts.symbolsOnly` skips the AST/complexity/CFG/dataflow visitors in the
+ * worker (and their result serialization across the thread boundary) for
+ * callers that only consume definitions/calls/typeMap — the native
+ * orchestrator's this-dispatch post-pass. Callers that ingest the files into
+ * the DB (dropped-language backfill) must keep
+ * the default full analysis.
  */
 export async function parseFilesWasmForBackfill(
   filePaths: string[],
   rootDir: string,
+  opts: { symbolsOnly?: boolean } = {},
 ): Promise<Map<string, ExtractorOutput>> {
   if (filePaths.length <= INLINE_BACKFILL_THRESHOLD) {
-    return parseFilesWasmInline(filePaths, rootDir);
+    return parseFilesWasmInline(filePaths, rootDir, opts.symbolsOnly);
   }
-  return parseFilesWasm(filePaths, rootDir);
+  return parseFilesWasm(filePaths, rootDir, opts.symbolsOnly ? EXTRACT_ONLY : FULL_ANALYSIS);
 }
 
 /**

package/src/domain/wasm-worker-entry.ts

@@ -109,10 +109,13 @@ function grammarPath(name: string): string {
 
 const COMMON_QUERY_PATTERNS: string[] = [
   '(function_declaration name: (identifier) @fn_name) @fn_node',
+  '(generator_function_declaration name: (identifier) @fn_name) @fn_node',
   '(variable_declarator name: (identifier) @varfn_name value: (arrow_function) @varfn_value)',
   '(variable_declarator name: (identifier) @varfn_name value: (function_expression) @varfn_value)',
+  '(variable_declarator name: (identifier) @varfn_name value: (generator_function) @varfn_value)',
   '(method_definition name: (property_identifier) @meth_name) @meth_node',
   '(method_definition name: (private_property_identifier) @meth_name) @meth_node',
+  '(method_definition name: (computed_property_name) @meth_name) @meth_node',
   '(import_statement source: (string) @imp_source) @imp_node',
   '(export_statement) @exp_node',
   '(call_expression function: (identifier) @callfn_name) @callfn_node',
@@ -123,10 +126,17 @@ const COMMON_QUERY_PATTERNS: string[] = [
   '(expression_statement (assignment_expression left: (member_expression) @assign_left right: (_) @assign_right)) @assign_node',
 ];
 
-const JS_CLASS_PATTERN: string = '(class_declaration name: (identifier) @cls_name) @cls_node';
+const JS_CLASS_PATTERNS: string[] = [
+  '(class_declaration name: (identifier) @cls_name) @cls_node',
+  // class expressions: `return class Foo extends Bar { ... }` or `const X = class Foo { ... }`
+  '(class name: (identifier) @cls_name) @cls_node',
+];
 
 const TS_EXTRA_PATTERNS: string[] = [
   '(class_declaration name: (type_identifier) @cls_name) @cls_node',
+  '(abstract_class_declaration name: (type_identifier) @cls_name) @cls_node',
+  // class expressions: `return class Foo extends Bar { ... }`
+  '(class name: (type_identifier) @cls_name) @cls_node',
   '(interface_declaration name: (type_identifier) @iface_name) @iface_node',
   '(type_alias_declaration name: (type_identifier) @type_name) @type_node',
 ];
@@ -430,7 +440,7 @@ async function loadLanguageLazy(entry: LanguageRegistryEntry): Promise<Parser |
       const isTS = entry.id === 'typescript' || entry.id === 'tsx';
       const patterns = isTS
         ? [...COMMON_QUERY_PATTERNS, ...TS_EXTRA_PATTERNS]
-        : [...COMMON_QUERY_PATTERNS, JS_CLASS_PATTERN];
+        : [...COMMON_QUERY_PATTERNS, ...JS_CLASS_PATTERNS];
       _queries.set(entry.id, new Query(lang, patterns.join('\n')));
     }
     return parser;
@@ -801,6 +811,29 @@ function serializeExtractorOutput(
     _lineCount: code.split('\n').length,
     dataflow: symbols.dataflow,
     astNodes,
+    ...(symbols.fnRefBindings?.length ? { fnRefBindings: symbols.fnRefBindings } : {}),
+    ...(symbols.paramBindings?.length ? { paramBindings: symbols.paramBindings } : {}),
+    ...(symbols.arrayElemBindings?.length ? { arrayElemBindings: symbols.arrayElemBindings } : {}),
+    ...(symbols.spreadArgBindings?.length ? { spreadArgBindings: symbols.spreadArgBindings } : {}),
+    ...(symbols.forOfBindings?.length ? { forOfBindings: symbols.forOfBindings } : {}),
+    ...(symbols.arrayCallbackBindings?.length
+      ? { arrayCallbackBindings: symbols.arrayCallbackBindings }
+      : {}),
+    ...(symbols.objectRestParamBindings?.length
+      ? { objectRestParamBindings: symbols.objectRestParamBindings }
+      : {}),
+    ...(symbols.objectPropBindings?.length
+      ? { objectPropBindings: symbols.objectPropBindings }
+      : {}),
+    ...(symbols.thisCallBindings?.length ? { thisCallBindings: symbols.thisCallBindings } : {}),
+    ...(symbols.newExpressions?.length ? { newExpressions: symbols.newExpressions } : {}),
+    ...(symbols.definePropertyReceivers?.size
+      ? { definePropertyReceivers: Array.from(symbols.definePropertyReceivers.entries()) }
+      : {}),
+    ...(symbols.returnTypeMap?.size
+      ? { returnTypeMap: Array.from(symbols.returnTypeMap.entries()) }
+      : {}),
+    ...(symbols.callAssignments?.length ? { callAssignments: symbols.callAssignments } : {}),
   };
 }
 

package/src/domain/wasm-worker-pool.ts

@@ -106,6 +106,28 @@ function deserializeResult(ser: SerializedExtractorOutput | null): ExtractorOutp
   // {line, kind, name, text?, receiver?} shape — see engine.ts:822 where the
   // visitor output is cast the same way.
   if (ser.astNodes !== undefined) out.astNodes = ser.astNodes as unknown as ASTNodeRow[];
+  if (ser.fnRefBindings?.length) out.fnRefBindings = ser.fnRefBindings;
+  if (ser.paramBindings?.length) out.paramBindings = ser.paramBindings;
+  if (ser.arrayElemBindings?.length) out.arrayElemBindings = ser.arrayElemBindings;
+  if (ser.spreadArgBindings?.length) out.spreadArgBindings = ser.spreadArgBindings;
+  if (ser.forOfBindings?.length) out.forOfBindings = ser.forOfBindings;
+  if (ser.arrayCallbackBindings?.length) out.arrayCallbackBindings = ser.arrayCallbackBindings;
+  if (ser.objectRestParamBindings?.length)
+    out.objectRestParamBindings = ser.objectRestParamBindings;
+  if (ser.objectPropBindings?.length) out.objectPropBindings = ser.objectPropBindings;
+  if (ser.thisCallBindings?.length) out.thisCallBindings = ser.thisCallBindings;
+  if (ser.newExpressions?.length) out.newExpressions = ser.newExpressions;
+  if (ser.definePropertyReceivers?.length) {
+    const m = new Map<string, string>();
+    for (const [k, v] of ser.definePropertyReceivers) m.set(k, v);
+    out.definePropertyReceivers = m;
+  }
+  if (ser.returnTypeMap?.length) {
+    const returnTypeMap = new Map<string, TypeMapEntry>();
+    for (const [k, v] of ser.returnTypeMap) returnTypeMap.set(k, v);
+    out.returnTypeMap = returnTypeMap;
+  }
+  if (ser.callAssignments?.length) out.callAssignments = ser.callAssignments;
   return out;
 }
 

package/src/domain/wasm-worker-protocol.ts

@@ -12,6 +12,7 @@
 
 import type {
   Call,
+  CallAssignment,
   ClassRelation,
   DataflowResult,
   Definition,
@@ -62,6 +63,20 @@ export interface SerializedExtractorOutput {
     text?: string;
     receiver?: string;
   }>;
+  fnRefBindings?: import('../types.js').FnRefBinding[];
+  arrayElemBindings?: import('../types.js').ArrayElemBinding[];
+  spreadArgBindings?: import('../types.js').SpreadArgBinding[];
+  forOfBindings?: import('../types.js').ForOfBinding[];
+  arrayCallbackBindings?: import('../types.js').ArrayCallbackBinding[];
+  objectRestParamBindings?: import('../types.js').ObjectRestParamBinding[];
+  objectPropBindings?: import('../types.js').ObjectPropBinding[];
+  paramBindings?: import('../types.js').ParamBinding[];
+  thisCallBindings?: import('../types.js').ThisCallBinding[];
+  newExpressions?: readonly string[];
+  /** Serialized definePropertyReceivers map (funcName → receiverVarName) as tuple array. */
+  definePropertyReceivers?: Array<[string, string]>;
+  returnTypeMap?: Array<[string, TypeMapEntry]>;
+  callAssignments?: CallAssignment[];
 }
 
 export interface WorkerParseResponseOk {

package/src/extractors/c.ts

@@ -189,7 +189,7 @@ function extractCParameters(paramListNode: TreeSitterNode | null): SubDeclaratio
   if (!paramListNode) return params;
   for (let i = 0; i < paramListNode.childCount; i++) {
     const param = paramListNode.child(i);
-    if (!param || param.type !== 'parameter_declaration') continue;
+    if (param?.type !== 'parameter_declaration') continue;
     const nameNode = param.childForFieldName('declarator');
     if (nameNode) {
       const name = unwrapCDeclaratorName(nameNode);
@@ -205,7 +205,7 @@ function extractStructFields(structNode: TreeSitterNode): SubDeclaration[] {
   if (!body) return fields;
   for (let i = 0; i < body.childCount; i++) {
     const member = body.child(i);
-    if (!member || member.type !== 'field_declaration') continue;
+    if (member?.type !== 'field_declaration') continue;
     const nameNode = member.childForFieldName('declarator');
     if (nameNode) {
       const name = unwrapCDeclaratorName(nameNode);
@@ -221,7 +221,7 @@ function extractEnumEntries(enumNode: TreeSitterNode): SubDeclaration[] {
   if (!body) return entries;
   for (let i = 0; i < body.childCount; i++) {
     const member = body.child(i);
-    if (!member || member.type !== 'enumerator') continue;
+    if (member?.type !== 'enumerator') continue;
     const nameNode = member.childForFieldName('name');
     if (nameNode) {
       entries.push({ name: nameNode.text, kind: 'constant', line: member.startPosition.row + 1 });

package/src/extractors/clojure.ts

@@ -224,7 +224,7 @@ function extractClojureParams(defnNode: TreeSitterNode): SubDeclaration[] {
   // Find the parameter vector [x y z]
   for (let i = 0; i < defnNode.childCount; i++) {
     const child = defnNode.child(i);
-    if (!child || child.type !== 'vec_lit') continue;
+    if (child?.type !== 'vec_lit') continue;
     for (let j = 0; j < child.childCount; j++) {
       const param = child.child(j);
       if (!param) continue;

package/src/extractors/cpp.ts

@@ -5,7 +5,13 @@ import type {
   TreeSitterNode,
   TreeSitterTree,
 } from '../types.js';
-import { extractModifierVisibility, findChild, nodeEndLine } from './helpers.js';
+import {
+  extractModifierVisibility,
+  findChild,
+  isCPrimitiveType,
+  nodeEndLine,
+  setTypeMapEntry,
+} from './helpers.js';
 
 /**
  * Extract symbols from C++ files.
@@ -50,6 +56,9 @@ function walkCppNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
     case 'call_expression':
       handleCppCallExpression(node, ctx);
       break;
+    case 'declaration':
+      handleCppDeclaration(node, ctx);
+      break;
   }
 
   for (let i = 0; i < node.childCount; i++) {
@@ -204,6 +213,40 @@ function handleCppInclude(node: TreeSitterNode, ctx: ExtractorOutput): void {
   });
 }
 
+/**
+ * Seed typeMap for declaration-typed locals: `UserService svc;` and
+ * `UserService svc = makeService();` both yield typeMap["svc"] = "UserService"
+ * at confidence 0.9. Mirrors `match_c_family_type_map` ("declaration" branch)
+ * in the native Rust C++ extractor.
+ */
+function handleCppDeclaration(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const typeNode = node.childForFieldName('type');
+  if (!typeNode) return;
+  const typeName = typeNode.text;
+  // Skip primitive types — they are never class/struct receivers
+  if (isCPrimitiveType(typeName)) return;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    const kind = child.type;
+    let nameNode: TreeSitterNode | null = null;
+    if (kind === 'init_declarator') {
+      nameNode = child.childForFieldName('declarator') ?? null;
+    } else if (kind === 'identifier') {
+      nameNode = child;
+    }
+    // Note: pointer_declarator / reference_declarator children (e.g. `UserService *svc;`)
+    // are intentionally skipped here — they are also skipped by the native Rust
+    // match_c_family_type_map helper, which only handles 'init_declarator' and
+    // 'identifier' children. Both engines have the same scope for this case.
+    if (!nameNode) continue;
+    const varName = unwrapCppDeclaratorName(nameNode);
+    if (varName) {
+      setTypeMapEntry(ctx.typeMap, varName, typeName, 0.9);
+    }
+  }
+}
+
 function handleCppCallExpression(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const funcNode = node.childForFieldName('function');
   if (!funcNode) return;
@@ -292,7 +335,7 @@ function extractCppParameters(paramListNode: TreeSitterNode | null): SubDeclarat
   if (!paramListNode) return params;
   for (let i = 0; i < paramListNode.childCount; i++) {
     const param = paramListNode.child(i);
-    if (!param || param.type !== 'parameter_declaration') continue;
+    if (param?.type !== 'parameter_declaration') continue;
     const nameNode = param.childForFieldName('declarator');
     if (nameNode) {
       const name = unwrapCppDeclaratorName(nameNode);
@@ -309,7 +352,7 @@ function extractCppClassFields(classNode: TreeSitterNode): SubDeclaration[] {
   if (!body) return fields;
   for (let i = 0; i < body.childCount; i++) {
     const member = body.child(i);
-    if (!member || member.type !== 'field_declaration') continue;
+    if (member?.type !== 'field_declaration') continue;
     const nameNode = member.childForFieldName('declarator');
     if (nameNode) {
       const name = unwrapCppDeclaratorName(nameNode);
@@ -330,7 +373,7 @@ function extractCppEnumEntries(enumNode: TreeSitterNode): SubDeclaration[] {
   if (!body) return entries;
   for (let i = 0; i < body.childCount; i++) {
     const member = body.child(i);
-    if (!member || member.type !== 'enumerator') continue;
+    if (member?.type !== 'enumerator') continue;
     const nameNode = member.childForFieldName('name');
     if (nameNode) {
       entries.push({ name: nameNode.text, kind: 'constant', line: member.startPosition.row + 1 });

package/src/extractors/csharp.ts

@@ -28,6 +28,7 @@ export function extractCSharpSymbols(tree: TreeSitterTree, _filePath: string): E
     classes: [],
     exports: [],
     typeMap: new Map(),
+    newExpressions: [],
   };
 
   walkCSharpNode(tree.rootNode, ctx);
@@ -252,7 +253,12 @@ function handleCsObjectCreation(node: TreeSitterNode, ctx: ExtractorOutput): voi
     typeNode.type === 'generic_name'
       ? typeNode.childForFieldName('name')?.text || typeNode.child(0)?.text
       : typeNode.text;
-  if (typeName) ctx.calls.push({ name: typeName, line: node.startPosition.row + 1 });
+  if (typeName) {
+    ctx.calls.push({ name: typeName, line: node.startPosition.row + 1 });
+    // Phase 8.5 (RTA): record instantiated type for CHA filtering, matching
+    // the JS extractor's newExpressions extraction for cross-engine parity.
+    (ctx.newExpressions as string[]).push(typeName);
+  }
 }
 
 const CS_PARENT_TYPES = [
@@ -273,7 +279,7 @@ function extractCSharpParameters(paramListNode: TreeSitterNode | null): SubDecla
   if (!paramListNode) return params;
   for (let i = 0; i < paramListNode.childCount; i++) {
     const param = paramListNode.child(i);
-    if (!param || param.type !== 'parameter') continue;
+    if (param?.type !== 'parameter') continue;
     const nameNode = param.childForFieldName('name');
     if (nameNode) {
       params.push({ name: nameNode.text, kind: 'parameter', line: param.startPosition.row + 1 });
@@ -288,12 +294,12 @@ function extractCSharpClassFields(classNode: TreeSitterNode): SubDeclaration[] {
   if (!body) return fields;
   for (let i = 0; i < body.childCount; i++) {
     const member = body.child(i);
-    if (!member || member.type !== 'field_declaration') continue;
+    if (member?.type !== 'field_declaration') continue;
     const varDecl = findChild(member, 'variable_declaration');
     if (!varDecl) continue;
     for (let j = 0; j < varDecl.childCount; j++) {
       const child = varDecl.child(j);
-      if (!child || child.type !== 'variable_declarator') continue;
+      if (child?.type !== 'variable_declarator') continue;
       const nameNode = child.childForFieldName('name');
       if (nameNode) {
         fields.push({
@@ -326,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 || child.type !== 'variable_declarator') continue;
+    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);
   }
 }
 

package/src/extractors/cuda.ts

@@ -5,7 +5,13 @@ import type {
   TreeSitterNode,
   TreeSitterTree,
 } from '../types.js';
-import { extractModifierVisibility, findChild, nodeEndLine } from './helpers.js';
+import {
+  extractModifierVisibility,
+  findChild,
+  isCPrimitiveType,
+  nodeEndLine,
+  setTypeMapEntry,
+} from './helpers.js';
 
 /**
  * Extract symbols from CUDA files.
@@ -63,6 +69,9 @@ function walkCudaNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
     case 'call_expression':
       handleCudaCallExpression(node, ctx);
       break;
+    case 'declaration':
+      handleCudaDeclaration(node, ctx);
+      break;
   }
 
   for (let i = 0; i < node.childCount; i++) {
@@ -204,6 +213,40 @@ function handleCudaInclude(node: TreeSitterNode, ctx: ExtractorOutput): void {
   });
 }
 
+/**
+ * Seed typeMap for declaration-typed locals: `UserService svc;` and
+ * `UserService svc = make();` both yield typeMap["svc"] = "UserService"
+ * at confidence 0.9. Mirrors `match_c_family_type_map` ("declaration" branch)
+ * in the native Rust CUDA extractor.
+ */
+function handleCudaDeclaration(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const typeNode = node.childForFieldName('type');
+  if (!typeNode) return;
+  const typeName = typeNode.text;
+  // Skip primitive types — they are never class/struct receivers
+  if (isCPrimitiveType(typeName)) return;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    const kind = child.type;
+    let nameNode: TreeSitterNode | null = null;
+    if (kind === 'init_declarator') {
+      nameNode = child.childForFieldName('declarator') ?? null;
+    } else if (kind === 'identifier') {
+      nameNode = child;
+    }
+    // Note: pointer_declarator / reference_declarator children (e.g. `UserService *svc;`)
+    // are intentionally skipped here — they are also skipped by the native Rust
+    // match_c_family_type_map helper, which only handles 'init_declarator' and
+    // 'identifier' children. Both engines have the same scope for this case.
+    if (!nameNode) continue;
+    const varName = extractCudaFieldName(nameNode);
+    if (varName) {
+      setTypeMapEntry(ctx.typeMap, varName, typeName, 0.9);
+    }
+  }
+}
+
 function handleCudaCallExpression(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const funcNode = node.childForFieldName('function');
   if (!funcNode) return;
@@ -262,7 +305,7 @@ function extractCudaParameters(paramListNode: TreeSitterNode | null): SubDeclara
   if (!paramListNode) return params;
   for (let i = 0; i < paramListNode.childCount; i++) {
     const param = paramListNode.child(i);
-    if (!param || param.type !== 'parameter_declaration') continue;
+    if (param?.type !== 'parameter_declaration') continue;
     const nameNode = param.childForFieldName('declarator');
     if (nameNode) {
       // Reuse the field-name drill helper so function-type parameters like
@@ -282,7 +325,7 @@ function extractCudaClassFields(classNode: TreeSitterNode): SubDeclaration[] {
   if (!body) return fields;
   for (let i = 0; i < body.childCount; i++) {
     const member = body.child(i);
-    if (!member || member.type !== 'field_declaration') continue;
+    if (member?.type !== 'field_declaration') continue;
     const nameNode = member.childForFieldName('declarator');
     if (!nameNode) continue;
     // Skip method declarations — a `field_declaration` whose declarator
@@ -380,7 +423,7 @@ function extractCudaEnumEntries(enumNode: TreeSitterNode): SubDeclaration[] {
   if (!body) return entries;
   for (let i = 0; i < body.childCount; i++) {
     const member = body.child(i);
-    if (!member || member.type !== 'enumerator') continue;
+    if (member?.type !== 'enumerator') continue;
     const nameNode = member.childForFieldName('name');
     if (nameNode) {
       entries.push({ name: nameNode.text, kind: 'constant', line: member.startPosition.row + 1 });