@optave/codegraph 3.13.0 → 3.15.0

package/src/ast-analysis/rules/b4.ts

@@ -0,0 +1,378 @@
+import type { DataflowRulesConfig, TreeSitterNode } from '../../types.js';
+import { makeDataflowRules } from '../shared.js';
+
+// ─── Haskell ──────────────────────────────────────────────────────────────────
+//
+// Haskell `function` node: name via `childForFieldName('name')` (confirmed in extractor line 62).
+// Params: `patterns` or `parameter` children of the function node (extractor line 81).
+// No explicit return keyword — last expression is the return value. returnNode: null.
+// apply: `childForFieldName('function')` for the called function (extractor line 264).
+// No standard variable declarations or member access in the conventional sense.
+
+function extractHaskellParamName(node: TreeSitterNode): string[] | null {
+  if (node.type === 'variable' || node.type === 'identifier') return [node.text];
+  if (node.type === 'wildcard') return ['_'];
+  // For pattern nodes, collect all variable bindings
+  if (node.type === 'patterns' || node.type === 'parameter') {
+    const names: string[] = [];
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
+      if (!child) continue;
+      if (child.type === 'variable' || child.type === 'identifier') names.push(child.text);
+    }
+    return names.length > 0 ? names : null;
+  }
+  return null;
+}
+
+function getHaskellParamListNode(funcNode: TreeSitterNode): TreeSitterNode | null {
+  // Haskell params are positional children; find the `patterns` child if present
+  for (let i = 0; i < funcNode.childCount; i++) {
+    const child = funcNode.child(i);
+    if (child?.type === 'patterns') return child;
+  }
+  return null;
+}
+
+export const dataflowHaskell: DataflowRulesConfig = makeDataflowRules({
+  functionNodes: new Set(['function']),
+  nameField: 'name',
+
+  getParamListNode: getHaskellParamListNode,
+  paramWrapperTypes: new Set(['variable', 'identifier', 'wildcard', 'parameter']),
+  extractParamName: extractHaskellParamName,
+
+  returnNode: null, // Haskell: no explicit return; last expression is the result
+
+  callNode: 'apply',
+  callFunctionField: 'function',
+  // `apply` args don't have a single named 'arguments' field in tree-sitter-haskell.
+});
+
+// ─── OCaml ────────────────────────────────────────────────────────────────────
+//
+// OCaml functions are `value_definition` → `let_binding` nodes with parameter children.
+// The extractor handles both `value_definition` (top-level) and standalone `let_binding`.
+// Params: `parameter` or `value_pattern` children of let_binding (extractor line 139).
+// No explicit return keyword — last expression is the result. returnNode: null.
+// application_expression: first child is function node (extractor line 314).
+// field_get_expression: `childForFieldName('field')` (extractor line 327).
+// Variable declarations: `let_binding` with no params (extractor line 103-110).
+
+function extractOCamlParamName(node: TreeSitterNode): string[] | null {
+  if (node.type === 'value_name' || node.type === 'identifier') return [node.text];
+  if (node.type === 'parameter' || node.type === 'value_pattern') {
+    // Pattern may be value_name or identifier
+    if (node.namedChildCount === 0) return [node.text];
+    for (const child of node.namedChildren) {
+      if (child.type === 'value_name' || child.type === 'identifier') return [child.text];
+    }
+  }
+  return null;
+}
+
+function getOCamlParamListNode(funcNode: TreeSitterNode): TreeSitterNode | null {
+  // For value_definition, params are inside let_binding children
+  if (funcNode.type === 'value_definition') {
+    for (let i = 0; i < funcNode.childCount; i++) {
+      const child = funcNode.child(i);
+      if (child?.type === 'let_binding') return child;
+    }
+  }
+  // For let_binding directly — return it as the "param list" (walker will iterate its children)
+  if (funcNode.type === 'let_binding') return funcNode;
+  return null;
+}
+
+export const dataflowOCaml: DataflowRulesConfig = makeDataflowRules({
+  functionNodes: new Set(['value_definition', 'let_binding']),
+  nameField: 'pattern',
+
+  getParamListNode: getOCamlParamListNode,
+  paramWrapperTypes: new Set(['parameter', 'value_pattern']),
+  extractParamName: extractOCamlParamName,
+
+  returnNode: null, // OCaml: no explicit return; last expression is the result
+
+  callNode: 'application_expression',
+  // application_expression: first child is function (no named 'function' field in tree-sitter-ocaml).
+  // Leave callFunctionField at default — will return null gracefully.
+
+  memberNode: 'field_get_expression',
+  memberPropertyField: 'field',
+  // field_get_expression object is first child, not a named field. Leave memberObjectField at default.
+});
+
+// ─── F# ───────────────────────────────────────────────────────────────────────
+//
+// F# functions: `function_declaration_left` is the LHS of a `let` binding (confirmed extractor).
+// The name is a direct `identifier` child of `function_declaration_left` (extractor line 127).
+// Params: `argument_patterns` child of `function_declaration_left` (extractor line 150).
+// No explicit return keyword in F#. returnNode: null.
+// application_expression: first child is function (extractor line 265).
+// dot_expression: member access (extractor line 276).
+
+function extractFSharpParamName(node: TreeSitterNode): string[] | null {
+  if (node.type === 'identifier') return [node.text];
+  // Collect all identifier descendants for pattern-destructured params
+  const names: string[] = [];
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child?.type === 'identifier') names.push(child.text);
+  }
+  return names.length > 0 ? names : null;
+}
+
+function getFSharpParamListNode(funcNode: TreeSitterNode): TreeSitterNode | null {
+  // function_declaration_left contains argument_patterns as a child
+  for (let i = 0; i < funcNode.childCount; i++) {
+    const child = funcNode.child(i);
+    if (child?.type === 'argument_patterns') return child;
+  }
+  return null;
+}
+
+export const dataflowFSharp: DataflowRulesConfig = makeDataflowRules({
+  functionNodes: new Set(['function_declaration_left']),
+  nameField: 'name',
+
+  getParamListNode: getFSharpParamListNode,
+  paramWrapperTypes: new Set(['identifier']),
+  extractParamName: extractFSharpParamName,
+
+  returnNode: null, // F#: no explicit return; last expression is the result
+
+  callNode: 'application_expression',
+  // application_expression: first child is function (no named 'function' field).
+
+  memberNode: 'dot_expression',
+  // dot_expression field names are not standard; leave memberObjectField/memberPropertyField at defaults.
+});
+
+// ─── Gleam ────────────────────────────────────────────────────────────────────
+//
+// Gleam `function` and `external_function`: name via `childForFieldName('name')` (extractor line 70).
+// Params: `childForFieldName('parameters')` or findChild('function_parameters') (extractor line 221).
+// Each param is `function_parameter` or `parameter` with `childForFieldName('name')` (extractor line 228).
+// No explicit return keyword in Gleam. returnNode: null.
+// function_call/call: `childForFieldName('function')` (extractor line 202).
+// field_access/module_select: `childForFieldName('field')` / `childForFieldName('label')` (extractor line 207).
+
+function extractGleamParamName(node: TreeSitterNode): string[] | null {
+  if (node.type === 'function_parameter' || node.type === 'parameter') {
+    const nameNode = node.childForFieldName('name');
+    if (nameNode) return [nameNode.text];
+    for (const child of node.namedChildren) {
+      if (child.type === 'identifier') return [child.text];
+    }
+  }
+  if (node.type === 'identifier') return [node.text];
+  return null;
+}
+
+export const dataflowGleam: DataflowRulesConfig = makeDataflowRules({
+  functionNodes: new Set(['function', 'external_function']),
+  nameField: 'name',
+
+  paramListField: 'parameters',
+  paramWrapperTypes: new Set(['function_parameter', 'parameter']),
+  extractParamName: extractGleamParamName,
+
+  returnNode: null, // Gleam: no explicit return; last expression is the result
+
+  callNodes: new Set(['function_call', 'call']),
+  callFunctionField: 'function',
+
+  memberNode: 'field_access',
+  memberObjectField: 'record',
+  memberPropertyField: 'field',
+});
+
+// ─── Elixir ───────────────────────────────────────────────────────────────────
+//
+// Elixir functions are `call` nodes where target is `def`/`defp` (confirmed extractor).
+// The extractor emits the function definition from `handleDefFunction` which walks
+// `call` nodes. The actual function body lives inside a `do_block`.
+// Params: inside `call` → `arguments` → inner `call` → `arguments` (extractor line 181-196).
+// No explicit return keyword in Elixir. returnNode: null.
+// Regular call: `call` nodes with `target` identifier (extractor handleElixirCall).
+// Dot call: `call` with `dot` target (extractor handleDotCall).
+//
+// For dataflow purposes: the function scope is a `call` node with `def`/`defp` target.
+// This requires a custom nameExtractor to identify which calls are function definitions.
+// The simplified approach: mark `call` as a function node but filter by target in nameExtractor.
+
+function extractElixirFunctionName(node: TreeSitterNode): string | null {
+  if (node.type !== 'call') return null;
+  const target = node.childForFieldName('target');
+  if (target?.type !== 'identifier') return null;
+  if (target.text !== 'def' && target.text !== 'defp') return null;
+  // Extract the function name from arguments → first call → target identifier
+  const args =
+    node.childForFieldName('arguments') ??
+    (() => {
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child?.type === 'arguments') return child;
+      }
+      return null;
+    })();
+  if (!args) return null;
+  for (let i = 0; i < args.childCount; i++) {
+    const child = args.child(i);
+    if (!child) continue;
+    if (child.type === 'call') {
+      const fnTarget = child.childForFieldName('target');
+      if (fnTarget?.type === 'identifier') return fnTarget.text;
+    }
+    if (child.type === 'identifier') return child.text;
+  }
+  return null;
+}
+
+export const dataflowElixir: DataflowRulesConfig = makeDataflowRules({
+  functionNodes: new Set(['call']),
+  nameField: 'target',
+  nameExtractor: extractElixirFunctionName,
+
+  // Param list extraction is complex for Elixir (nested calls inside arguments).
+  // Leave at defaults — param list discovery will gracefully return null.
+
+  returnNode: null, // Elixir: no explicit return; last expression is the result
+
+  callNode: 'call',
+  // Elixir call nodes use 'target' for the function name, not 'function'.
+  // Leave callFunctionField at default 'function' — will return null gracefully.
+  // The primary value here is function scope marking.
+});
+
+// ─── Erlang ───────────────────────────────────────────────────────────────────
+//
+// Erlang `fun_decl` contains `function_clause` children.
+// The extractor handles `fun_decl` by extracting from the first `function_clause`.
+// function_clause: name via `childForFieldName('name')` or `findChild(node, 'atom')` (extractor line 151).
+// Params: `childForFieldName('args')` or findChild('expr_args') (extractor line 179).
+// Each arg in expr_args is a named child (pattern). arity preserved by param count.
+// No explicit return keyword in Erlang. returnNode: null.
+// call: first named child is function (extractor line 272).
+
+function extractErlangParamName(node: TreeSitterNode): string[] | null {
+  // Erlang params are pattern nodes; var/atom get their text as name
+  if (node.type === 'var' || node.type === 'atom') return [node.text];
+  // For complex patterns, use a placeholder
+  return [`_${node.startPosition.row}`];
+}
+
+function getErlangParamListNode(funcNode: TreeSitterNode): TreeSitterNode | null {
+  // fun_decl: find first function_clause, then its expr_args
+  if (funcNode.type === 'fun_decl') {
+    for (let i = 0; i < funcNode.childCount; i++) {
+      const child = funcNode.child(i);
+      if (child?.type === 'function_clause') {
+        const args = child.childForFieldName('args');
+        if (args) return args;
+        for (let j = 0; j < child.childCount; j++) {
+          const argChild = child.child(j);
+          if (argChild?.type === 'expr_args') return argChild;
+        }
+      }
+    }
+  }
+  // function_clause directly: find expr_args
+  if (funcNode.type === 'function_clause') {
+    const args = funcNode.childForFieldName('args');
+    if (args) return args;
+    for (let i = 0; i < funcNode.childCount; i++) {
+      const child = funcNode.child(i);
+      if (child?.type === 'expr_args') return child;
+    }
+  }
+  return null;
+}
+
+export const dataflowErlang: DataflowRulesConfig = makeDataflowRules({
+  functionNodes: new Set(['fun_decl', 'function_clause']),
+  nameField: 'name',
+
+  getParamListNode: getErlangParamListNode,
+  extractParamName: extractErlangParamName,
+
+  returnNode: null, // Erlang: no explicit return; last expression is the result
+
+  callNode: 'call',
+  // Erlang call: first named child is function (atom or remote). No named 'function' field.
+});
+
+// ─── Clojure ──────────────────────────────────────────────────────────────────
+//
+// Clojure functions are `list_lit` nodes where first symbol is `defn`/`defn-`/`defmacro`.
+// The extractor uses `findFirstSymbol` / `findSecondSymbol` helpers.
+// The function name is the second symbol in the list.
+// Params: first `vec_lit` child after the name (extractor extractClojureParams line 222).
+// No explicit return keyword in Clojure. returnNode: null.
+// Regular calls: `list_lit` nodes where first symbol is not a def form (extractor default case).
+//
+// nameExtractor must distinguish function-defining lists from call lists.
+
+function extractClojureFunctionName(node: TreeSitterNode): string | null {
+  if (node.type !== 'list_lit') return null;
+  // Find first symbol — skip delimiters and metadata
+  let firstSym: TreeSitterNode | null = null;
+  let secondSym: TreeSitterNode | null = null;
+  let count = 0;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if ('()[]{}#'.includes(child.type) || child.type === 'meta_lit') continue;
+    if (child.type === 'sym_lit' || child.type === 'kwd_lit') {
+      count++;
+      if (count === 1) firstSym = child;
+      else if (count === 2) {
+        secondSym = child;
+        break;
+      }
+    }
+  }
+  if (!firstSym) return null;
+  const keyword = firstSym.text;
+  if (
+    keyword !== 'defn' &&
+    keyword !== 'defn-' &&
+    keyword !== 'defmacro' &&
+    keyword !== 'defmethod'
+  )
+    return null;
+  return secondSym ? secondSym.text : null;
+}
+
+function getClojureParamListNode(funcNode: TreeSitterNode): TreeSitterNode | null {
+  if (funcNode.type !== 'list_lit') return null;
+  // Find the first vec_lit child (the parameter vector)
+  for (let i = 0; i < funcNode.childCount; i++) {
+    const child = funcNode.child(i);
+    if (child?.type === 'vec_lit') return child;
+  }
+  return null;
+}
+
+function extractClojureParamName(node: TreeSitterNode): string[] | null {
+  if (node.type === 'sym_lit') return [node.text];
+  return null;
+}
+
+export const dataflowClojure: DataflowRulesConfig = makeDataflowRules({
+  functionNodes: new Set(['list_lit']),
+  nameField: 'name',
+  nameExtractor: extractClojureFunctionName,
+
+  getParamListNode: getClojureParamListNode,
+  paramWrapperTypes: new Set(['sym_lit']),
+  extractParamName: extractClojureParamName,
+
+  returnNode: null, // Clojure: no explicit return; last expression is the result
+
+  callNode: 'list_lit',
+  // Clojure calls are also list_lit nodes — first sym is the function name.
+  // The dataflow visitor will see these as calls (not function defs) since
+  // nameExtractor returns null for non-def forms.
+});

package/src/ast-analysis/rules/b5.ts

@@ -0,0 +1,65 @@
+import type { DataflowRulesConfig } from '../../types.js';
+import { makeDataflowRules } from '../shared.js';
+
+// ─── Zig ──────────────────────────────────────────────────────────────────────
+//
+// Zig function_declaration: name via `childForFieldName('name')` (confirmed in extractor line 68).
+// Parameters: `childForFieldName('parameters')` (confirmed in extractor extractZigParams line 84).
+// Each parameter is a `parameter` node; identifier child is the name (extractor line 89-90).
+// return_statement: Zig has explicit return (confirmed in extractor + language spec).
+// variable_declaration: name is first `identifier` child (extractor handleZigVariable line 99).
+// call_expression: `childForFieldName('function')` (confirmed in extractor handleZigCallExpression line 209).
+// field_expression/field_access: `childForFieldName('field')` or `childForFieldName('member')` (extractor line 215).
+// member object: `childForFieldName('value')` or `funcNode.child(0)` (extractor line 216).
+
+export const dataflowZig: DataflowRulesConfig = makeDataflowRules({
+  functionNodes: new Set(['function_declaration']),
+  nameField: 'name',
+
+  paramListField: 'parameters',
+  paramWrapperTypes: new Set(['parameter']),
+  // Zig parameter: identifier child for the name (extractZigParams uses findChild(param, 'identifier'))
+  paramIdentifier: 'identifier',
+
+  returnNode: 'return_statement',
+
+  varDeclaratorNode: 'variable_declaration',
+  varNameField: 'name',
+
+  callNode: 'call_expression',
+  callFunctionField: 'function',
+  callArgsField: 'arguments',
+
+  memberNode: 'field_expression',
+  memberObjectField: 'value',
+  memberPropertyField: 'field',
+});
+
+// ─── Solidity ─────────────────────────────────────────────────────────────────
+//
+// Solidity function_definition: name via `childForFieldName('name')` (confirmed in extractor line 232).
+// Parameters: `childForFieldName('parameters')` or findChild('parameter_list') (extractor line 355-357).
+// Each parameter is a `parameter` node (extractor uses extractSimpleParameters with paramTypes: ['parameter']).
+// return_statement: Solidity has explicit return.
+// call_expression / function_call: both confirmed in extractor walkSolidityNode line 71-72.
+// call_expression handler: `childForFieldName('function')` or `childForFieldName('callee')` (extractor line 336).
+// member_expression: `childForFieldName('property')` (extractor line 342), `childForFieldName('object')` (line 343).
+
+export const dataflowSolidity: DataflowRulesConfig = makeDataflowRules({
+  functionNodes: new Set(['function_definition', 'modifier_definition']),
+  nameField: 'name',
+
+  paramListField: 'parameters',
+  paramWrapperTypes: new Set(['parameter']),
+  paramIdentifier: 'identifier',
+
+  returnNode: 'return_statement',
+
+  callNodes: new Set(['call_expression', 'function_call']),
+  callFunctionField: 'function',
+  callArgsField: 'arguments',
+
+  memberNode: 'member_expression',
+  memberObjectField: 'object',
+  memberPropertyField: 'property',
+});

package/src/ast-analysis/rules/c.ts

@@ -0,0 +1,157 @@
+import type { DataflowRulesConfig, TreeSitterNode } from '../../types.js';
+import { makeDataflowRules } from '../shared.js';
+
+// ─── C/C++ function-name extraction ──────────────────────────────────────────
+//
+// C/C++ function_definition nests the name inside declarators:
+//   function_definition
+//     declarator: function_declarator
+//       declarator: identifier | pointer_declarator | qualified_identifier | ...
+//       parameters: parameter_list
+//
+// We unwrap through common decorator wrappers to reach the bare identifier.
+
+const DECLARATOR_WRAPPERS = new Set([
+  'pointer_declarator',
+  'reference_declarator',
+  'array_declarator',
+  'parenthesized_declarator',
+  'abstract_function_declarator',
+]);
+
+function unwrapDeclarator(node: TreeSitterNode | null): TreeSitterNode | null {
+  let cur = node;
+  while (cur && DECLARATOR_WRAPPERS.has(cur.type)) {
+    cur = cur.childForFieldName('declarator');
+  }
+  return cur;
+}
+
+function extractCFunctionName(node: TreeSitterNode): string | null {
+  const decl = node.childForFieldName('declarator');
+  if (!decl) return null;
+
+  // For pointer/reference-returning functions (int *foo(), T &bar()), the direct
+  // child is a pointer_declarator or similar wrapper — unwrap one level first.
+  const unwrapped = DECLARATOR_WRAPPERS.has(decl.type)
+    ? decl.childForFieldName('declarator')
+    : decl;
+  const funcDecl = unwrapped?.type === 'function_declarator' ? unwrapped : null;
+  if (!funcDecl) return null;
+
+  const inner = funcDecl.childForFieldName('declarator');
+  const nameNode = unwrapDeclarator(inner);
+  if (!nameNode) return null;
+
+  // qualified_identifier (C++ method): extract the unqualified_identifier
+  if (nameNode.type === 'qualified_identifier') {
+    const unqual =
+      nameNode.childForFieldName('name') ??
+      nameNode.namedChildren[nameNode.namedChildren.length - 1] ??
+      null;
+    return unqual?.text ?? null;
+  }
+
+  return nameNode.type === 'identifier' || nameNode.type === 'field_identifier'
+    ? nameNode.text
+    : null;
+}
+
+// Traverse through pointer/reference/array wrappers to reach function_declarator.
+function findFuncDeclarator(node: TreeSitterNode | null): TreeSitterNode | null {
+  if (!node) return null;
+  if (node.type === 'function_declarator') return node;
+  if (DECLARATOR_WRAPPERS.has(node.type)) {
+    return findFuncDeclarator(node.childForFieldName('declarator'));
+  }
+  return null;
+}
+
+// Navigate function_definition → (optional wrapper) → function_declarator → parameters.
+// Needed because C/C++ params are on function_declarator, not directly on function_definition.
+function getCParamListNode(funcNode: TreeSitterNode): TreeSitterNode | null {
+  const decl = funcNode.childForFieldName('declarator');
+  return findFuncDeclarator(decl)?.childForFieldName('parameters') ?? null;
+}
+
+function extractCParamName(node: TreeSitterNode): string[] | null {
+  if (node.type !== 'parameter_declaration') return null;
+  const decl = node.childForFieldName('declarator');
+  if (!decl) return null;
+
+  // Reference declarator (T& name, T&& name): tree-sitter-cpp uses no named
+  // 'declarator' field inside reference_declarator, so unwrapDeclarator would
+  // return null. Handle it first by taking the last named child.
+  if (decl.type === 'reference_declarator') {
+    const inner = decl.namedChild(decl.namedChildCount - 1);
+    if (inner?.type === 'identifier') return [inner.text];
+    return null;
+  }
+
+  const nameNode = unwrapDeclarator(decl);
+  if (!nameNode) return null;
+  if (nameNode.type === 'identifier') return [nameNode.text];
+  return null;
+}
+
+// ─── C Dataflow rules ─────────────────────────────────────────────────────────
+
+export const dataflow: DataflowRulesConfig = makeDataflowRules({
+  functionNodes: new Set(['function_definition']),
+  nameField: 'declarator',
+  nameExtractor: extractCFunctionName,
+
+  paramListField: 'parameters',
+  getParamListNode: getCParamListNode,
+  paramIdentifier: 'identifier',
+  paramWrapperTypes: new Set(['parameter_declaration']),
+  extractParamName: extractCParamName,
+
+  returnNode: 'return_statement',
+
+  varDeclaratorNode: 'init_declarator',
+  varNameField: 'declarator',
+  varValueField: 'value',
+
+  assignmentNode: 'assignment_expression',
+  assignLeftField: 'left',
+  assignRightField: 'right',
+
+  callNode: 'call_expression',
+  callFunctionField: 'function',
+  callArgsField: 'arguments',
+
+  memberNode: 'field_expression',
+  memberObjectField: 'argument',
+  memberPropertyField: 'field',
+
+  expressionStmtNode: 'expression_statement',
+  mutatingMethods: new Set(),
+});
+
+// C++ extends C with additional function node types
+export const dataflowCpp: DataflowRulesConfig = makeDataflowRules({
+  ...dataflow,
+  functionNodes: new Set([
+    'function_definition',
+    // function_declaration is a forward declaration (no body) in tree-sitter-cpp;
+    // including it creates spurious param vertices from prototypes and can overwrite
+    // correct dataflow_summary rows with flows_to_return=0 when the declaration is
+    // processed after the definition.
+  ]),
+  // C++ call expressions can use :: scope resolution
+  mutatingMethods: new Set([
+    'push_back',
+    'push_front',
+    'insert',
+    'erase',
+    'clear',
+    'resize',
+    'reserve',
+    'emplace',
+    'emplace_back',
+    'emplace_front',
+    'append',
+    'assign',
+  ]),
+});

package/src/ast-analysis/rules/index.ts

@@ -4,6 +4,11 @@ import type {
   DataflowRulesConfig,
   HalsteadRules,
 } from '../../types.js';
+import * as b2 from './b2.js';
+import * as b3 from './b3.js';
+import * as b4 from './b4.js';
+import * as b5 from './b5.js';
+import * as c from './c.js';
 import * as csharp from './csharp.js';
 import * as go from './go.js';
 import * as java from './java.js';
@@ -71,6 +76,35 @@ export const DATAFLOW_RULES: Map<string, DataflowRulesConfig> = new Map([
   ['csharp', csharp.dataflow],
   ['php', php.dataflow],
   ['ruby', ruby.dataflow],
+  // P5 Batch B1: C-family languages
+  ['c', c.dataflow],
+  ['cpp', c.dataflowCpp],
+  ['objc', c.dataflow], // ObjC C-compatible functions; ObjC methods TODO
+  ['cuda', c.dataflowCpp], // CUDA inherits C++ grammar
+  // P5 Batch B2: JVM/mobile languages
+  ['kotlin', b2.dataflowKotlin],
+  ['swift', b2.dataflowSwift],
+  ['scala', b2.dataflowScala],
+  ['dart', b2.dataflowDart],
+  ['groovy', b2.dataflowGroovy],
+  // P5 Batch B3: scripting/dynamic languages
+  ['lua', b3.dataflowLua],
+  ['r', b3.dataflowR],
+  ['julia', b3.dataflowJulia],
+  ['bash', b3.dataflowBash],
+  // P5 Batch B4: functional languages
+  ['haskell', b4.dataflowHaskell],
+  ['ocaml', b4.dataflowOCaml],
+  ['ocaml-interface', b4.dataflowOCaml],
+  ['fsharp', b4.dataflowFSharp],
+  ['fsharp-signature', b4.dataflowFSharp],
+  ['gleam', b4.dataflowGleam],
+  ['elixir', b4.dataflowElixir],
+  ['erlang', b4.dataflowErlang],
+  ['clojure', b4.dataflowClojure],
+  // P5 Batch B5: systems/blockchain languages
+  ['zig', b5.dataflowZig],
+  ['solidity', b5.dataflowSolidity],
 ]);
 
 // ─── AST Node Type Maps ──────────────────────────────────────────────────

package/src/ast-analysis/rules/javascript.ts

@@ -212,6 +212,9 @@ export const dataflow: DataflowRulesConfig = makeDataflowRules({
     'arrow_function',
     'function_expression',
     'function',
+    // Generator functions — tree-sitter-javascript produces separate node types for these
+    'generator_function_declaration',
+    'generator_function',
   ]),
   varAssignedFnParent: 'variable_declarator',
   assignmentFnParent: 'assignment_expression',

package/src/ast-analysis/shared.ts

@@ -80,12 +80,14 @@ export const DATAFLOW_DEFAULTS: DataflowRulesConfig = {
 
   // Function name extraction
   nameField: 'name',
+  nameExtractor: null, // override for languages with nested name structures (C/C++)
   varAssignedFnParent: null, // parent type for `const fn = ...` (JS only)
   assignmentFnParent: null, // parent type for `x = function...` (JS only)
   pairFnParent: null, // parent type for `{ key: function }` (JS only)
 
   // Parameters
   paramListField: 'parameters',
+  getParamListNode: null, // override for nested param lists (C/C++: function_definition→declarator→parameters)
   paramIdentifier: 'identifier',
   paramWrapperTypes: new Set(),
   defaultParamType: null,