@optave/codegraph 3.10.0 → 3.11.1

package/src/ast-analysis/engine.ts

@@ -753,6 +753,146 @@ function allNativeDataComplete(
 
 // ─── Public API ──────────────────────────────────────────────────────────
 
+/** Distribute the per-file walk time equally among the visitors that ran. */
+function accumulateWalkTime(
+  timing: AnalysisTiming,
+  walkMs: number,
+  astVisitor: Visitor | null,
+  complexityVisitor: Visitor | null,
+  cfgVisitor: Visitor | null,
+  dataflowVisitor: Visitor | null,
+): void {
+  const activeCount = [astVisitor, complexityVisitor, cfgVisitor, dataflowVisitor].filter(
+    Boolean,
+  ).length;
+  if (activeCount === 0) return;
+
+  const share = walkMs / activeCount;
+  if (astVisitor) timing.astMs += share;
+  if (complexityVisitor) timing.complexityMs += share;
+  if (cfgVisitor) timing.cfgMs += share;
+  if (dataflowVisitor) timing.dataflowMs += share;
+}
+
+/** Apply visitor walk results to the per-file symbols/definitions. */
+function applyVisitorResults(
+  results: WalkResults,
+  symbols: ExtractorOutput,
+  langId: string,
+  astVisitor: Visitor | null,
+  complexityVisitor: Visitor | null,
+  cfgVisitor: Visitor | null,
+  dataflowVisitor: Visitor | null,
+): void {
+  const defs = symbols.definitions || [];
+
+  if (astVisitor) {
+    const astRows = (results['ast-store'] || []) as ASTNodeRow[];
+    if (astRows.length > 0) symbols.astNodes = astRows;
+  }
+
+  if (complexityVisitor) storeComplexityResults(results, defs, langId);
+  if (cfgVisitor) storeCfgResults(results, defs);
+  if (dataflowVisitor) symbols.dataflow = results.dataflow as DataflowResult;
+}
+
+/** Process a single file: set up visitors, walk the tree, and apply results. */
+function processFileWalk(
+  db: BetterSqlite3Database,
+  relPath: string,
+  symbols: ExtractorOutput,
+  langId: string,
+  opts: AnalysisOpts,
+  timing: AnalysisTiming,
+): void {
+  if (!symbols._tree) return;
+
+  const { visitors, walkerOpts, astVisitor, complexityVisitor, cfgVisitor, dataflowVisitor } =
+    setupVisitors(db, relPath, symbols, langId, opts);
+
+  if (visitors.length === 0) return;
+
+  const walkStart = performance.now();
+  const results = walkWithVisitors(symbols._tree.rootNode, visitors, langId, walkerOpts);
+  const walkMs = performance.now() - walkStart;
+
+  accumulateWalkTime(timing, walkMs, astVisitor, complexityVisitor, cfgVisitor, dataflowVisitor);
+  applyVisitorResults(
+    results,
+    symbols,
+    langId,
+    astVisitor,
+    complexityVisitor,
+    cfgVisitor,
+    dataflowVisitor,
+  );
+}
+
+/**
+ * Unified pre-walk: run all applicable visitors in a single DFS per file.
+ * Returns the total wall-clock time for diagnostics.
+ */
+function runUnifiedWalkPass(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, ExtractorOutput>,
+  extToLang: Map<string, string>,
+  opts: AnalysisOpts,
+  timing: AnalysisTiming,
+): number {
+  const t0walk = performance.now();
+
+  for (const [relPath, symbols] of fileSymbols) {
+    if (!symbols._tree) continue;
+
+    const ext = path.extname(relPath).toLowerCase();
+    const langId = symbols._langId || extToLang.get(ext);
+    if (!langId) continue;
+
+    processFileWalk(db, relPath, symbols, langId, opts, timing);
+  }
+
+  return performance.now() - t0walk;
+}
+
+/** Try native Rust standalone analysis to fill gaps before WASM fallback. */
+function tryNativeStandaloneAnalysis(
+  fileSymbols: Map<string, ExtractorOutput>,
+  rootDir: string,
+  opts: AnalysisOpts,
+  extToLang: Map<string, string>,
+): void {
+  const native = loadNative();
+  if (!native?.analyzeComplexity && !native?.buildCfgAnalysis && !native?.extractDataflowAnalysis) {
+    return;
+  }
+  const t0native = performance.now();
+  runNativeAnalysis(native, fileSymbols, rootDir, opts, extToLang);
+  debug(`native standalone analysis: ${(performance.now() - t0native).toFixed(1)}ms`);
+}
+
+/**
+ * Fast path: when all files were parsed by the native engine with full analysis,
+ * skip WASM re-parse and JS visitor walks entirely and go straight to DB persistence.
+ * Returns true if the fast path handled the work.
+ */
+async function runFastPathIfApplicable(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, ExtractorOutput>,
+  rootDir: string,
+  opts: AnalysisOpts,
+  engineOpts: EngineOpts | undefined,
+  timing: AnalysisTiming,
+): Promise<boolean> {
+  if (!allNativeDataComplete(fileSymbols, opts)) return false;
+
+  debug('native full-analysis fast path: all data present, skipping WASM/visitor passes');
+  const doComplexity = opts.complexity !== false;
+  const doCfg = opts.cfg !== false;
+  if (doComplexity && doCfg) reconcileCfgCyclomatic(fileSymbols);
+  await delegateToBuildFunctions(db, fileSymbols, rootDir, opts, engineOpts, timing);
+  return true;
+}
+
 export async function runAnalyses(
   db: BetterSqlite3Database,
   fileSymbols: Map<string, ExtractorOutput>,
@@ -771,80 +911,24 @@ export async function runAnalyses(
 
   const extToLang = buildExtToLangMap();
 
-  // Fast path: when all files were parsed by the native engine with full analysis
-  // (parseFilesFull), all data is already present — skip WASM re-parse and JS
-  // visitor walks entirely, go straight to DB persistence.
-  if (allNativeDataComplete(fileSymbols, opts)) {
-    debug('native full-analysis fast path: all data present, skipping WASM/visitor passes');
-    if (doComplexity && doCfg) reconcileCfgCyclomatic(fileSymbols);
-    await delegateToBuildFunctions(db, fileSymbols, rootDir, opts, engineOpts, timing);
+  if (await runFastPathIfApplicable(db, fileSymbols, rootDir, opts, engineOpts, timing)) {
     return timing;
   }
 
   // Native analysis pass: try Rust standalone functions before WASM fallback.
   // This fills in complexity/CFG/dataflow for files that the native parse pipeline
   // missed, avoiding the need to parse with WASM + run JS visitors.
-  const native = loadNative();
-  if (native?.analyzeComplexity || native?.buildCfgAnalysis || native?.extractDataflowAnalysis) {
-    const t0native = performance.now();
-    runNativeAnalysis(native, fileSymbols, rootDir, opts, extToLang);
-    debug(`native standalone analysis: ${(performance.now() - t0native).toFixed(1)}ms`);
-  }
+  tryNativeStandaloneAnalysis(fileSymbols, rootDir, opts, extToLang);
 
   // WASM pre-parse for files that still need it (AST store, or native gaps)
   await ensureWasmTreesIfNeeded(fileSymbols, opts, rootDir);
 
-  // Unified pre-walk: run all applicable visitors in a single DFS per file.
   // Time each file's walk and distribute equally among active visitors
   // so that phase timers (astMs, complexityMs, etc.) reflect real work — not
   // just the DB-write tail in delegateToBuildFunctions.
-  const t0walk = performance.now();
-
-  for (const [relPath, symbols] of fileSymbols) {
-    if (!symbols._tree) continue;
-
-    const ext = path.extname(relPath).toLowerCase();
-    const langId = symbols._langId || extToLang.get(ext);
-    if (!langId) continue;
-
-    const { visitors, walkerOpts, astVisitor, complexityVisitor, cfgVisitor, dataflowVisitor } =
-      setupVisitors(db, relPath, symbols, langId, opts);
-
-    if (visitors.length === 0) continue;
-
-    const walkStart = performance.now();
-    const results = walkWithVisitors(symbols._tree.rootNode, visitors, langId, walkerOpts);
-    const walkMs = performance.now() - walkStart;
-
-    // Distribute walk time equally among active visitors
-    const activeCount = [astVisitor, complexityVisitor, cfgVisitor, dataflowVisitor].filter(
-      Boolean,
-    ).length;
-    if (activeCount > 0) {
-      const share = walkMs / activeCount;
-      if (astVisitor) timing.astMs += share;
-      if (complexityVisitor) timing.complexityMs += share;
-      if (cfgVisitor) timing.cfgMs += share;
-      if (dataflowVisitor) timing.dataflowMs += share;
-    }
-
-    const defs = symbols.definitions || [];
-
-    if (astVisitor) {
-      const astRows = (results['ast-store'] || []) as ASTNodeRow[];
-      if (astRows.length > 0) symbols.astNodes = astRows;
-    }
-
-    if (complexityVisitor) storeComplexityResults(results, defs, langId);
-    if (cfgVisitor) storeCfgResults(results, defs);
-    if (dataflowVisitor) symbols.dataflow = results.dataflow as DataflowResult;
-  }
-
-  // Total wall-clock time for the unified walk loop, including per-file
-  // setupVisitors overhead. Walk time is already distributed into per-phase
-  // timers above, so this field overlaps with (astMs + complexityMs + ...).
-  // It is kept as a diagnostic cross-check, not an additive bucket.
-  timing._unifiedWalkMs = performance.now() - t0walk;
+  // _unifiedWalkMs is kept as a diagnostic cross-check (overlaps with the
+  // per-phase timers above, not additive).
+  timing._unifiedWalkMs = runUnifiedWalkPass(db, fileSymbols, extToLang, opts, timing);
 
   // Reconcile: apply CFG-derived cyclomatic override for any definitions that have
   // both precomputed complexity and CFG data but whose cyclomatic was never overridden.

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

@@ -101,6 +101,11 @@ const CPP_AST_TYPES: Record<string, string> = {
   raw_string_literal: 'string',
 };
 
+// CUDA's tree-sitter grammar inherits the full C++ node vocabulary, so the
+// AST node types and quote rules are identical to C++. Mirrors the native
+// `CUDA_AST_CONFIG` in `crates/codegraph-core/src/extractors/helpers.rs`.
+const CUDA_AST_TYPES: Record<string, string> = CPP_AST_TYPES;
+
 const KOTLIN_AST_TYPES: Record<string, string> = {
   throw_expression: 'throw',
   string_literal: 'string',
@@ -153,6 +158,55 @@ const OCAML_AST_TYPES: Record<string, string> = {
   string: 'string',
 };
 
+const FSHARP_AST_TYPES: Record<string, string> = {
+  string: 'string',
+};
+
+const OBJC_AST_TYPES: Record<string, string> = {
+  throw_statement: 'throw',
+  string_literal: 'string',
+};
+
+const GLEAM_AST_TYPES: Record<string, string> = {
+  string: 'string',
+};
+
+const JULIA_AST_TYPES: Record<string, string> = {
+  string_literal: 'string',
+  prefixed_string_literal: 'string',
+};
+
+const CLOJURE_AST_TYPES: Record<string, string> = {
+  str_lit: 'string',
+  regex_lit: 'regex',
+};
+
+const ERLANG_AST_TYPES: Record<string, string> = {
+  string: 'string',
+};
+
+const GROOVY_AST_TYPES: Record<string, string> = {
+  object_creation_expression: 'new',
+  throw_statement: 'throw',
+  string_literal: 'string',
+  // `gstring` listed defensively: tree-sitter-groovy 0.1.x emits `string_literal`
+  // for both single- and double-quoted strings, but some grammar variants use
+  // `gstring` for double-quoted / interpolated strings.
+  gstring: 'string',
+};
+
+const R_AST_TYPES: Record<string, string> = {
+  string: 'string',
+};
+
+const SOLIDITY_AST_TYPES: Record<string, string> = {
+  new_expression: 'new',
+  revert_statement: 'throw',
+  string_literal: 'string',
+  hex_string_literal: 'string',
+  unicode_string_literal: 'string',
+};
+
 export const AST_TYPE_MAPS: Map<string, Record<string, string>> = new Map([
   ['javascript', JS_AST_TYPES],
   ['typescript', JS_AST_TYPES],
@@ -166,6 +220,7 @@ export const AST_TYPE_MAPS: Map<string, Record<string, string>> = new Map([
   ['php', PHP_AST_TYPES],
   ['c', C_AST_TYPES],
   ['cpp', CPP_AST_TYPES],
+  ['cuda', CUDA_AST_TYPES],
   ['kotlin', KOTLIN_AST_TYPES],
   ['swift', SWIFT_AST_TYPES],
   ['scala', SCALA_AST_TYPES],
@@ -177,6 +232,16 @@ export const AST_TYPE_MAPS: Map<string, Record<string, string>> = new Map([
   ['haskell', HASKELL_AST_TYPES],
   ['ocaml', OCAML_AST_TYPES],
   ['ocaml-interface', OCAML_AST_TYPES],
+  ['fsharp', FSHARP_AST_TYPES],
+  ['fsharp-signature', FSHARP_AST_TYPES],
+  ['objc', OBJC_AST_TYPES],
+  ['gleam', GLEAM_AST_TYPES],
+  ['julia', JULIA_AST_TYPES],
+  ['clojure', CLOJURE_AST_TYPES],
+  ['erlang', ERLANG_AST_TYPES],
+  ['groovy', GROOVY_AST_TYPES],
+  ['r', R_AST_TYPES],
+  ['solidity', SOLIDITY_AST_TYPES],
 ]);
 
 // ─── Per-language string-extraction config ───────────────────────────────
@@ -201,6 +266,8 @@ const RB_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"', stringPrefixes: '
 const PHP_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"', stringPrefixes: '' };
 const C_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
 const CPP_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: 'LuUR' };
+// CUDA shares C++ string-literal lexing, including the `L`/`u`/`U`/`R` prefixes.
+const CUDA_STRING_CONFIG: AstStringConfig = CPP_STRING_CONFIG;
 const KOTLIN_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
 const SWIFT_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
 const SCALA_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
@@ -211,6 +278,15 @@ const DART_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"', stringPrefixes:
 const ZIG_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
 const HASKELL_STRING_CONFIG: AstStringConfig = { quoteChars: '"\'', stringPrefixes: '' };
 const OCAML_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const FSHARP_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const OBJC_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const GLEAM_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const JULIA_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const CLOJURE_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const ERLANG_STRING_CONFIG: AstStringConfig = { quoteChars: '"', stringPrefixes: '' };
+const GROOVY_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"', stringPrefixes: '' };
+const R_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"', stringPrefixes: '' };
+const SOLIDITY_STRING_CONFIG: AstStringConfig = { quoteChars: '"\'', stringPrefixes: '' };
 
 export const AST_STRING_CONFIGS: Map<string, AstStringConfig> = new Map([
   ['javascript', JS_STRING_CONFIG],
@@ -225,6 +301,7 @@ export const AST_STRING_CONFIGS: Map<string, AstStringConfig> = new Map([
   ['php', PHP_STRING_CONFIG],
   ['c', C_STRING_CONFIG],
   ['cpp', CPP_STRING_CONFIG],
+  ['cuda', CUDA_STRING_CONFIG],
   ['kotlin', KOTLIN_STRING_CONFIG],
   ['swift', SWIFT_STRING_CONFIG],
   ['scala', SCALA_STRING_CONFIG],
@@ -236,6 +313,16 @@ export const AST_STRING_CONFIGS: Map<string, AstStringConfig> = new Map([
   ['haskell', HASKELL_STRING_CONFIG],
   ['ocaml', OCAML_STRING_CONFIG],
   ['ocaml-interface', OCAML_STRING_CONFIG],
+  ['fsharp', FSHARP_STRING_CONFIG],
+  ['fsharp-signature', FSHARP_STRING_CONFIG],
+  ['objc', OBJC_STRING_CONFIG],
+  ['gleam', GLEAM_STRING_CONFIG],
+  ['julia', JULIA_STRING_CONFIG],
+  ['clojure', CLOJURE_STRING_CONFIG],
+  ['erlang', ERLANG_STRING_CONFIG],
+  ['groovy', GROOVY_STRING_CONFIG],
+  ['r', R_STRING_CONFIG],
+  ['solidity', SOLIDITY_STRING_CONFIG],
 ]);
 
 // ─── Per-language "stop-after-collect" kinds ─────────────────────────────

package/src/ast-analysis/visitor-utils.ts

@@ -88,78 +88,118 @@ export function extractParams(
   return result;
 }
 
-/** Extract names from a rest parameter (e.g. `...args`). */
-function extractRestParamNames(node: TreeSitterNode, rules: LanguageRules): string[] {
-  const nameNode = node.childForFieldName('name');
-  if (nameNode) return [nameNode.text];
-  for (const child of node.namedChildren) {
-    if (child.type === rules.paramIdentifier) return [child.text];
-  }
-  return [];
-}
-
-/** Extract names from an object destructuring pattern (e.g. `{ a, b: c }`). */
-function extractObjectDestructNames(node: TreeSitterNode, rules: LanguageRules): string[] {
-  const names: string[] = [];
-  for (const child of node.namedChildren) {
-    if (rules.shorthandPropPattern && child.type === rules.shorthandPropPattern) {
-      names.push(child.text);
-    } else if (rules.pairPatternType && child.type === rules.pairPatternType) {
-      const value = child.childForFieldName('value');
-      if (value) names.push(...extractParamNames(value, rules));
-    } else if (rules.restParamType && child.type === rules.restParamType) {
-      names.push(...extractParamNames(child, rules));
-    }
-  }
-  return names;
-}
-
-/** Extract names from an array destructuring pattern (e.g. `[a, b]`). */
-function extractArrayDestructNames(node: TreeSitterNode, rules: LanguageRules): string[] {
-  const names: string[] = [];
-  for (const child of node.namedChildren) {
-    names.push(...extractParamNames(child, rules));
-  }
-  return names;
-}
-
 /**
- * Extract parameter names from a single parameter node.
+ * Resolve a single parameter node to either a direct list of names (base case)
+ * or a list of child nodes that still need processing. Returns `null` if the
+ * node yields nothing.
+ *
+ * This base case keeps destructuring helpers from recursing back into
+ * `extractParamNames`, breaking the 3-node mutual recursion cycle between
+ * `extractParamNames`, `extractObjectDestructNames`, and `extractArrayDestructNames`.
  */
-export function extractParamNames(node: TreeSitterNode | null, rules: LanguageRules): string[] {
-  if (!node) return [];
+function resolveParamNode(
+  node: TreeSitterNode,
+  rules: LanguageRules,
+): { names?: string[]; next?: TreeSitterNode[] } | null {
   const t = node.type;
 
   if (rules.extractParamName) {
     const result = rules.extractParamName(node);
-    if (result) return result;
+    if (result) return { names: result };
   }
 
-  if (t === rules.paramIdentifier) return [node.text];
+  if (t === rules.paramIdentifier) return { names: [node.text] };
 
   if (rules.paramWrapperTypes.has(t)) {
     const pattern = node.childForFieldName('pattern') || node.childForFieldName('name');
-    return pattern ? extractParamNames(pattern, rules) : [];
+    return pattern ? { next: [pattern] } : null;
   }
 
   if (rules.defaultParamType && t === rules.defaultParamType) {
     const left = node.childForFieldName('left') || node.childForFieldName('name');
-    return left ? extractParamNames(left, rules) : [];
+    return left ? { next: [left] } : null;
   }
 
   if (rules.restParamType && t === rules.restParamType) {
-    return extractRestParamNames(node, rules);
+    const nameNode = node.childForFieldName('name');
+    if (nameNode) return { names: [nameNode.text] };
+    for (const child of node.namedChildren) {
+      if (child.type === rules.paramIdentifier) return { names: [child.text] };
+    }
+    return null;
   }
 
   if (rules.objectDestructType && t === rules.objectDestructType) {
-    return extractObjectDestructNames(node, rules);
+    return { next: collectObjectDestructChildren(node, rules) };
   }
 
   if (rules.arrayDestructType && t === rules.arrayDestructType) {
-    return extractArrayDestructNames(node, rules);
+    return { next: [...node.namedChildren] };
+  }
+
+  return null;
+}
+
+/**
+ * Collect child nodes from an object destructuring pattern that should be
+ * processed for further name extraction. Returns nodes (not names) so the
+ * caller drives traversal via a worklist instead of recursion.
+ */
+function collectObjectDestructChildren(
+  node: TreeSitterNode,
+  rules: LanguageRules,
+): TreeSitterNode[] {
+  const next: TreeSitterNode[] = [];
+  for (const child of node.namedChildren) {
+    if (rules.shorthandPropPattern && child.type === rules.shorthandPropPattern) {
+      // Shorthand prop is a direct identifier — handled by the shorthand
+      // guard in the `extractParamNames` worklist loop (before `resolveParamNode`).
+      next.push(child);
+    } else if (rules.pairPatternType && child.type === rules.pairPatternType) {
+      const value = child.childForFieldName('value');
+      if (value) next.push(value);
+    } else if (rules.restParamType && child.type === rules.restParamType) {
+      next.push(child);
+    }
   }
+  return next;
+}
 
-  return [];
+/**
+ * Extract parameter names from a single parameter node.
+ *
+ * Uses an iterative worklist to handle nested destructuring (objects, arrays,
+ * defaults, rest, wrappers) without mutual recursion through helper functions.
+ */
+export function extractParamNames(node: TreeSitterNode | null, rules: LanguageRules): string[] {
+  if (!node) return [];
+
+  const names: string[] = [];
+  const stack: TreeSitterNode[] = [node];
+
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) continue;
+
+    // Shorthand identifier inside an object destructuring is just the node's text.
+    if (rules.shorthandPropPattern && current.type === rules.shorthandPropPattern) {
+      names.push(current.text);
+      continue;
+    }
+
+    const resolved = resolveParamNode(current, rules);
+    if (!resolved) continue;
+    if (resolved.names) names.push(...resolved.names);
+    if (resolved.next) {
+      // Push in reverse so traversal order matches the previous recursive order.
+      for (let i = resolved.next.length - 1; i >= 0; i--) {
+        const child = resolved.next[i];
+        if (child) stack.push(child);
+      }
+    }
+  }
+
+  return names;
 }
 
 /**