@optave/codegraph 3.9.5 → 3.10.0

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

@@ -172,4 +172,8 @@ export const dataflow: DataflowRulesConfig = makeDataflowRules({
 
 // ─── AST Node Types ───────────────────────────────────────────────────────
 
-export const astTypes: Record<string, string> | null = null;
+export const astTypes: Record<string, string> | null = {
+  await_expression: 'await',
+  string_literal: 'string',
+  raw_string_literal: 'string',
+};

package/src/ast-analysis/visitors/ast-store-visitor.ts

@@ -5,9 +5,42 @@ import type {
   Visitor,
   VisitorContext,
 } from '../../types.js';
+import type { AstStringConfig } from '../rules/index.js';
 
 const TEXT_MAX = 200;
 
+// ── Cross-language node-type constants (mirror Rust `helpers.rs`) ────────
+const IDENT_TYPES = new Set<string>([
+  'identifier',
+  'type_identifier',
+  'name',
+  'qualified_name',
+  'scoped_identifier',
+  'qualified_identifier',
+  'member_expression',
+  'member_access_expression',
+  'field_expression',
+  'attribute',
+  'scoped_type_identifier',
+]);
+
+const CALL_TYPES = new Set<string>([
+  'call_expression',
+  'call',
+  'invocation_expression',
+  'method_invocation',
+  'function_call_expression',
+  'member_call_expression',
+  'scoped_call_expression',
+]);
+
+const DEFAULT_STRING_CONFIG: AstStringConfig = { quoteChars: '\'"`', stringPrefixes: '' };
+
+// Keyword tokens skipped when extracting the inner expression text of a
+// throw/raise/await/new node. Module-level constant avoids reallocating on
+// every call (can be hot in large files).
+const CHILD_EXPR_SKIP_KEYWORDS = new Set<string>(['throw', 'raise', 'await', 'new']);
+
 interface AstStoreRow {
   file: string;
   line: number;
@@ -20,69 +53,150 @@ interface AstStoreRow {
 
 function truncate(s: string | null | undefined, max: number = TEXT_MAX): string | null {
   if (!s) return null;
-  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+  return s.length <= max ? s : `${s.slice(0, max - 1)}…`;
+}
+
+function trimLeadingChars(s: string, chars: string): string {
+  if (!chars) return s;
+  let i = 0;
+  while (i < s.length && chars.includes(s[i]!)) i++;
+  return i === 0 ? s : s.slice(i);
+}
+
+function trimTrailingChars(s: string, chars: string): string {
+  if (!chars) return s;
+  let i = s.length;
+  while (i > 0 && chars.includes(s[i - 1]!)) i--;
+  return i === s.length ? s : s.slice(0, i);
 }
 
-function extractNewName(node: TreeSitterNode): string {
+/** Extract constructor name from a `new_expression` / `object_creation_expression`. */
+function extractConstructorName(node: TreeSitterNode): string {
+  for (const field of ['type', 'class', 'constructor']) {
+    const f = node.childForFieldName(field);
+    if (f?.text) return f.text;
+  }
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
-    if (child.type === 'identifier') return child.text;
-    if (child.type === 'member_expression') return child.text;
+    if (IDENT_TYPES.has(child.type)) return child.text;
   }
-  return node.text?.split('(')[0]?.replace('new ', '').trim() || '?';
+  const raw = node.text || '';
+  const beforeParen = raw.split('(')[0] || raw;
+  return beforeParen.replace(/^new\s+/, '').trim() || '?';
 }
 
-function extractExpressionText(node: TreeSitterNode): string | null {
+/** Extract function name from a call node. */
+function extractCallName(node: TreeSitterNode): string {
+  for (const field of ['function', 'method', 'name']) {
+    const f = node.childForFieldName(field);
+    if (f?.text) return f.text;
+  }
+  const text = node.text || '';
+  return text.split('(')[0] || '?';
+}
+
+/** Extract name from a throw/raise statement — matches native `extract_throw_target`. */
+function extractThrowName(node: TreeSitterNode, newTypes: Set<string>): string {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
-    if (child.type !== 'throw' && child.type !== 'await') {
-      return truncate(child.text);
-    }
+    const ck = child.type;
+    if (newTypes.has(ck)) return extractConstructorName(child);
+    if (CALL_TYPES.has(ck)) return extractCallName(child);
+    if (IDENT_TYPES.has(ck)) return child.text;
   }
-  return truncate(node.text);
+  return truncate(node.text) ?? node.text ?? '';
 }
 
-/** Extract the name from a throw statement's child nodes. */
-function extractThrowName(node: TreeSitterNode): string | null {
+/** Extract name from an await expression — matches native `extract_awaited_name`. */
+function extractAwaitName(node: TreeSitterNode): string {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
-    if (child.type === 'new_expression') return extractNewName(child);
-    if (child.type === 'call_expression') {
-      const fn = child.childForFieldName('function');
-      return fn ? fn.text : child.text?.split('(')[0] || '?';
-    }
-    if (child.type === 'identifier') return child.text;
+    const ck = child.type;
+    if (CALL_TYPES.has(ck)) return extractCallName(child);
+    if (IDENT_TYPES.has(ck)) return child.text;
   }
-  return truncate(node.text);
+  return truncate(node.text) ?? node.text ?? '';
 }
 
-/** Extract the name from an await expression's child nodes. */
-function extractAwaitName(node: TreeSitterNode): string | null {
+/** Extract text of the expression inside a throw/await, skipping the keyword. */
+function extractChildExpressionText(node: TreeSitterNode): string | null {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
-    if (child.type === 'call_expression') {
-      const fn = child.childForFieldName('function');
-      return fn ? fn.text : child.text?.split('(')[0] || '?';
-    }
-    if (child.type === 'identifier' || child.type === 'member_expression') {
-      return child.text;
-    }
+    if (!CHILD_EXPR_SKIP_KEYWORDS.has(child.type)) return truncate(child.text);
   }
   return truncate(node.text);
 }
 
+/**
+ * Count code points cheaply: skip the `[...s]` spread when `s.length` already
+ * decides the answer. Each code point is 1 or 2 UTF-16 units, so `.length < 2`
+ * implies `< 2` code points and `.length >= 3` already guarantees `>= 2` code
+ * points (worst case: one surrogate pair + one BMP char = 2 code points).
+ * Only `.length === 2` is genuinely ambiguous (could be a single surrogate
+ * pair = 1 code point, or two BMP chars = 2 code points) and needs the spread.
+ */
+function codePointCountAtLeast2(s: string): boolean {
+  const len = s.length;
+  if (len < 2) return false;
+  if (len >= 3) return true;
+  return [...s].length >= 2;
+}
+
+/**
+ * Extract string content from a string-literal node, mirroring the native
+ * engine's `build_string_node` (`helpers.rs`). Returns `null` when the
+ * content is shorter than 2 Unicode code points.
+ */
+function extractStringContent(node: TreeSitterNode, cfg: AstStringConfig): string | null {
+  const raw = node.text ?? '';
+  const isRawString = node.type.includes('raw_string');
+
+  let s = raw;
+  s = trimLeadingChars(s, '@');
+  if (cfg.stringPrefixes) s = trimLeadingChars(s, cfg.stringPrefixes);
+  if (isRawString) s = trimLeadingChars(s, 'r#');
+  s = trimLeadingChars(s, cfg.quoteChars);
+  if (isRawString) s = trimTrailingChars(s, '#');
+  s = trimTrailingChars(s, cfg.quoteChars);
+
+  return codePointCountAtLeast2(s) ? s : null;
+}
+
+// Per-astTypeMap cache for the set of node-types that map to kind 'new'.
+// Computed once per unique astTypeMap reference (one per language) instead
+// of once per file.
+const _newTypesCache = new WeakMap<Record<string, string>, Set<string>>();
+function newTypesFor(astTypeMap: Record<string, string>): Set<string> {
+  let s = _newTypesCache.get(astTypeMap);
+  if (s) return s;
+  s = new Set<string>();
+  for (const type in astTypeMap) {
+    if (astTypeMap[type] === 'new') s.add(type);
+  }
+  _newTypesCache.set(astTypeMap, s);
+  return s;
+}
+
 export function createAstStoreVisitor(
   astTypeMap: Record<string, string>,
   defs: Definition[],
   relPath: string,
   nodeIdMap: Map<string, number>,
+  stringConfig: AstStringConfig = DEFAULT_STRING_CONFIG,
+  stopRecurseKinds: ReadonlySet<string> = new Set(),
 ): Visitor {
   const rows: AstStoreRow[] = [];
   const matched = new Set<number>();
+  const newTypes = newTypesFor(astTypeMap);
+  // When nodeIdMap is empty, parentNodeId resolution is wasted work — the
+  // worker passes an empty map and the main thread re-resolves against its
+  // own DB-populated map in features/ast.ts::collectFileAstRows. Skip the
+  // findParentDef linear scan in that case.
+  const skipParentLookup = nodeIdMap.size === 0;
 
   function findParentDef(line: number): Definition | null {
     let best: Definition | null = null;
@@ -97,6 +211,7 @@ export function createAstStoreVisitor(
   }
 
   function resolveParentNodeId(line: number): number | null {
+    if (skipParentLookup) return null;
     const parentDef = findParentDef(line);
     if (!parentDef) return null;
     return nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null;
@@ -106,12 +221,15 @@ export function createAstStoreVisitor(
   type KindHandler = (node: TreeSitterNode) => NameTextResult;
 
   const kindHandlers: Record<string, KindHandler> = {
-    new: (node) => ({ name: extractNewName(node), text: truncate(node.text) }),
-    throw: (node) => ({ name: extractThrowName(node), text: extractExpressionText(node) }),
-    await: (node) => ({ name: extractAwaitName(node), text: extractExpressionText(node) }),
+    new: (node) => ({ name: extractConstructorName(node), text: truncate(node.text) }),
+    throw: (node) => ({
+      name: extractThrowName(node, newTypes),
+      text: extractChildExpressionText(node),
+    }),
+    await: (node) => ({ name: extractAwaitName(node), text: extractChildExpressionText(node) }),
     string: (node) => {
-      const content = node.text?.replace(/^['"`]|['"`]$/g, '') || '';
-      if (content.length < 2) return { name: null, text: null, skip: true };
+      const content = extractStringContent(node, stringConfig);
+      if (content == null) return { name: null, text: null, skip: true };
       return { name: truncate(content, 100), text: truncate(node.text) };
     },
     regex: (node) => ({ name: node.text || '?', text: truncate(node.text) }),
@@ -151,12 +269,25 @@ export function createAstStoreVisitor(
       // unrelated subtree. The parent call's skipChildren handles the intended case.
       if (matched.has(node.id)) return;
 
+      // Gate with `hasOwn` because plain-object lookup walks Object.prototype:
+      // tree-sitter node types like `constructor` (Haskell sum-types: Left,
+      // Right) would otherwise resolve to `Object.prototype.constructor` (the
+      // Object() function), which then crashes the worker boundary with
+      // "function Object() { [native code] } could not be cloned" when the
+      // resulting astNodes row is structured-cloned back to the main thread.
+      if (!Object.hasOwn(astTypeMap, node.type)) return;
       const kind = astTypeMap[node.type];
       if (!kind) return;
 
       collectNode(node, kind);
 
-      if (kind !== 'string' && kind !== 'regex') {
+      // Mirror the native walker's recursion policy. In JS/TS, the native
+      // javascript.rs walker returns after collecting `new` or `throw` to
+      // avoid double-counting the wrapped expression (e.g. `throw new
+      // Error('x')` emits one `throw` row, not throw+new+string). Other
+      // languages go through helpers.rs::walk_ast_nodes_with_config_depth
+      // which always recurses — so `stopRecurseKinds` is empty for them.
+      if (stopRecurseKinds.has(kind)) {
         return { skipChildren: true };
       }
     },

package/src/domain/graph/builder/context.ts

@@ -28,6 +28,16 @@ export class PipelineContext {
   engineOpts!: EngineOpts;
   engineName!: 'native' | 'wasm';
   engineVersion!: string | null;
+  /**
+   * The version reported by the native binary itself (CARGO_PKG_VERSION at
+   * build time), as opposed to `engineVersion` which prefers the platform
+   * package.json. The Rust orchestrator's check_version_mismatch compares
+   * `build_meta.engine_version` against CARGO_PKG_VERSION, so build_meta
+   * writes must use this value to avoid a perpetual full-rebuild loop when
+   * the binary and platform package.json drift apart (e.g., CI hot-swap
+   * via ci-install-native.mjs — #1066).
+   */
+  nativeBinaryVersion!: string | null;
   aliases!: PathAliases;
   incremental!: boolean;
   forceFullRebuild: boolean = false;

package/src/domain/graph/builder/helpers.ts

@@ -222,12 +222,17 @@ export function fileHash(content: string): string {
 }
 
 /**
- * Stat a file, returning { mtimeMs, size } or null on error.
+ * Stat a file, returning { mtime, size } or null on error.
+ *
+ * `mtime` is `Math.floor(stat.mtimeMs)` so it matches the integer column
+ * stored in the DB. Floor-once-here keeps every consumer honest: storing or
+ * comparing a non-floored `mtimeMs` against the integer DB column would cause
+ * spurious fast-skip misses on the next build.
  */
-export function fileStat(filePath: string): { mtimeMs: number; size: number } | null {
+export function fileStat(filePath: string): { mtime: number; size: number } | null {
   try {
     const s = fs.statSync(filePath);
-    return { mtimeMs: s.mtimeMs, size: s.size };
+    return { mtime: Math.floor(s.mtimeMs), size: s.size };
   } catch {
     return null;
   }