@optave/codegraph 3.13.0 → 3.15.0

package/src/ast-analysis/engine.ts

@@ -358,6 +358,32 @@ function reconcileCfgCyclomatic(fileSymbols: Map<string, ExtractorOutput>): void
 
 // ─── WASM pre-parse ─────────────────────────────────────────────────────
 
+// ─── Per-file analysis predicates ───────────────────────────────────────
+
+/** Whether a file needs WASM AST extraction (astNodes not yet populated). */
+function fileNeedsWasmAst(symbols: ExtractorOutput, ext: string, lid: string): boolean {
+  return !Array.isArray(symbols.astNodes) && (WALK_EXTENSIONS.has(ext) || AST_TYPE_MAPS.has(lid));
+}
+
+/** Whether a file needs WASM complexity analysis (any function body missing metrics). */
+function fileNeedsWasmComplexity(symbols: ExtractorOutput, ext: string, lid: string): boolean {
+  if (!COMPLEXITY_EXTENSIONS.has(ext) && !COMPLEXITY_RULES.has(lid)) return false;
+  const defs = symbols.definitions || [];
+  return defs.some((d) => hasFuncBody(d) && !d.complexity);
+}
+
+/** Whether a file needs WASM CFG analysis (any function body missing CFG blocks). */
+function fileNeedsWasmCfg(symbols: ExtractorOutput, ext: string, lid: string): boolean {
+  if (!CFG_EXTENSIONS.has(ext) && !CFG_RULES.has(lid)) return false;
+  const defs = symbols.definitions || [];
+  return defs.some((d) => hasFuncBody(d) && d.cfg !== null && !Array.isArray(d.cfg?.blocks));
+}
+
+/** Whether a file needs WASM dataflow analysis (dataflow not yet populated). */
+function fileNeedsWasmDataflow(symbols: ExtractorOutput, ext: string, lid: string): boolean {
+  return !symbols.dataflow && (DATAFLOW_EXTENSIONS.has(ext) || DATAFLOW_RULES.has(lid));
+}
+
 /** Check whether a single file needs a WASM tree for any enabled analysis pass. */
 function fileNeedsWasmTree(
   relPath: string,
@@ -366,33 +392,12 @@ function fileNeedsWasmTree(
 ): boolean {
   if (symbols._tree) return false;
   const ext = path.extname(relPath).toLowerCase();
-  const defs = symbols.definitions || [];
   const lid = symbols._langId || '';
 
-  if (
-    flags.doAst &&
-    !Array.isArray(symbols.astNodes) &&
-    (WALK_EXTENSIONS.has(ext) || AST_TYPE_MAPS.has(lid))
-  )
-    return true;
-  if (
-    flags.doComplexity &&
-    (COMPLEXITY_EXTENSIONS.has(ext) || COMPLEXITY_RULES.has(lid)) &&
-    defs.some((d) => hasFuncBody(d) && !d.complexity)
-  )
-    return true;
-  if (
-    flags.doCfg &&
-    (CFG_EXTENSIONS.has(ext) || CFG_RULES.has(lid)) &&
-    defs.some((d) => hasFuncBody(d) && d.cfg !== null && !Array.isArray(d.cfg?.blocks))
-  )
-    return true;
-  if (
-    flags.doDataflow &&
-    !symbols.dataflow &&
-    (DATAFLOW_EXTENSIONS.has(ext) || DATAFLOW_RULES.has(lid))
-  )
-    return true;
+  if (flags.doAst && fileNeedsWasmAst(symbols, ext, lid)) return true;
+  if (flags.doComplexity && fileNeedsWasmComplexity(symbols, ext, lid)) return true;
+  if (flags.doCfg && fileNeedsWasmCfg(symbols, ext, lid)) return true;
+  if (flags.doDataflow && fileNeedsWasmDataflow(symbols, ext, lid)) return true;
   return false;
 }
 
@@ -701,50 +706,25 @@ function allNativeDataComplete(
     const ext = path.extname(relPath).toLowerCase();
     const langId = symbols._langId || '';
 
-    // AST nodes: native must have produced them
-    if (
-      doAst &&
-      !Array.isArray(symbols.astNodes) &&
-      (WALK_EXTENSIONS.has(ext) || AST_TYPE_MAPS.has(langId))
-    ) {
+    if (doAst && fileNeedsWasmAst(symbols, ext, langId)) {
       debug(`allNativeDataComplete: ${relPath} missing astNodes`);
       return false;
     }
-
-    // Dataflow: native must have produced it
-    if (
-      doDataflow &&
-      !symbols.dataflow &&
-      (DATAFLOW_EXTENSIONS.has(ext) || DATAFLOW_RULES.has(langId))
-    ) {
+    if (doDataflow && fileNeedsWasmDataflow(symbols, ext, langId)) {
       debug(`allNativeDataComplete: ${relPath} missing dataflow`);
       return false;
     }
-
-    const defs = symbols.definitions || [];
-    for (const def of defs) {
-      if (!hasFuncBody(def)) continue;
-
-      // Complexity: every function must already have it
-      if (
-        doComplexity &&
-        !def.complexity &&
-        (COMPLEXITY_EXTENSIONS.has(ext) || COMPLEXITY_RULES.has(langId))
-      ) {
-        debug(`allNativeDataComplete: ${relPath}:${def.name} missing complexity`);
-        return false;
-      }
-
-      // CFG: every function must already have blocks
-      if (
-        doCfg &&
-        def.cfg !== null &&
-        !Array.isArray(def.cfg?.blocks) &&
-        (CFG_EXTENSIONS.has(ext) || CFG_RULES.has(langId))
-      ) {
-        debug(`allNativeDataComplete: ${relPath}:${def.name} missing cfg blocks`);
-        return false;
-      }
+    if (doComplexity && fileNeedsWasmComplexity(symbols, ext, langId)) {
+      const offender = (symbols.definitions || []).find((d) => hasFuncBody(d) && !d.complexity);
+      debug(`allNativeDataComplete: ${relPath}:${offender?.name ?? '?'} missing complexity`);
+      return false;
+    }
+    if (doCfg && fileNeedsWasmCfg(symbols, ext, langId)) {
+      const offender = (symbols.definitions || []).find(
+        (d) => hasFuncBody(d) && d.cfg !== null && !Array.isArray(d.cfg?.blocks),
+      );
+      debug(`allNativeDataComplete: ${relPath}:${offender?.name ?? '?'} missing cfg blocks`);
+      return false;
     }
   }
 

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

@@ -0,0 +1,263 @@
+import type { DataflowRulesConfig, TreeSitterNode } from '../../types.js';
+import { makeDataflowRules } from '../shared.js';
+
+// ─── Kotlin ───────────────────────────────────────────────────────────────────
+//
+// Kotlin function_declaration wraps params in `function_value_parameters`.
+// The name is a `simple_identifier` direct child (found via findChild in extractor).
+// call_expression: first child is simple_identifier OR navigation_expression (method call).
+// navigation_expression: acts as member access for `obj.method()`.
+// Field names for call function/args are NOT standard named fields in tree-sitter-kotlin,
+// so we leave callFunctionField/callArgsField at defaults — childForFieldName returns null
+// gracefully and the analysis falls back to skipping arg tracking.
+
+function getKotlinParamListNode(funcNode: TreeSitterNode): TreeSitterNode | null {
+  for (const child of funcNode.namedChildren) {
+    if (child.type === 'function_value_parameters') return child;
+  }
+  return null;
+}
+
+function extractKotlinParamName(node: TreeSitterNode): string[] | null {
+  if (node.type !== 'parameter') return null;
+  const nameNode = node.childForFieldName('name');
+  if (nameNode) return [nameNode.text];
+  // Fallback: find simple_identifier among named children
+  for (const child of node.namedChildren) {
+    if (child.type === 'simple_identifier') return [child.text];
+  }
+  return null;
+}
+
+export const dataflowKotlin: DataflowRulesConfig = makeDataflowRules({
+  functionNodes: new Set(['function_declaration']),
+  nameField: 'name',
+
+  getParamListNode: getKotlinParamListNode,
+  paramWrapperTypes: new Set(['parameter']),
+  extractParamName: extractKotlinParamName,
+
+  returnNode: 'return_statement',
+
+  callNode: 'call_expression',
+  // tree-sitter-kotlin does not expose standard named fields for call function/args;
+  // defaults ('function'/'arguments') will return null gracefully.
+
+  memberNode: 'navigation_expression',
+  // Field names for navigation_expression object/property also lack standard names;
+  // defaults will return null gracefully.
+});
+
+// ─── Swift ────────────────────────────────────────────────────────────────────
+//
+// Swift function_declaration: name is `simple_identifier`, params in child node.
+// The extractor uses findChild(node, 'simple_identifier') for the function name.
+// Swift's tree-sitter grammar wraps params in a `parameter` or `parameters` node.
+// call_expression: first child is simple_identifier or navigation_expression.
+// navigation_expression: obj.method() — last child is navigation_suffix > simple_identifier.
+
+function getSwiftParamListNode(funcNode: TreeSitterNode): TreeSitterNode | null {
+  // Look for parameter_clause or parameters as a direct child
+  for (let i = 0; i < funcNode.childCount; i++) {
+    const child = funcNode.child(i);
+    if (!child) continue;
+    if (child.type === 'parameter_clause' || child.type === 'parameters') return child;
+  }
+  return null;
+}
+
+function extractSwiftParamName(node: TreeSitterNode): string[] | null {
+  if (node.type === 'parameter') {
+    // Swift parameters have internal label + external label; use internal name
+    // The `name` field in tree-sitter-swift is the internal parameter name
+    const nameNode = node.childForFieldName('name') ?? node.childForFieldName('internal_name');
+    if (nameNode) return [nameNode.text];
+    // Fallback: find simple_identifier
+    for (const child of node.namedChildren) {
+      if (child.type === 'simple_identifier') return [child.text];
+    }
+  }
+  return null;
+}
+
+export const dataflowSwift: DataflowRulesConfig = makeDataflowRules({
+  functionNodes: new Set(['function_declaration']),
+  nameField: 'name',
+
+  getParamListNode: getSwiftParamListNode,
+  paramWrapperTypes: new Set(['parameter']),
+  extractParamName: extractSwiftParamName,
+
+  returnNode: 'return_statement',
+
+  callNode: 'call_expression',
+  // tree-sitter-swift call_expression: function is first child, args follow.
+  // No standard named fields — leave defaults to return null gracefully.
+
+  memberNode: 'navigation_expression',
+  // navigation_expression field names are non-standard in tree-sitter-swift.
+});
+
+// ─── Scala ────────────────────────────────────────────────────────────────────
+//
+// Scala function_definition: `node.childForFieldName('name')` for the name (confirmed
+// in extractor). Parameters are via findChild(funcNode, 'parameters') (no named field).
+// call_expression: `childForFieldName('function')` confirmed in extractor line 146.
+// field_expression: `childForFieldName('value')` = object, `childForFieldName('field')` = property.
+// val_definition / var_definition: `childForFieldName('pattern')` = name side.
+
+function getScalaParamListNode(funcNode: TreeSitterNode): TreeSitterNode | null {
+  // Scala parameters list is a direct child; extractor uses findChild(funcNode, 'parameters')
+  for (let i = 0; i < funcNode.childCount; i++) {
+    const child = funcNode.child(i);
+    if (child?.type === 'parameters') return child;
+  }
+  return null;
+}
+
+function extractScalaParamName(node: TreeSitterNode): string[] | null {
+  if (node.type !== 'parameter') return null;
+  // Extractor uses findChild(param, 'identifier')
+  for (const child of node.namedChildren) {
+    if (child.type === 'identifier') return [child.text];
+  }
+  return null;
+}
+
+export const dataflowScala: DataflowRulesConfig = makeDataflowRules({
+  functionNodes: new Set(['function_definition']),
+  nameField: 'name',
+
+  getParamListNode: getScalaParamListNode,
+  paramWrapperTypes: new Set(['parameter']),
+  extractParamName: extractScalaParamName,
+
+  returnNode: 'return_expression',
+
+  varDeclaratorNodes: new Set(['val_definition', 'var_definition']),
+  varNameField: 'pattern',
+
+  callNode: 'call_expression',
+  callFunctionField: 'function',
+  callArgsField: 'arguments',
+
+  memberNode: 'field_expression',
+  memberObjectField: 'value',
+  memberPropertyField: 'field',
+});
+
+// ─── Dart ─────────────────────────────────────────────────────────────────────
+//
+// Dart uses `function_signature` for top-level functions and `method_signature`
+// for class methods (both confirmed in extractor). The extractor uses
+// `childForFieldName('name')` for the function name on both node types.
+// Dart call: `selector` node with `argument_part` — the extractor uses this.
+// There is no standard `call_expression` node type in tree-sitter-dart.
+// We use `function_signature` as the primary function node type.
+// Parameters: `childForFieldName('parameters')` on function_signature (confirmed in extractor).
+
+function extractDartParamName(node: TreeSitterNode): string[] | null {
+  // Dart: parameter types include 'formal_parameter', 'named_formal_parameter',
+  // 'optional_formal_parameter', and bare 'identifier'
+  if (
+    node.type === 'formal_parameter' ||
+    node.type === 'optional_formal_parameter' ||
+    node.type === 'named_formal_parameter'
+  ) {
+    const nameNode = node.childForFieldName('name');
+    if (nameNode) return [nameNode.text];
+    // Fallback: last identifier child is usually the name
+    let lastName: string | null = null;
+    for (const child of node.namedChildren) {
+      if (child.type === 'identifier') lastName = child.text;
+    }
+    if (lastName) return [lastName];
+  }
+  if (node.type === 'identifier') return [node.text];
+  return null;
+}
+
+export const dataflowDart: DataflowRulesConfig = makeDataflowRules({
+  functionNodes: new Set(['function_signature', 'method_signature']),
+  nameField: 'name',
+
+  paramListField: 'parameters',
+  paramWrapperTypes: new Set([
+    'formal_parameter',
+    'optional_formal_parameter',
+    'named_formal_parameter',
+  ]),
+  extractParamName: extractDartParamName,
+
+  returnNode: 'return_statement',
+
+  callNode: 'call_expression',
+  // tree-sitter-dart does not have standard named fields for calls;
+  // the extractor uses `selector` nodes instead. Leave defaults.
+});
+
+// ─── Groovy ───────────────────────────────────────────────────────────────────
+//
+// Groovy has multiple function node types (method_definition/declaration,
+// constructor_definition/declaration, function_definition/declaration).
+// Params: `childForFieldName('parameters')` with fallback to findChild('formal_parameters')
+// (confirmed in extractor extractGroovyParams, line 334).
+// call_expression: `childForFieldName('function')` confirmed in extractor line 299.
+// field_expression: `childForFieldName('argument')` = object (confirmed in extractor line 303),
+// `childForFieldName('field')` = property.
+
+function getGroovyParamListNode(funcNode: TreeSitterNode): TreeSitterNode | null {
+  const byField = funcNode.childForFieldName('parameters');
+  if (byField) return byField;
+  // Fallback: search for formal_parameters child
+  for (let i = 0; i < funcNode.childCount; i++) {
+    const child = funcNode.child(i);
+    if (child?.type === 'formal_parameters') return child;
+  }
+  return null;
+}
+
+function extractGroovyParamName(node: TreeSitterNode): string[] | null {
+  if (node.type === 'formal_parameter' || node.type === 'parameter') {
+    const nameNode = node.childForFieldName('name');
+    if (nameNode) return [nameNode.text];
+    // Fallback: first identifier child
+    for (const child of node.namedChildren) {
+      if (child.type === 'identifier') return [child.text];
+    }
+  }
+  return null;
+}
+
+export const dataflowGroovy: DataflowRulesConfig = makeDataflowRules({
+  functionNodes: new Set([
+    'method_definition',
+    'method_declaration',
+    'constructor_definition',
+    'constructor_declaration',
+    'function_definition',
+    'function_declaration',
+  ]),
+  nameField: 'name',
+
+  getParamListNode: getGroovyParamListNode,
+  paramWrapperTypes: new Set(['formal_parameter', 'parameter']),
+  extractParamName: extractGroovyParamName,
+
+  returnNode: 'return_statement',
+
+  varDeclaratorNode: 'variable_declarator',
+
+  callNodes: new Set([
+    'call_expression',
+    'function_call',
+    'juxt_function_call',
+    'method_invocation',
+  ]),
+  callFunctionField: 'function',
+  callArgsField: 'arguments',
+
+  memberNode: 'field_expression',
+  memberObjectField: 'argument',
+  memberPropertyField: 'field',
+});

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

@@ -0,0 +1,127 @@
+import type { DataflowRulesConfig } from '../../types.js';
+import { makeDataflowRules } from '../shared.js';
+
+// ─── Lua ──────────────────────────────────────────────────────────────────────
+//
+// Lua function_declaration: name via `childForFieldName('name')` (confirmed in extractor line 47).
+// The name node may be `method_index_expression`, `dot_index_expression`, or `identifier`.
+// Parameters: `childForFieldName('parameters')` (confirmed in extractor line 89) — returns
+// a node containing `identifier` children directly (no wrapper type).
+// function_call: name via `childForFieldName('name')` (confirmed in extractor line 132).
+// dot_index_expression: table=`childForFieldName('table')`, field=`childForFieldName('field')`.
+// method_index_expression: table=`childForFieldName('table')`, method=`childForFieldName('method')`.
+
+export const dataflowLua: DataflowRulesConfig = makeDataflowRules({
+  functionNodes: new Set(['function_declaration']),
+  nameField: 'name',
+
+  paramListField: 'parameters',
+  // Lua params are bare identifier children in the param list — no wrapper type
+  paramIdentifier: 'identifier',
+
+  returnNode: 'return_statement',
+
+  callNode: 'function_call',
+  callFunctionField: 'name',
+  callArgsField: 'arguments',
+
+  memberNode: 'dot_index_expression',
+  memberObjectField: 'table',
+  memberPropertyField: 'field',
+});
+
+// ─── R ────────────────────────────────────────────────────────────────────────
+//
+// R functions are defined as: `name <- function_definition` (binary_operator with `<-`).
+// The extractor handles this as binary_operator + function_definition on the RHS.
+// There is no standalone function declaration node — `function_definition` is always
+// an RHS expression. The parent `binary_operator` is the true "function node".
+// R does NOT have an explicit `return` statement keyword that always appears —
+// `return()` is a regular function call. Set returnNode: null.
+// call node: `call` (confirmed in extractor handleCall line 111).
+// The call node's first child (not a named field) is the function expression.
+// Parameters: findChild(funcDef, 'parameters') on function_definition (extractor line 88).
+// Each parameter is a `parameter` node with `childForFieldName('name')` or identifier child.
+
+export const dataflowR: DataflowRulesConfig = makeDataflowRules({
+  // R functions are the `binary_operator` node where RHS is `function_definition`.
+  // We track the binary_operator as a function scope, but the param list lives
+  // inside the nested `function_definition` child. This is best-effort: the
+  // unified dataflow walker will find `binary_operator` nodes but may not locate
+  // the param list via the standard field walk. Most analysis benefit comes from
+  // variable tracking and call arg flows.
+  // Use function_definition directly: the walker will enter it as function scope.
+  functionNodes: new Set(['function_definition']),
+  // R function_definition has no 'name' field — the name comes from the enclosing
+  // binary_operator's LHS. The nameExtractor is not needed here since the
+  // extractor handles name resolution; the dataflow visitor just needs to find
+  // the function scope boundary.
+  nameField: 'name',
+
+  paramListField: 'parameters',
+  paramWrapperTypes: new Set(['parameter']),
+
+  returnNode: null, // R uses return() as a function call, not a statement
+
+  callNode: 'call',
+  // R `call` node has the function as its first child (not a named field).
+  // Leaving callFunctionField at default 'function' — childForFieldName will
+  // return null, and the analysis falls back to skipping the callee name.
+
+  assignmentNode: 'binary_operator',
+  assignLeftField: 'left',
+  assignRightField: 'right',
+});
+
+// ─── Julia ────────────────────────────────────────────────────────────────────
+//
+// Julia function_definition: extractor uses a `signature` child → `call_expression`
+// to find the function name + params (complex nesting). The function node type
+// is `function_definition` (confirmed in extractor line 41).
+// The params are inside the signature's call_expression's argument_list.
+// For dataflow purposes, we just mark function_definition as the scope boundary.
+// Params are inside function_definition → signature → call_expression → argument_list.
+// Since there's no direct param list field on function_definition, use getParamListNode.
+// call_expression: `node.child(0)` for function name (confirmed in extractor handleCall line 387).
+// Julia has explicit `return_statement` (confirmed in extractor comment: "Julia has explicit return").
+// variable assignment: `assignment` node (confirmed in extractor handleAssignment line 158).
+
+export const dataflowJulia: DataflowRulesConfig = makeDataflowRules({
+  functionNodes: new Set(['function_definition']),
+  nameField: 'name',
+
+  // Julia params are buried deep: function_definition → signature → call_expression → argument_list.
+  // No direct named field on function_definition for params. Leave param extraction
+  // to best-effort: getParamListNode returns null (default), so params will be skipped
+  // gracefully. The primary value is function scope tracking and call arg flows.
+  paramListField: 'parameters',
+
+  returnNode: 'return_statement',
+
+  assignmentNode: 'assignment',
+  assignLeftField: 'left',
+  assignRightField: 'right',
+
+  callNode: 'call_expression',
+  // Julia call_expression: first child is the function (no named field 'function').
+  // Leave callFunctionField at default — will return null gracefully.
+});
+
+// ─── Bash ─────────────────────────────────────────────────────────────────────
+//
+// Bash function_definition: name via `childForFieldName('name')` (confirmed in extractor line 42).
+// Bash has no typed parameters or return values.
+// command: `command_name` child (extractor handleBashCommand line 55).
+// No param lists, no return nodes, no variable declarators in the conventional sense.
+// Minimal config — primarily useful for function scope tracking and call edges.
+
+export const dataflowBash: DataflowRulesConfig = makeDataflowRules({
+  functionNodes: new Set(['function_definition']),
+  nameField: 'name',
+
+  returnNode: null, // Bash has no explicit return statement node (return is a command)
+
+  callNode: 'command',
+  // Bash `command` node: function name is in `command_name` child (not a named field).
+  // Leave callFunctionField at default — will return null gracefully.
+});