genesis-compiler 1.10.6 → 1.10.8

package/src/index/code-indexers/ast-grep.js

@@ -1,13 +1,17 @@
+import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
 import path from 'node:path';
 
 import { fileURLToPath } from 'node:url';
 import { asDiagnostic } from '../errors.js';
+import { extractionCachePath, loadExtractions, storeExtractions } from '../extraction-cache.js';
 import { sha256 } from '../utils.js';
 import { runProcess } from '../process.js';
 import { parserAbortSignal, prepareCodeParsers } from './parsers.js';
 
 const MAX_SOURCE_BYTES = 4 * 1024 * 1024;
+const COLLECT_AFTER_CHARACTERS = 512 * 1024;
 const OPENING_PARAMETER_DELIMITERS = '([{<';
 const CLOSING_PARAMETER_DELIMITERS = ')]}>';
 const EXCLUDED_DIRECTORIES = new Set([
@@ -61,6 +65,16 @@ const DECLARATION_KINDS = {
   go: ['type_spec', 'const_spec', 'var_spec'], rust: ['struct_item', 'enum_item', 'trait_item', 'type_item', 'const_item', 'static_item'],
   ruby: ['class', 'module', 'assignment'], kotlin: ['class_declaration', 'object_declaration', 'property_declaration'], shell: [],
 };
+const DEPENDENCY_KINDS = {
+  javascript: ['import_statement', 'export_statement', 'call_expression'],
+  python: ['import_statement', 'import_from_statement'], cpp: ['preproc_include'],
+  java: ['import_declaration'], csharp: ['using_directive'], go: ['import_spec'],
+  rust: ['use_declaration', 'mod_item'], php: ['namespace_use_declaration', 'include_expression', 'require_expression'],
+  ruby: ['call'], kotlin: ['import_header'], shell: ['command'],
+};
+// A JavaScript call is a dependency only when its text starts with require or
+// import, so the traversal skips calls whose callee cannot start that way.
+const DEPENDENCY_CALLS = { call_expression: { has: { field: 'function', regex: '^(?:require|import)' } } };
 
 function nodeRange(node, lineOffset = 0, columnOffset = 0) {
   const range = node.range();
@@ -91,20 +105,18 @@ function declarationNode(node) {
   return node.parent()?.kind() === 'decorated_definition' ? node.parent() : node;
 }
 
-function declarationsInTree(root, language, source, lineOffset, columnOffset, pythonExports = null) {
+function declarationsInTree(nodes, language, source, lineOffset, columnOffset, pythonExports = null) {
   const exportedNames = language === 'javascript' ? javascriptExportedNames(source) : pythonExports?.names;
   const result = [];
   for (const kind of DECLARATION_KINDS[language] || []) {
-    let nodes;
-    try { nodes = root.findAll({ rule: { kind } }); } catch { continue; }
-    for (const node of nodes) {
+    for (const node of nodes.get(kind)) {
       let declaredNodes = [node];
       if (language === 'java' && ['field_declaration', 'constant_declaration'].includes(kind)) declaredNodes = node.children().filter(child => child.kind() === 'variable_declarator');
       if (language === 'csharp' && kind === 'field_declaration') declaredNodes = node.children().find(child => child.kind() === 'variable_declaration')?.children().filter(child => child.kind() === 'variable_declarator') || [];
       if (language === 'php' && ['const_declaration', 'property_declaration'].includes(kind)) declaredNodes = node.children().filter(child => ['const_element', 'property_element'].includes(child.kind()));
       if (language === 'go' && ['const_spec', 'var_spec'].includes(kind)) declaredNodes = node.children().filter(child => child.kind() === 'identifier');
       if (language === 'ruby' && kind === 'assignment' && safeField(node, 'left')?.kind() !== 'constant') continue;
-      if (language === 'python' && kind === 'assignment' && (safeField(node, 'left')?.text() === '__all__' || node.ancestors().some(parent => parent.kind() === 'function_definition'))) continue;
+      if (language === 'python' && kind === 'assignment' && (safeField(node, 'left')?.text() === '__all__' || lineage(node).kinds.includes('function_definition'))) continue;
       if (['variable_declarator', 'field_definition', 'public_field_definition'].includes(kind) && ['arrow_function', 'function_expression'].includes(safeField(node, 'value')?.kind())) continue;
       const declaration = kind === 'variable_declarator' ? node.parent() : declarationNode(node);
       const range = nodeRange(declaration, lineOffset, columnOffset);
@@ -123,20 +135,14 @@ function declarationsInTree(root, language, source, lineOffset, columnOffset, py
 
 // These are syntax observations. Resolution belongs to the native index, and
 // unsupported/dynamic targets remain explicit rather than guessed.
-function dependencyReferences(root, language, source, lineOffset, columnOffset) {
-  const kinds = {
-    javascript: ['import_statement', 'export_statement', 'call_expression'],
-    python: ['import_statement', 'import_from_statement'], cpp: ['preproc_include'],
-    java: ['import_declaration'], csharp: ['using_directive'], go: ['import_spec'],
-    rust: ['use_declaration', 'mod_item'], php: ['namespace_use_declaration', 'include_expression', 'require_expression'],
-    ruby: ['call'], kotlin: ['import_header'], shell: ['command'],
-  }[language] || [];
+function dependencyReferences(nodes, language, source, lineOffset, columnOffset) {
   const references = [];
-  for (const kind of kinds) {
-    let nodes;
-    try { nodes = root.findAll({ rule: { kind } }); } catch { continue; }
-    for (const node of nodes) {
-      const text = node.text();
+  for (const kind of DEPENDENCY_KINDS[language] || []) {
+    for (const node of nodes.get(kind)) {
+      // napi indexes are UTF-16 offsets into this source; a slice avoids
+      // copying the text of every call that is not an import.
+      const { start, end } = node.range();
+      const text = source.slice(start.index, end.index);
       let target;
       let relationKind = 'import';
       let typeOnly = false;
@@ -156,7 +162,7 @@ function dependencyReferences(root, language, source, lineOffset, columnOffset)
         }
         typeOnly = node.children().some(child => child.kind() === 'type') ||
           (specifiers.length > 0 && specifiers.every(specifier => specifier.children().some(child => child.kind() === 'type')) && !clause.children().some(child => ['identifier', 'namespace_import'].includes(child.kind()))) ||
-          (kind === 'call_expression' && /^import\s*\(/u.test(text) && node.ancestors().some(parent => ['type_alias_declaration', 'type_annotation', 'type_query'].includes(parent.kind())));
+          (kind === 'call_expression' && /^import\s*\(/u.test(text) && lineage(node).kinds.some(parent => ['type_alias_declaration', 'type_annotation', 'type_query'].includes(parent)));
         if (typeOnly && kind !== 'export_statement') relationKind = 'type-import';
       } else if (language === 'python') {
         const from = text.match(/^from\s+([.\w]+)\s+import/u);
@@ -262,9 +268,23 @@ function splitParameters(value) {
   return result.filter(Boolean);
 }
 
+// napi builds new objects on every call, and several checks read one node's
+// ancestry, so each node's ancestors and their kinds are read once per script
+// unit. The unit clears them so its syntax tree can be released.
+const lineages = new Map();
+function lineage(node) {
+  let value = lineages.get(node);
+  if (!value) {
+    const nodes = node.ancestors();
+    value = { nodes, kinds: nodes.map(entry => entry.kind()) };
+    lineages.set(node, value);
+  }
+  return value;
+}
+
 function ancestor(node, kinds) {
-  const wanted = new Set(kinds);
-  return node.ancestors().find((candidate) => wanted.has(candidate.kind())) || null;
+  const { nodes, kinds: names } = lineage(node);
+  return nodes[names.findIndex(kind => kinds.includes(kind))] || null;
 }
 
 const CONTAINER_KINDS = new Set([
@@ -277,10 +297,10 @@ function containerName(node, language) {
     const receiver = safeField(node, 'receiver')?.text().trim();
     if (receiver) return receiver.replace(/^\(|\)$/gu, '').replace(/^\w+\s+\*?/u, '').trim();
   }
-  const container = node.ancestors().find((candidate) => CONTAINER_KINDS.has(candidate.kind()) && !(language === 'python' && candidate.kind() === 'module'));
+  const { nodes, kinds } = lineage(node);
+  const container = nodes[kinds.findIndex(kind => CONTAINER_KINDS.has(kind) && !(language === 'python' && kind === 'module'))];
   if (!container) {
-    const parentFunction = node.ancestors().find((candidate) => DEFINITIONS.javascript.kinds.includes(candidate.kind())
-      || candidate.kind() === 'function_definition');
+    const parentFunction = nodes[kinds.findIndex(kind => DEFINITIONS.javascript.kinds.includes(kind) || kind === 'function_definition')];
     return parentFunction ? declaredName(parentFunction) : null;
   }
   if (container.kind() === 'impl_item') {
@@ -310,7 +330,8 @@ function directText(node) {
 }
 
 function cPlusPlusVisibility(node) {
-  if (node.ancestors().some(parent => parent.kind() === 'namespace_definition' && !safeField(parent, 'name'))) return 'internal';
+  const { nodes, kinds } = lineage(node);
+  if (nodes.some((parent, index) => kinds[index] === 'namespace_definition' && !safeField(parent, 'name'))) return 'internal';
   const classBody = ancestor(node, ['field_declaration_list']);
   if (!classBody) return /\bstatic\b/u.test(directText(node)) ? 'internal' : 'public';
   const classNode = ancestor(node, ['class_specifier', 'struct_specifier', 'union_specifier']);
@@ -354,17 +375,19 @@ function javascriptExportedNames(source) {
 
 function pythonExportedNames(root) {
   let names = null; let partial = false;
-  const nodes = root.findAll({ rule: { any: [{ kind: 'assignment' }, { kind: 'augmented_assignment' }, { kind: 'call' }] } });
-  for (const node of nodes.sort((a, b) => a.range().start.index - b.range().start.index)) {
-    const parents = node.ancestors();
-    if (parents.some(parent => ['function_definition', 'class_definition', 'lambda'].includes(parent.kind()))) continue;
+  // A statement whose text never mentions __all__ cannot define it.
+  const nodes = root.findAll({ rule: { any: [{ kind: 'assignment' }, { kind: 'augmented_assignment' }, { kind: 'call' }], regex: '__all__' } })
+    .map(node => ({ node, start: node.range().start.index }));
+  for (const { node } of nodes.sort((a, b) => a.start - b.start)) {
+    const parents = lineage(node).kinds;
+    if (parents.some(kind => ['function_definition', 'class_definition', 'lambda'].includes(kind))) continue;
     const call = node.kind() === 'call';
     if (call ? !node.findAll({ rule: { kind: 'identifier' } }).some(identifier => identifier.text() === '__all__') : safeField(node, 'left')?.text() !== '__all__') continue;
     const right = safeField(node, 'right');
     const literals = right && ['list', 'tuple'].includes(right.kind()) ? right.children().filter(child => !['[', ']', '(', ')', ',', 'comment'].includes(child.kind())) : null;
     const values = literals?.map(child => child.kind() === 'string' ? child.text().match(/^(?:r|u)?(['"])([^'"\\\r\n]*)\1$/iu)?.[2] : undefined);
     const addition = node.kind() === 'augmented_assignment';
-    if (call || parents.some(parent => !['module', 'expression_statement'].includes(parent.kind())) || !values || values.some(value => value === undefined) || (addition && (!names || safeField(node, 'operator')?.text() !== '+='))) {
+    if (call || parents.some(kind => !['module', 'expression_statement'].includes(kind)) || !values || values.some(value => value === undefined) || (addition && (!names || safeField(node, 'operator')?.text() !== '+='))) {
       names = null; partial = true;
     } else {
       names = new Set([...(addition ? names : []), ...values]); partial = false;
@@ -378,7 +401,7 @@ function javascriptVisibility(node, name, exportedNames) {
   if (['field_definition', 'public_field_definition'].includes(node.parent()?.kind()) && node.parent().children().some(child => child.kind() === 'accessibility_modifier' && ['private', 'protected'].includes(child.text()))) return 'internal';
   // An exported class exposes its members, not locals inside those members.
   // An export-name match also cannot expose a shadowing nested declaration.
-  if (node.ancestors().some(parent => DEFINITIONS.javascript.kinds.includes(parent.kind()))) return 'internal';
+  if (lineage(node).kinds.some(kind => DEFINITIONS.javascript.kinds.includes(kind))) return 'internal';
   const classNode = ancestor(node, ['class_declaration', 'class_expression', 'class']);
   if (classNode) {
     const className = declaredName(classNode);
@@ -394,15 +417,16 @@ function javascriptVisibility(node, name, exportedNames) {
 }
 
 function visibility(node, name, language, exportedNames) {
-  const head = directText(node);
-  if (node.ancestors().some(parent => CALLABLE_KINDS.has(parent.kind()) || ['lambda_expression', 'closure_expression', 'lambda_literal', 'func_literal', 'lambda', 'anonymous_method_expression'].includes(parent.kind()))) return 'internal';
+  const { kinds } = lineage(node);
+  if (kinds.some(kind => CALLABLE_KINDS.has(kind) || ['lambda_expression', 'closure_expression', 'lambda_literal', 'func_literal', 'lambda', 'anonymous_method_expression'].includes(kind))) return 'internal';
   if (language === 'javascript') return javascriptVisibility(node, name, exportedNames);
   if (language === 'python') {
-    const nestedFunction = node.ancestors().some((candidate) => candidate.kind() === 'function_definition');
+    const nestedFunction = kinds.includes('function_definition');
     if (nestedFunction) return 'internal';
-    const classMember = node.ancestors().some(parent => parent.kind() === 'class_definition');
+    const classMember = kinds.includes('class_definition');
     return (exportedNames && !classMember ? exportedNames.has(name) : !name.startsWith('_')) ? 'public' : 'internal';
   }
+  const head = directText(node);
   if (['java', 'csharp'].includes(language)) return /\bpublic\b/u.test(head) || (!/\b(?:private|protected|internal)\b/u.test(head) && ancestor(node, ['interface_declaration'])) ? 'public' : 'internal';
   if (language === 'cpp') return cPlusPlusVisibility(node);
   if (language === 'php') return /\b(?:private|protected)\b/u.test(head) ? 'internal' : 'public';
@@ -417,10 +441,10 @@ function visibility(node, name, language, exportedNames) {
 function callableKind(node, name, language) {
   if (node.kind().includes('constructor') || ['__construct', '__init__', 'constructor'].includes(name)) return 'constructor';
   if (node.kind().includes('method')) return 'method';
-  const owner = node.ancestors().find((candidate) => (
-    !(language === 'python' && candidate.kind() === 'module') && (CONTAINER_KINDS.has(candidate.kind()) || CALLABLE_KINDS.has(candidate.kind()))
+  const owner = lineage(node).kinds.find(kind => (
+    !(language === 'python' && kind === 'module') && (CONTAINER_KINDS.has(kind) || CALLABLE_KINDS.has(kind))
   ));
-  return owner && CONTAINER_KINDS.has(owner.kind()) ? 'method' : 'function';
+  return owner && CONTAINER_KINDS.has(owner) ? 'method' : 'function';
 }
 
 function scriptUnits(source, filePath, definition) {
@@ -444,28 +468,27 @@ function scriptUnits(source, filePath, definition) {
   return units;
 }
 
-function functionsInTree(root, definition, { language, lineOffset, columnOffset, source, pythonExports = null }) {
+function functionsInTree(nodes, definition, { language, lineOffset, columnOffset, source, pythonExports = null }) {
   const exportedNames = language === 'javascript' ? javascriptExportedNames(source) : pythonExports?.names;
-  const nodes = new Map();
-  for (const kind of definition.kinds) {
-    for (const node of root.findAll({ rule: { kind } })) nodes.set(node.id(), node);
-  }
-  return [...nodes.values()].sort((left, right) => left.range().start.index - right.range().start.index)
-    .map((node) => {
+  return definition.kinds.flatMap(kind => nodes.get(kind)).map(node => ({ node, own: node.range() }))
+    .sort((left, right) => left.own.start.index - right.own.start.index)
+    .map(({ node, own }) => {
       const name = declaredName(node);
       if (!name) return null;
       const container = containerName(node, language);
-      const location = node.range().start;
-      const range = nodeRange(declarationNode(node), lineOffset, columnOffset);
+      const location = own.start;
+      const declaration = declarationNode(node);
+      const range = nodeRange(declaration, lineOffset, columnOffset);
       const parameters = splitParameters(parameterText(node));
       const resolvedVisibility = visibility(node, name, language, exportedNames);
       const scope = language === 'rust' ? node.children().find(child => child.kind() === 'visibility_modifier')?.text() || 'private' : null;
+      const text = source.slice(own.start.index, own.end.index);
       return {
         name,
         qualifiedName: [container, name].filter(Boolean).join(language === 'php' ? '::' : '.'),
         kind: callableKind(node, name, language),
         visibility: resolvedVisibility,
-        ...(language === 'javascript' && declarationNode(node).parent()?.kind() === 'export_statement' && declarationNode(node).parent().children().some(child => child.kind() === 'default') ? { exportName: 'default' } : {}),
+        ...(language === 'javascript' && declaration.parent()?.kind() === 'export_statement' && declaration.parent().children().some(child => child.kind() === 'default') ? { exportName: 'default' } : {}),
         ...(scope ? { visibilityScope: scope === 'pub' ? 'public' : scope.replace(/^pub\((.*)\)$/u, '$1') } : {}),
         container,
         line: location.line + lineOffset + 1,
@@ -473,13 +496,279 @@ function functionsInTree(root, definition, { language, lineOffset, columnOffset,
         start: range.start,
         end: range.end,
         parameters,
-        async: /^\s*async\b/u.test(node.text()),
-        generator: /\bfunction\s*\*|\byield\b/u.test(node.text()),
+        async: /^\s*async\b/u.test(text),
+        generator: /\bfunction\s*\*|\byield\b/u.test(text),
         static: /\bstatic\b/u.test(directText(node)),
       };
     }).filter(Boolean);
 }
 
+// Call-web syntax: every callable site (including anonymous ones), its call
+// sites and its import bindings. These are cached per file content; the
+// call-web owner resolves them against the whole snapshot.
+const CALL_SITES = Object.freeze({
+  javascript: {
+    functions: { function_declaration: 'function', generator_function_declaration: 'function', function_expression: 'closure', function: 'closure', generator_function: 'closure', arrow_function: 'arrow', method_definition: 'method' },
+    calls: ['call_expression'], containers: ['class_declaration', 'class', 'abstract_class_declaration'],
+  },
+  python: { functions: { function_definition: 'function', lambda: 'closure' }, calls: ['call'], containers: ['class_definition'] },
+  go: { functions: { function_declaration: 'function', method_declaration: 'method', func_literal: 'closure' }, calls: ['call_expression'], containers: [] },
+  rust: { functions: { function_item: 'function', closure_expression: 'closure' }, calls: ['call_expression'], containers: ['impl_item', 'trait_item'] },
+  java: { functions: { method_declaration: 'method', constructor_declaration: 'constructor', compact_constructor_declaration: 'constructor', lambda_expression: 'closure' }, calls: ['method_invocation'], containers: ['class_declaration', 'interface_declaration', 'enum_declaration', 'record_declaration'] },
+  kotlin: { functions: { function_declaration: 'function', secondary_constructor: 'constructor', anonymous_function: 'closure', lambda_literal: 'closure' }, calls: ['call_expression'], containers: ['class_declaration', 'object_declaration'] },
+  csharp: { functions: { method_declaration: 'method', constructor_declaration: 'constructor', local_function_statement: 'function', lambda_expression: 'closure', anonymous_method_expression: 'closure' }, calls: ['invocation_expression'], containers: ['class_declaration', 'struct_declaration', 'interface_declaration', 'record_declaration'] },
+  php: { functions: { function_definition: 'function', method_declaration: 'method', anonymous_function: 'closure', anonymous_function_creation_expression: 'closure', arrow_function: 'arrow' }, calls: ['function_call_expression', 'member_call_expression', 'nullsafe_member_call_expression', 'scoped_call_expression'], containers: ['class_declaration', 'interface_declaration', 'trait_declaration', 'enum_declaration'] },
+  ruby: { functions: { method: 'function', singleton_method: 'method', lambda: 'closure', block: 'closure', do_block: 'closure' }, calls: ['call'], containers: ['class', 'module'] },
+  cpp: { functions: { function_definition: 'function', lambda_expression: 'closure' }, calls: ['call_expression'], containers: ['class_specifier', 'struct_specifier'] },
+  shell: { functions: { function_definition: 'function' }, calls: ['command'], containers: [] },
+});
+const CALL_IMPORT_KINDS = { javascript: ['import_statement'], python: ['import_statement', 'import_from_statement'], go: ['import_spec'], rust: ['use_declaration'], java: ['import_declaration'], kotlin: ['import_header'], php: ['namespace_use_declaration'] };
+const CONSTRUCTOR_NAMES = new Set(['constructor', '__init__', '__construct', 'initialize']);
+// Leading decorators, attributes and comments are not the canonical start.
+const LEADING_SYNTAX = new Set(['decorator', 'comment', 'line_comment', 'block_comment', 'attribute_list', 'attribute_item', 'attribute', 'annotation', 'marker_annotation']);
+const LITERAL_RECEIVER = /string|array|list|dictionary|tuple|regex|number|integer|float|literal|comprehension/u;
+const PROJECT_LITERAL = new Set(['composite_literal', 'func_literal', 'lambda_literal']);
+const validKinds = new Map();
+
+// ast-grep rejects unknown kinds; grammars differ (JavaScript/TypeScript/Tsx).
+function knownKinds(root, parser, kinds) {
+  const key = `${parser}\0${kinds.join(',')}`;
+  if (!validKinds.has(key)) validKinds.set(key, kinds.filter(kind => { try { root.find({ rule: { kind } }); return true; } catch { return false; } }));
+  return validKinds.get(key);
+}
+
+function findKinds(root, parser, kinds, refinements = {}) {
+  const known = knownKinds(root, parser, kinds);
+  return known.length ? root.findAll({ rule: { any: known.map(kind => ({ kind, ...refinements[kind] })) } }) : [];
+}
+
+function canonicalStart(node) {
+  const first = node.child(0);
+  if (!first || (!LEADING_SYNTAX.has(first.kind()) && first.kind() !== 'modifiers')) return node.range().start;
+  for (const child of node.children()) {
+    if (LEADING_SYNTAX.has(child.kind())) continue;
+    if (child.kind() === 'modifiers') {
+      const inner = child.children().find(entry => !LEADING_SYNTAX.has(entry.kind()));
+      if (inner) return inner.range().start;
+      continue;
+    }
+    return child.range().start;
+  }
+  return node.range().start;
+}
+
+function objectOwnerName(node) {
+  // `const api = { list() {} }` and `{ list: () => {} }` belong to `api`.
+  const object = node.parent()?.kind() === 'object' ? node.parent() : node.parent()?.kind() === 'pair' && node.parent().parent()?.kind() === 'object' ? node.parent().parent() : null;
+  const owner = object?.parent();
+  if (!owner) return null;
+  if (owner.kind() === 'variable_declarator') return safeField(owner, 'name')?.text() || null;
+  if (owner.kind() === 'pair') return safeField(owner, 'key')?.text() || null;
+  if (owner.kind() === 'assignment_expression') return safeField(owner, 'left')?.text().match(/[A-Za-z_$][\w$]*$/u)?.[0] || null;
+  return null;
+}
+
+function callContainerName(node, language) {
+  if (node.kind() === 'impl_item') return safeField(node, 'type')?.text().trim() || null;
+  return safeField(node, 'name')?.text().trim()
+    || node.children().find(child => ['constant', 'identifier', 'name', 'simple_identifier', 'type_identifier'].includes(child.kind()))?.text().trim()
+    || (language === 'javascript' && node.parent()?.kind() === 'variable_declarator' ? safeField(node.parent(), 'name')?.text() : null)
+    || null;
+}
+
+function calleeParts(node, language) {
+  const field = name => safeField(node, name);
+  let callee = null; let nameNode = null; let receiver = null;
+  if (['javascript', 'python', 'go', 'rust', 'csharp', 'cpp'].includes(language)) {
+    callee = field('function');
+    const kind = callee?.kind();
+    if (['identifier', 'field_identifier'].includes(kind)) nameNode = callee;
+    else if (['member_expression', 'attribute', 'selector_expression', 'field_expression', 'member_access_expression'].includes(kind)) {
+      nameNode = safeField(callee, { javascript: 'property', python: 'attribute', go: 'field', rust: 'field', csharp: 'name', cpp: 'field' }[language]);
+      receiver = safeField(callee, { javascript: 'object', python: 'object', go: 'operand', rust: 'value', csharp: 'expression', cpp: 'argument' }[language]);
+    } else if (['scoped_identifier', 'qualified_identifier'].includes(kind)) {
+      nameNode = safeField(callee, 'name'); receiver = safeField(callee, kind === 'scoped_identifier' ? 'path' : 'scope');
+    } else if (kind === 'generic_name' || kind === 'template_function') nameNode = safeField(callee, 'name') || callee.child(0);
+  } else if (language === 'java') {
+    nameNode = field('name'); receiver = field('object');
+  } else if (language === 'kotlin') {
+    callee = node.child(0);
+    if (callee?.kind() === 'simple_identifier') nameNode = callee;
+    else if (callee?.kind() === 'navigation_expression') {
+      const suffix = callee.children().at(-1);
+      nameNode = suffix?.kind() === 'navigation_suffix' ? suffix.children().find(child => child.kind() === 'simple_identifier') : null;
+      receiver = callee.child(0);
+    }
+  } else if (language === 'php') {
+    if (node.kind() === 'function_call_expression') {
+      callee = field('function');
+      nameNode = callee?.kind() === 'qualified_name' ? callee.children().at(-1) : callee?.kind() === 'name' ? callee : null;
+    } else {
+      nameNode = field('name'); receiver = field(node.kind() === 'scoped_call_expression' ? 'scope' : 'object');
+    }
+  } else if (language === 'ruby') {
+    nameNode = field('method'); receiver = field('receiver');
+  } else if (language === 'shell') {
+    nameNode = field('name');
+  }
+  return { callee, nameNode, receiver };
+}
+
+function bindingsInTree(imports, requires, language, point) {
+  const bindings = [];
+  for (const node of imports) {
+    const at = point(node.range().start);
+    const add = (local, imported = local, extra = {}) => { if (local) bindings.push({ at, local, imported, ...extra }); };
+    if (language === 'javascript') {
+      if (node.children().some(child => child.kind() === 'type')) continue;
+      const clause = node.children().find(child => child.kind() === 'import_clause');
+      for (const child of clause?.children() || []) {
+        if (child.kind() === 'identifier') add(child.text(), 'default');
+        else if (child.kind() === 'namespace_import') add(child.children().find(entry => entry.kind() === 'identifier')?.text(), '*', { namespace: true });
+        else if (child.kind() === 'named_imports') {
+          for (const specifier of child.children().filter(entry => entry.kind() === 'import_specifier')) {
+            if (specifier.children().some(entry => entry.kind() === 'type')) continue;
+            const name = safeField(specifier, 'name')?.text();
+            add(safeField(specifier, 'alias')?.text() || name, name);
+          }
+        }
+      }
+    } else if (language === 'python') {
+      if (node.kind() === 'import_statement') {
+        for (const child of node.children()) {
+          if (child.kind() === 'dotted_name') add(child.text(), '*', { namespace: true });
+          else if (child.kind() === 'aliased_import') add(safeField(child, 'alias')?.text(), '*', { namespace: true });
+        }
+      } else {
+        const module = safeField(node, 'module_name');
+        for (const child of node.children()) {
+          if (child.id() === module?.id()) continue;
+          if (child.kind() === 'wildcard_import') bindings.push({ at, local: '*', imported: '*', wildcard: true });
+          else if (child.kind() === 'dotted_name') add(child.text());
+          else if (child.kind() === 'aliased_import') add(safeField(child, 'alias')?.text(), safeField(child, 'name')?.text());
+        }
+      }
+    } else if (language === 'go') {
+      const target = node.text().match(/["`]([^"`]+)["`]/u)?.[1];
+      const alias = safeField(node, 'name')?.text();
+      if (target && alias !== '_' && alias !== '.') add(alias || target.split('/').at(-1), '*', { namespace: true });
+    } else {
+      // Java/Kotlin/Rust/PHP name the imported type or function last.
+      const text = node.text().replace(/\s+/gu, ' ');
+      const alias = text.match(/\bas\s+([A-Za-z_][\w]*)/u)?.[1];
+      for (const group of text.match(/\{([^}]*)\}/u)?.[1].split(',') || [text.replace(/\bas\s+[A-Za-z_]\w*/u, '')]) {
+        const name = group.trim().replace(/[;{}]/gu, '').split(/::|\\|\./u).at(-1)?.trim().split(/\s+/u).at(-1);
+        if (name && name !== '*' && /^[A-Za-z_]\w*$/u.test(name)) add(alias && !group.includes('{') ? alias : name, name);
+      }
+    }
+  }
+  // JavaScript `const name = require(...)` and `const { a, b: c } = require(...)`.
+  for (const node of requires) {
+    if (node.parent()?.kind() !== 'variable_declarator') continue;
+    const at = point(node.range().start);
+    const name = safeField(node.parent(), 'name');
+    if (name?.kind() === 'identifier') bindings.push({ at, local: name.text(), imported: '*', namespace: true });
+    else if (name?.kind() === 'object_pattern') {
+      for (const entry of name.children()) {
+        if (entry.kind() === 'shorthand_property_identifier_pattern') bindings.push({ at, local: entry.text(), imported: entry.text() });
+        else if (entry.kind() === 'pair_pattern') bindings.push({ at, local: safeField(entry, 'value')?.text(), imported: safeField(entry, 'key')?.text() });
+      }
+    }
+  }
+  return bindings.filter(entry => entry.local && entry.imported);
+}
+
+function callSitesInTree(root, { language, parser, lineOffset = 0, columnOffset = 0, source }) {
+  const definition = CALL_SITES[language];
+  const point = value => ({ line: value.line + lineOffset + 1, column: value.column + 1 + (value.line === 0 ? columnOffset : 0) });
+  // One traversal finds every node of interest; the four roles use disjoint kinds.
+  const roles = new Map([
+    ...Object.keys(definition.functions).map(kind => [kind, 'functions']), ...definition.calls.map(kind => [kind, 'calls']),
+    ...definition.containers.map(kind => [kind, 'containers']), ...(CALL_IMPORT_KINDS[language] || []).map(kind => [kind, 'imports']),
+  ]);
+  const found = { functions: [], calls: [], containers: [], imports: [] };
+  for (const node of findKinds(root, parser, [...roles.keys()])) {
+    const kind = node.kind();
+    found[roles.get(kind)].push({ node, kind });
+  }
+  const functions = found.functions.map(({ node, kind }) => {
+    const range = node.range();
+    return { node, kind, startIndex: range.start.index, endIndex: range.end.index, start: point(canonicalStart(node)), end: point(range.end) };
+  }).sort((left, right) => left.startIndex - right.startIndex || right.endIndex - left.endIndex);
+  const containers = found.containers.map(({ node }) => {
+    const range = node.range();
+    return { name: callContainerName(node, language), startIndex: range.start.index, endIndex: range.end.index };
+  }).sort((left, right) => left.startIndex - right.startIndex);
+  // Syntax nests, so one sweep in start order finds each innermost owner.
+  const innermost = (items, owners) => {
+    const result = new Map(); const open = []; let next = 0;
+    for (const item of [...items].sort((left, right) => left.startIndex - right.startIndex)) {
+      while (next < owners.length && owners[next].startIndex <= item.startIndex) {
+        while (open.length && open.at(-1).endIndex <= owners[next].startIndex) open.pop();
+        open.push(owners[next++]);
+      }
+      while (open.length && open.at(-1).endIndex <= item.startIndex) open.pop();
+      let owner = open.at(-1);
+      if (owner === item) owner = open.at(-2);
+      result.set(item, owner || null);
+    }
+    return result;
+  };
+  const parents = innermost(functions, functions);
+  const owners = innermost(functions, containers);
+  const records = functions.map((entry, index) => {
+    entry.index = index;
+    const base = definition.functions[entry.kind];
+    const parent = parents.get(entry);
+    const owner = owners.get(entry);
+    // A class member is directly inside its class, not inside a local function.
+    const member = owner && (!parent || owner.startIndex > parent.startIndex) ? owner : null;
+    const objectOwner = language === 'javascript' ? objectOwnerName(entry.node) : null;
+    // Only JavaScript names an anonymous callable after the binding that holds it.
+    let name = '';
+    if (language === 'javascript' || (base !== 'arrow' && base !== 'closure')) { try { name = declaredName(entry.node); } catch { name = ''; } }
+    const container = objectOwner || member?.name || owner?.name || (entry.kind === 'method_declaration' && language === 'go' ? containerName(entry.node, language) : null);
+    let kind = base;
+    if (base === 'function' || base === 'method') kind = (member || objectOwner) && CONSTRUCTOR_NAMES.has(name) ? 'constructor' : base === 'method' || member ? 'method' : 'function';
+    const record = { name, kind, start: entry.start, end: entry.end, parent: parent ? parent.index : -1 };
+    if (container) record.container = container;
+    if (language === 'javascript' && entry.node.parent()?.kind() === 'export_statement' && entry.node.parent().children().some(child => child.kind() === 'default')) record.default = true;
+    return record;
+  });
+  const requires = [];
+  const calls = found.calls.map(({ node }) => {
+    const range = node.range();
+    const { callee, nameNode, receiver } = calleeParts(node, language);
+    const nameRange = (nameNode || callee || node).range();
+    const receiverRange = receiver?.range();
+    const calleeStart = (receiverRange || (callee || nameNode || node).range()).start.index;
+    const name = nameNode ? nameNode.text() : null;
+    const record = { name, callee: source.slice(calleeStart, Math.max(calleeStart, nameRange.end.index)).replace(/\s+/gu, ' ').slice(0, 120), at: point((nameNode ? nameRange : range).start), start: point(range.start), end: point(range.end), startIndex: range.start.index };
+    if (receiver) {
+      record.receiver = source.slice(receiverRange.start.index, receiverRange.end.index).replace(/\s+/gu, ' ').slice(0, 120);
+      const kind = receiver.kind();
+      if (LITERAL_RECEIVER.test(kind) && !PROJECT_LITERAL.has(kind)) record.literal = true;
+    } else if (language === 'javascript' && name === 'require' && nameNode === callee) requires.push(node);
+    return record;
+  });
+  const callers = innermost(calls, functions);
+  for (const call of calls) { call.from = callers.get(call)?.index ?? -1; delete call.startIndex; }
+  return { functions: records, calls, bindings: bindingsInTree(found.imports.map(({ node }) => node), requires, language, point) };
+}
+
+// Identical content parsed by a different grammar, or admitted only by its
+// shebang, is a different extraction.
+function extractionVariant(filePath, indexer) {
+  if (indexer === 'javascript') return filePath.endsWith('.vue') ? 'vue' : javascriptParser(filePath);
+  if (indexer === 'cpp') return cFamilyParser(filePath);
+  return hasSupportedExtension(filePath, DEFINITIONS[indexer]) ? indexer : `${indexer}+shebang`;
+}
+
+function moduleEnd(source) {
+  const lines = source.split('\n');
+  return { line: lines.length, column: lines.at(-1).length + 1 };
+}
+
 function hasSupportedExtension(filePath, definition) {
   const normalized = filePath.toLowerCase();
   return definition.extensions.some((extension) => normalized.endsWith(extension));
@@ -499,8 +788,8 @@ function fileRole(filePath) {
     : 'source';
 }
 
-function syntaxDiagnostics(root, filePath, lineOffset) {
-  return root.findAll({ rule: { kind: 'ERROR' } }).slice(0, 20).map((node) => ({
+function syntaxDiagnostics(nodes, filePath, lineOffset) {
+  return nodes.get('ERROR').slice(0, 20).map((node) => ({
     code: 'CODE_INDEX_PARSE_RECOVERED',
     message: 'The parser recovered from invalid or unsupported syntax.',
     path: filePath,
@@ -512,10 +801,15 @@ function createIndexer(id) {
   const definition = DEFINITIONS[id];
   return {
     id,
-    async extract({ files, projectRoot, parseAsync, parserErrors = {} }) {
+    async extract({ files, projectRoot, parse, parserErrors = {}, callSites = new Set() }) {
       const indexedFiles = [];
       const diagnostics = [];
+      let parsed = 0;
       for (const file of files.filter((candidate) => isCandidate(candidate, definition))) {
+        // A syntax tree lives in native memory, which V8 cannot see, until every
+        // node object that refers to it is collected. The worker exposes gc so
+        // that memory stays bounded by recently parsed source.
+        if (globalThis.gc && parsed > COLLECT_AFTER_CHARACTERS) { globalThis.gc(); parsed = 0; }
         let source;
         try {
           source = await readFile(path.join(projectRoot, file.path), 'utf8');
@@ -543,26 +837,38 @@ function createIndexer(id) {
         const functions = [];
         const symbols = [];
         const dependencies = [];
+        const sites = callSites.has(file.path) ? { functions: [], calls: [], bindings: [], moduleEnd: moduleEnd(source) } : null;
         for (const unit of scriptUnits(source, file.path, definition)) {
           try {
             if (parserErrors[unit.parser]) {
               diagnostics.push({ ...parserErrors[unit.parser], path: file.path });
               continue;
             }
-            const parsed = await parseAsync(unit.parser, unit.source);
+            const parsed = await parse(unit.parser, unit.source);
             const root = parsed.root();
             const pythonExports = id === 'python' ? pythonExportedNames(root) : null;
             if (pythonExports?.partial) diagnostics.push({ code: 'CODE_INDEX_PYTHON_EXPORTS_PARTIAL', path: file.path, message: 'Python __all__ is dynamic or conditional. Public naming is shown; runtime exports remain unresolved.' });
-            functions.push(...functionsInTree(root, definition, {
+            // One traversal finds every node the readers below use, by kind in document order.
+            const nodes = new Map([...definition.kinds, ...DECLARATION_KINDS[id], ...DEPENDENCY_KINDS[id], 'ERROR'].map(kind => [kind, []]));
+            for (const node of findKinds(root, unit.parser, [...nodes.keys()], id === 'javascript' ? DEPENDENCY_CALLS : {})) nodes.get(node.kind()).push(node);
+            functions.push(...functionsInTree(nodes, definition, {
               language: id,
               lineOffset: unit.lineOffset,
               columnOffset: unit.columnOffset,
               source: unit.source,
               pythonExports,
             }));
-            symbols.push(...declarationsInTree(root, id, unit.source, unit.lineOffset, unit.columnOffset, pythonExports));
-            dependencies.push(...dependencyReferences(root, id, unit.source, unit.lineOffset, unit.columnOffset));
-            diagnostics.push(...syntaxDiagnostics(root, file.path, unit.lineOffset));
+            symbols.push(...declarationsInTree(nodes, id, unit.source, unit.lineOffset, unit.columnOffset, pythonExports));
+            dependencies.push(...dependencyReferences(nodes, id, unit.source, unit.lineOffset, unit.columnOffset));
+            diagnostics.push(...syntaxDiagnostics(nodes, file.path, unit.lineOffset));
+            if (sites) {
+              // Several Vue script blocks share one file-level function list.
+              const unitSites = callSitesInTree(root, { language: id, parser: unit.parser, lineOffset: unit.lineOffset, columnOffset: unit.columnOffset, source: unit.source });
+              const offset = sites.functions.length;
+              sites.functions.push(...unitSites.functions.map(entry => ({ ...entry, parent: entry.parent < 0 ? -1 : entry.parent + offset })));
+              sites.calls.push(...unitSites.calls.map(entry => ({ ...entry, from: entry.from < 0 ? -1 : entry.from + offset })));
+              sites.bindings.push(...unitSites.bindings);
+            }
           } catch (error) {
             if (error.code === 'PROCESS_ABORTED') throw error;
             diagnostics.push({
@@ -570,6 +876,8 @@ function createIndexer(id) {
               message: error.message,
               path: file.path,
             });
+          } finally {
+            lineages.clear();
           }
         }
         // Vue SFCs expose a component as their default public interface even
@@ -578,6 +886,7 @@ function createIndexer(id) {
           const lines = source.split('\n');
           symbols.push({ name: 'Component', qualifiedName: 'default component', exportName: 'default', kind: 'component', visibility: 'public', container: null, line: 1, column: 1, start: { line: 1, column: 1 }, end: { line: lines.length, column: lines.at(-1).length + 1 } });
         }
+        parsed += source.length;
         indexedFiles.push({
           path: file.path,
           language: id,
@@ -589,6 +898,7 @@ function createIndexer(id) {
           functions,
           symbols,
           dependencies,
+          ...(sites ? { callSites: sites } : {}),
         });
       }
       return { files: indexedFiles, diagnostics };
@@ -596,35 +906,101 @@ function createIndexer(id) {
   };
 }
 
+/** The files each selected indexer parses, with the grammar variant that keys their cached extractions. */
+export function extractionCandidates(indexers, files) {
+  return indexers.filter(id => Object.hasOwn(DEFINITIONS, id)).flatMap(id => files.filter(file => isCandidate(file, DEFINITIONS[id]))
+    .map(file => ({ path: file.path, language: id, variant: extractionVariant(file.path, id), hash: file.hash, mode: file.mode })));
+}
+
+// A cached extraction is reused only by the same extractor code, grammars and
+// runtime, so changing any of them extracts every file again.
+let identity = null;
+export function extractorIdentity() {
+  identity ??= Promise.all(['ast-grep.js', 'parsers.js', 'worker.js'].map(name => readFile(new URL(`./${name}`, import.meta.url))))
+    .then(sources => {
+      const hash = createHash('sha256').update(`${createRequire(import.meta.url)('@ast-grep/napi/package.json').version}\n${process.version}\n`);
+      for (const source of sources) hash.update(source);
+      return hash.digest('hex').slice(0, 16);
+    });
+  return identity;
+}
+
 export const astGrepCodeIndexers = new Map(
   Object.keys(DEFINITIONS).map((id) => [id, createIndexer(id)]),
 );
 
+// Only outcomes that follow from the content alone are cached. A failed read,
+// an unavailable parser or a failed parse is tried again by the next run.
+const CONTENT_DIAGNOSTICS = new Set(['CODE_INDEX_PARSE_RECOVERED', 'CODE_INDEX_PYTHON_EXPORTS_PARTIAL']);
+
 // ast-grep permits one registration per process. A finite indexing child loads
 // this request's languages once and releases every native parser when it exits.
-export async function extractCodeIndexes({ indexers, files, projectRoot, signal }) {
+// With a cache root, it parses only files whose extraction is not cached; the
+// result is the same as extracting every file.
+export async function extractCodeIndexes({ indexers, files, projectRoot, signal, callSites = [], cacheRoot = null }) {
   const selected = indexers.filter(id => astGrepCodeIndexers.has(id));
   const diagnostics = indexers.filter(id => !astGrepCodeIndexers.has(id)).map(id => ({
     code: 'CODE_INDEXER_UNAVAILABLE', message: `No installed code indexer exists for ${id}.`,
   }));
-  const languages = selected.flatMap(id => files.filter(file => isCandidate(file, DEFINITIONS[id]))
-    .map(file => typeof DEFINITIONS[id].parser === 'function'
-      ? DEFINITIONS[id].parser(file.path) : DEFINITIONS[id].parser));
-  if (languages.length === 0) return { contributions: [], diagnostics };
-  const { registrations, errors } = await prepareCodeParsers(languages);
-  let contributions;
-  try {
-    const result = await runProcess(process.execPath, [fileURLToPath(new URL('./worker.js', import.meta.url))], {
-      input: JSON.stringify({ indexers: selected, files, projectRoot, registrations, errors }),
-      signal: signal || parserAbortSignal(), timeoutMs: 180_000, code: 'CODE_INDEXER_FAILED',
-    });
-    contributions = JSON.parse(result.stdout.toString('utf8'));
-  } catch (error) {
-    if (error.code === 'PROCESS_ABORTED') throw error;
-    return { contributions: [], diagnostics: [...diagnostics, {
-      ...asDiagnostic(error), code: 'CODE_INDEXER_FAILED',
-    }] };
+  const version = cacheRoot ? await extractorIdentity() : null;
+  const candidates = new Map(selected.map(id => [id, extractionCandidates([id], files)
+    .map(entry => ({ ...entry, location: cacheRoot ? extractionCachePath(cacheRoot, { version, ...entry }) : null }))]));
+  const cacheLocations = [...candidates.values()].flat().map(entry => entry.location).filter(Boolean);
+  if ([...candidates.values()].every(entries => entries.length === 0)) return { contributions: [], diagnostics, cacheLocations };
+  const cached = new Map();
+  for (const [id, entries] of candidates) cached.set(id, cacheRoot ? await loadExtractions(cacheRoot, entries) : { values: new Map(), misses: entries });
+  const wanted = new Set([...[...cached.values()].flatMap(value => value.misses.map(entry => entry.path)), ...callSites]);
+  let extracted = [];
+  if (wanted.size) {
+    const sent = files.filter(file => wanted.has(file.path));
+    const languages = selected.flatMap(id => sent.filter(file => isCandidate(file, DEFINITIONS[id]))
+      .map(file => typeof DEFINITIONS[id].parser === 'function'
+        ? DEFINITIONS[id].parser(file.path) : DEFINITIONS[id].parser));
+    const { registrations, errors } = await prepareCodeParsers(languages);
+    try {
+      const result = await runProcess(process.execPath, ['--expose-gc', fileURLToPath(new URL('./worker.js', import.meta.url))], {
+        input: JSON.stringify({ indexers: selected, files: sent, projectRoot, registrations, errors, callSites }),
+        signal: signal || parserAbortSignal(), timeoutMs: 180_000, code: 'CODE_INDEXER_FAILED',
+      });
+      extracted = JSON.parse(result.stdout.toString('utf8'));
+    } catch (error) {
+      if (error.code === 'PROCESS_ABORTED') throw error;
+      return { contributions: [], diagnostics: [...diagnostics, {
+        ...asDiagnostic(error), code: 'CODE_INDEXER_FAILED',
+      }], cacheLocations };
+    }
   }
+  // Reassemble each indexer's files and per-file diagnostics in candidate order.
+  const stored = [];
+  const contributions = selected.map((id, index) => {
+    const { values, misses } = cached.get(id);
+    const missed = new Set(misses.map(entry => entry.path));
+    const records = new Map((extracted[index]?.files || []).map(file => [file.path, file]));
+    const found = new Map();
+    for (const diagnostic of extracted[index]?.diagnostics || []) {
+      if (!found.has(diagnostic.path)) found.set(diagnostic.path, []);
+      found.get(diagnostic.path).push(diagnostic);
+    }
+    const contribution = { files: [], diagnostics: [], extractor: id };
+    for (const entry of candidates.get(id)) {
+      let record = records.get(entry.path);
+      let fileDiagnostics = found.get(entry.path) || [];
+      if (!wanted.has(entry.path)) {
+        const value = values.get(entry.path);
+        const { bytes, lines, functions, symbols, dependencies } = value.record || {};
+        record = value.record && { path: entry.path, language: id, role: fileRole(entry.path), mode: entry.mode, bytes, lines, hash: entry.hash, functions, symbols, dependencies };
+        fileDiagnostics = value.diagnostics.map(diagnostic => ({ ...diagnostic, path: entry.path }));
+      } else if (cacheRoot && missed.has(entry.path) && fileDiagnostics.every(diagnostic => CONTENT_DIAGNOSTICS.has(diagnostic.code))) {
+        const value = record ? { bytes: record.bytes, lines: record.lines, functions: record.functions, symbols: record.symbols, dependencies: record.dependencies } : null;
+        // Diagnostics keep their member order; the path is the reader's own.
+        stored.push({ location: entry.location, value: { record: value, diagnostics: fileDiagnostics.map(diagnostic => ({ ...diagnostic, path: '' })) } });
+      }
+      if (record) contribution.files.push(record);
+      contribution.diagnostics.push(...fileDiagnostics);
+    }
+    return contribution;
+  });
+  await storeExtractions(stored);
   return { contributions, diagnostics: [...diagnostics, ...contributions.flatMap(value =>
-    value.diagnostics.map(diagnostic => ({ ...diagnostic, extractor: value.extractor }))) ] };
+    value.diagnostics.map(diagnostic => ({ ...diagnostic, extractor: value.extractor }))) ], cacheLocations };
 }