@optave/codegraph 3.12.0 → 3.15.0

package/src/domain/parser.ts

@@ -158,6 +158,7 @@ const COMMON_QUERY_PATTERNS: string[] = [
   '(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',
@@ -221,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);
@@ -465,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).
@@ -713,7 +716,17 @@ function patchReturnTypeMap(r: any): void {
 }
 
 /** Wrap bindingType into binding object for dataflow argFlows and mutations. */
-function patchDataflow(dataflow: any): void {
+/**
+ * Normalise a DataflowResult from the native Rust extractor to the VisitorArgFlow
+ * shape expected by the TypeScript dataflow analysis layer.
+ *
+ * The Rust `DataflowArgFlow` emits `bindingType: string | null` as a flat field.
+ * The TS analysis layer (`buildDataflowVerticesAndEdges`, `collectCallerStitchCandidates`)
+ * expects `binding: { type: string; index?: number }` on each argFlow/mutation entry.
+ * This normalisation must be applied whenever `extractDataflowAnalysis` is called
+ * outside the standard `patchNativeResult` pipeline.
+ */
+export function patchDataflowResult(dataflow: any): void {
   if (dataflow.argFlows) {
     for (const f of dataflow.argFlows) {
       f.binding = f.bindingType ? { type: f.bindingType } : null;
@@ -735,7 +748,7 @@ function patchNativeResult(r: any): ExtractorOutput {
   if (r.imports) patchImports(r.imports);
   patchTypeMap(r);
   patchReturnTypeMap(r);
-  if (r.dataflow) patchDataflow(r.dataflow);
+  if (r.dataflow) patchDataflowResult(r.dataflow);
 
   return r;
 }
@@ -1181,12 +1194,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.
@@ -1198,11 +1224,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;
@@ -1220,7 +1251,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);
   }
@@ -1230,14 +1272,13 @@ 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 prototype-methods and this-dispatch post-passes. Callers
- * that ingest the files into the DB (dropped-language backfill) must keep
+ * 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(
@@ -1246,7 +1287,7 @@ export async function parseFilesWasmForBackfill(
   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, opts.symbolsOnly ? EXTRACT_ONLY : FULL_ANALYSIS);
 }

package/src/domain/queries.ts

@@ -39,7 +39,7 @@ export {
   moduleMapData,
   statsData,
 } from './analysis/module-map.js';
-export { rolesData } from './analysis/roles.js';
+export { dynamicCallsData, rolesData } from './analysis/roles.js';
 // ── Analysis modules ─────────────────────────────────────────────────────
 export {
   childrenData,

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

@@ -115,6 +115,7 @@ const COMMON_QUERY_PATTERNS: string[] = [
   '(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',
@@ -125,11 +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',
 ];
@@ -433,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;
@@ -818,6 +825,7 @@ function serializeExtractorOutput(
     ...(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()) }
@@ -826,6 +834,9 @@ function serializeExtractorOutput(
       ? { returnTypeMap: Array.from(symbols.returnTypeMap.entries()) }
       : {}),
     ...(symbols.callAssignments?.length ? { callAssignments: symbols.callAssignments } : {}),
+    ...(symbols.cjsRequireBindings?.length
+      ? { cjsRequireBindings: symbols.cjsRequireBindings }
+      : {}),
   };
 }
 

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

@@ -86,11 +86,14 @@ interface PendingJob {
  */
 const WORKER_PARSE_TIMEOUT_MS = 60_000;
 
-function deserializeResult(ser: SerializedExtractorOutput | null): ExtractorOutput | null {
-  if (!ser) return null;
+/** Deserialize the core fields and metadata scalars from a serialized result. */
+function deserializeCoreFields(
+  ser: SerializedExtractorOutput,
+): Pick<ExtractorOutput, 'definitions' | 'calls' | 'imports' | 'classes' | 'exports' | 'typeMap'> &
+  Partial<Pick<ExtractorOutput, '_langId' | '_lineCount' | 'dataflow' | 'astNodes'>> {
   const typeMap = new Map<string, TypeMapEntry>();
   for (const [k, v] of ser.typeMap) typeMap.set(k, v);
-  const out: ExtractorOutput = {
+  const out: ReturnType<typeof deserializeCoreFields> = {
     definitions: ser.definitions,
     calls: ser.calls,
     imports: ser.imports,
@@ -106,6 +109,11 @@ 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[];
+  return out;
+}
+
+/** Deserialize the simple array binding fields (present when non-empty). */
+function deserializeBindingFields(ser: SerializedExtractorOutput, out: ExtractorOutput): void {
   if (ser.fnRefBindings?.length) out.fnRefBindings = ser.fnRefBindings;
   if (ser.paramBindings?.length) out.paramBindings = ser.paramBindings;
   if (ser.arrayElemBindings?.length) out.arrayElemBindings = ser.arrayElemBindings;
@@ -115,7 +123,14 @@ function deserializeResult(ser: SerializedExtractorOutput | null): ExtractorOutp
   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.callAssignments?.length) out.callAssignments = ser.callAssignments;
+  if (ser.cjsRequireBindings?.length) out.cjsRequireBindings = ser.cjsRequireBindings;
+}
+
+/** Deserialize the Map-typed fields that require entry-by-entry reconstruction. */
+function deserializeMapFields(ser: SerializedExtractorOutput, out: ExtractorOutput): void {
   if (ser.definePropertyReceivers?.length) {
     const m = new Map<string, string>();
     for (const [k, v] of ser.definePropertyReceivers) m.set(k, v);
@@ -126,7 +141,17 @@ function deserializeResult(ser: SerializedExtractorOutput | null): ExtractorOutp
     for (const [k, v] of ser.returnTypeMap) returnTypeMap.set(k, v);
     out.returnTypeMap = returnTypeMap;
   }
-  if (ser.callAssignments?.length) out.callAssignments = ser.callAssignments;
+}
+
+function deserializeResult(ser: SerializedExtractorOutput | null): ExtractorOutput | null {
+  if (!ser) return null;
+  // deserializeCoreFields supplies all required ExtractorOutput fields (definitions,
+  // calls, imports, classes, exports, typeMap). The cast is safe: every required field
+  // is present in the returned Pick. If a new required field is added to ExtractorOutput,
+  // add it to deserializeCoreFields' return Pick and body to keep the cast honest.
+  const out = { ...deserializeCoreFields(ser) } as ExtractorOutput;
+  deserializeBindingFields(ser, out);
+  deserializeMapFields(ser, out);
   return out;
 }
 

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

@@ -71,11 +71,16 @@ export interface SerializedExtractorOutput {
   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[];
+  /** Variable-level dataflow vertices extracted during parsing (P1+). */
+  dataflowVertices?: import('../types.js').DataflowVertex[];
+  /** CJS require bindings — see ExtractorOutput.cjsRequireBindings (#1661). */
+  cjsRequireBindings?: Array<{ names: string[]; source: string }>;
 }
 
 export interface WorkerParseResponseOk {

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;

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;

package/src/extractors/dart.ts

@@ -255,14 +255,59 @@ function handleDartSelector(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const argPart = findChild(node, 'argument_part');
   if (!argPart) return;
 
-  // Look for the identifier this selector belongs to
+  const line = node.startPosition.row + 1;
+
+  // Look for the identifier this selector belongs to.
+  // Two layouts are possible depending on grammar version:
+  //   A) selector has both unconditional_assignable_selector + argument_part (same node)
+  //   B) one selector node holds unconditional_assignable_selector (.method),
+  //      the next holds argument_part (the call args) — method name is in the previous sibling
   const unconditional = findChild(node, 'unconditional_assignable_selector');
+  let methodName: string | null = null;
+
   if (unconditional) {
     const id = findChild(unconditional, 'identifier');
-    if (id) {
-      ctx.calls.push({ name: id.text, line: node.startPosition.row + 1 });
+    if (id) methodName = id.text;
+  } else {
+    // Layout B: look at the previous sibling selector for the method name
+    const parent = node.parent;
+    if (parent) {
+      for (let i = 0; i < parent.childCount; i++) {
+        const sibling = parent.child(i);
+        if (sibling === node) break;
+        if (sibling?.type === 'selector') {
+          const unc2 = findChild(sibling, 'unconditional_assignable_selector');
+          if (unc2) {
+            const id2 = findChild(unc2, 'identifier');
+            if (id2) methodName = id2.text;
+          }
+        }
+      }
     }
   }
+
+  if (!methodName) return;
+
+  // Function.apply(fn, positionalArgs, namedArgs) — dynamic higher-order dispatch
+  if (methodName === 'apply') {
+    const parent = node.parent;
+    if (parent) {
+      for (let i = 0; i < parent.childCount; i++) {
+        const sibling = parent.child(i);
+        if (sibling && sibling !== node && sibling.text === 'Function') {
+          ctx.calls.push({
+            name: '<dynamic:unresolved>',
+            line,
+            dynamic: true,
+            dynamicKind: 'unresolved-dynamic',
+          });
+          return;
+        }
+      }
+    }
+  }
+
+  ctx.calls.push({ name: methodName, line });
 }
 
 function handleDartTypeAlias(node: TreeSitterNode, ctx: ExtractorOutput): void {

package/src/extractors/groovy.ts

@@ -292,8 +292,26 @@ function handleGroovyImport(node: TreeSitterNode, ctx: ExtractorOutput): void {
   }
 }
 
+/** Extract the first string literal argument from a Groovy call node. */
+function getFirstStringArgGroovy(node: TreeSitterNode): string | null {
+  const args = node.childForFieldName('arguments') || findChild(node, 'argument_list');
+  if (!args) return null;
+  for (let i = 0; i < args.childCount; i++) {
+    const child = args.child(i);
+    if (!child) continue;
+    const t = child.type;
+    if (t === '(' || t === ')' || t === ',') continue;
+    if (t === 'string' || t === 'string_literal' || t === 'string_fragment') {
+      return child.text.replace(/^["']|["']$/g, '');
+    }
+    break;
+  }
+  return null;
+}
+
 function handleGroovyCallExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const call: Call = { name: '', line: node.startPosition.row + 1 };
+  let fieldNode: TreeSitterNode | null = null;
 
   // Try standard call_expression pattern
   const funcNode = node.childForFieldName('function') || node.childForFieldName('method');
@@ -301,7 +319,10 @@ function handleGroovyCallExpr(node: TreeSitterNode, ctx: ExtractorOutput): void
     if (funcNode.type === 'field_expression' || funcNode.type === 'member_access') {
       const field = funcNode.childForFieldName('field') || funcNode.childForFieldName('property');
       const obj = funcNode.childForFieldName('argument') || funcNode.childForFieldName('object');
-      if (field) call.name = field.text;
+      if (field) {
+        fieldNode = field;
+        call.name = field.text;
+      }
       if (obj) call.receiver = obj.text;
     } else {
       call.name = funcNode.text;
@@ -311,12 +332,51 @@ function handleGroovyCallExpr(node: TreeSitterNode, ctx: ExtractorOutput): void
     const nameNode = node.childForFieldName('name');
     const obj = node.childForFieldName('object');
     if (nameNode) {
+      fieldNode = nameNode;
       call.name = nameNode.text;
       if (obj) call.receiver = obj.text;
     }
   }
 
-  if (call.name) ctx.calls.push(call);
+  if (!call.name) return;
+
+  // obj."$dyn"() or obj."${var}"() — GString method name; cannot resolve statically
+  if (fieldNode && (fieldNode.type === 'gstring' || fieldNode.type === 'template_string')) {
+    ctx.calls.push({
+      name: '<dynamic:unresolved>',
+      line: call.line,
+      dynamic: true,
+      dynamicKind: 'unresolved-dynamic',
+      receiver: call.receiver,
+    });
+    return;
+  }
+
+  // obj.invokeMethod("name", args) — Groovy's explicit dynamic dispatch
+  if (call.name === 'invokeMethod') {
+    const literal = getFirstStringArgGroovy(node);
+    if (literal) {
+      ctx.calls.push({
+        name: literal,
+        line: call.line,
+        dynamic: true,
+        dynamicKind: 'reflection',
+        keyExpr: literal,
+        receiver: call.receiver,
+      });
+    } else {
+      ctx.calls.push({
+        name: '<dynamic:computed-key>',
+        line: call.line,
+        dynamic: true,
+        dynamicKind: 'computed-key',
+        receiver: call.receiver,
+      });
+    }
+    return;
+  }
+
+  ctx.calls.push(call);
 }
 
 function handleGroovyObjectCreation(node: TreeSitterNode, ctx: ExtractorOutput): void {

package/src/extractors/helpers.ts

@@ -1,5 +1,6 @@
 import type {
   Call,
+  DynamicKind,
   ExtractorOutput,
   Import,
   SubDeclaration,
@@ -270,18 +271,20 @@ export function extractModifierVisibility(
 
 /**
  * Append a `Call` to the extractor output. `line` defaults to the start line of
- * `node`; pass `extra` for `receiver` / `dynamic` flags.
+ * `node`; pass `extra` for `receiver` / `dynamic` / `dynamicKind` / `keyExpr` fields.
  */
 export function pushCall(
   ctx: ExtractorOutput,
   node: TreeSitterNode,
   name: string,
-  extra: { receiver?: string; dynamic?: boolean } = {},
+  extra: { receiver?: string; dynamic?: boolean; dynamicKind?: DynamicKind; keyExpr?: string } = {},
 ): void {
   if (!name) return;
   const call: Call = { name, line: nodeStartLine(node) };
   if (extra.receiver !== undefined) call.receiver = extra.receiver;
   if (extra.dynamic !== undefined) call.dynamic = extra.dynamic;
+  if (extra.dynamicKind !== undefined) call.dynamicKind = extra.dynamicKind;
+  if (extra.keyExpr !== undefined) call.keyExpr = extra.keyExpr;
   ctx.calls.push(call);
 }
 
@@ -305,6 +308,49 @@ export function pushImport(
   ctx.imports.push(entry);
 }
 
+// ── C-family primitive types ───────────────────────────────────────────────
+
+/**
+ * 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`).
+ * Shared between the C++ and CUDA extractors to prevent divergence.
+ */
+export const C_PRIMITIVE_TYPES: ReadonlySet<string> = 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',
+]);
+
+/**
+ * Return true when `typeName` is a primitive C/C++/CUDA type.
+ * Strips leading qualifiers (`const int` → `int`) before checking.
+ */
+export function isCPrimitiveType(typeName: string): boolean {
+  const base = typeName.split(/\s+/).pop() ?? typeName;
+  return C_PRIMITIVE_TYPES.has(base) || C_PRIMITIVE_TYPES.has(typeName);
+}
+
 // ── Parameter extraction ───────────────────────────────────────────────────
 
 /**