fix(wasm): emit receiver edges for declaration-typed locals in C++/CUDA

The JS C++ and CUDA extractors had no handler for 'declaration' AST nodes,
so typeMap was never seeded for statically-typed locals (e.g. 'UserService svc;').
Without a typeMap entry for 'svc', resolveReceiverEdge had nothing to look up and
silently skipped the receiver edge.

Add handleCppDeclaration / handleCudaDeclaration to both extractors. They mirror
match_c_family_type_map ('declaration' branch) from the native Rust path: extract
the type node text and seed typeMap[varName] = { type, confidence: 0.9 } for each
identifier or init_declarator child. Primitive types (int, char, bool, …) are
skipped to avoid spurious edges.

parity-compare.mjs --langs cpp,cuda --hybrid: PARITY OK (wasm = native = hybrid)
All 3044 tests pass.

Author: carlos-alm

src/extractors/cpp.ts

@@ -4,6 +4,7 @@ import type {
   SubDeclaration,
   TreeSitterNode,
   TreeSitterTree,
+  TypeMapEntry,
 } from '../types.js';
 import { extractModifierVisibility, findChild, nodeEndLine } from './helpers.js';
 
@@ -50,6 +51,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 +208,36 @@ 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 (isPrimitiveCppType(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;
+    }
+    if (!nameNode) continue;
+    const varName = unwrapCppDeclaratorName(nameNode);
+    if (varName) {
+      ctx.typeMap.set(varName, { type: typeName, confidence: 0.9 });
+    }
+  }
+}
+
 function handleCppCallExpression(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const funcNode = node.childForFieldName('function');
   if (!funcNode) return;
@@ -324,6 +358,23 @@ function extractCppClassFields(classNode: TreeSitterNode): SubDeclaration[] {
   return fields;
 }
 
+/**
+ * Primitive C/C++ types that are never class/struct receivers. Seeding these
+ * into typeMap would cause spurious receiver edges (e.g. `int x` → `int`).
+ */
+const CPP_PRIMITIVE_TYPES = new Set([
+  'int', 'long', 'short', 'unsigned', 'signed', 'float', 'double',
+  'char', 'bool', 'void', 'wchar_t', 'auto', 'size_t', 'uint8_t',
+  'uint16_t', 'uint32_t', 'uint64_t', 'int8_t', 'int16_t', 'int32_t',
+  'int64_t', 'ptrdiff_t', 'intptr_t', 'uintptr_t',
+]);
+
+function isPrimitiveCppType(typeName: string): boolean {
+  // Strip qualifiers like `const`, `volatile`, `unsigned` etc.
+  const base = typeName.split(/\s+/).pop() ?? typeName;
+  return CPP_PRIMITIVE_TYPES.has(base) || CPP_PRIMITIVE_TYPES.has(typeName);
+}
+
 function extractCppEnumEntries(enumNode: TreeSitterNode): SubDeclaration[] {
   const entries: SubDeclaration[] = [];
   const body = findChild(enumNode, 'enumerator_list');

src/extractors/cuda.ts

@@ -4,6 +4,7 @@ import type {
   SubDeclaration,
   TreeSitterNode,
   TreeSitterTree,
+  TypeMapEntry,
 } from '../types.js';
 import { extractModifierVisibility, findChild, nodeEndLine } from './helpers.js';
 
@@ -63,6 +64,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 +208,36 @@ 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 (isCudaPrimitiveType(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;
+    }
+    if (!nameNode) continue;
+    const varName = extractCudaFieldName(nameNode);
+    if (varName) {
+      ctx.typeMap.set(varName, { type: typeName, confidence: 0.9 });
+    }
+  }
+}
+
 function handleCudaCallExpression(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const funcNode = node.childForFieldName('function');
   if (!funcNode) return;
@@ -374,6 +408,22 @@ function innerCudaDeclarator(node: TreeSitterNode): TreeSitterNode | null {
   return null;
 }
 
+/**
+ * Primitive C/C++/CUDA types that are never class/struct receivers. Seeding
+ * these into typeMap would produce spurious receiver edges (e.g. `int x` → `int`).
+ */
+const CUDA_PRIMITIVE_TYPES = new Set([
+  'int', 'long', 'short', 'unsigned', 'signed', 'float', 'double',
+  'char', 'bool', 'void', 'wchar_t', 'auto', 'size_t', 'uint8_t',
+  'uint16_t', 'uint32_t', 'uint64_t', 'int8_t', 'int16_t', 'int32_t',
+  'int64_t', 'ptrdiff_t', 'intptr_t', 'uintptr_t',
+]);
+
+function isCudaPrimitiveType(typeName: string): boolean {
+  const base = typeName.split(/\s+/).pop() ?? typeName;
+  return CUDA_PRIMITIVE_TYPES.has(base) || CUDA_PRIMITIVE_TYPES.has(typeName);
+}
+
 function extractCudaEnumEntries(enumNode: TreeSitterNode): SubDeclaration[] {
   const entries: SubDeclaration[] = [];
   const body = findChild(enumNode, 'enumerator_list');