gitnexus 1.6.9 → 1.6.10-aptos.0

package/dist/core/ingestion/languages/cpp/captures.js

@@ -4,7 +4,7 @@ import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { normalizeQualifiedName } from '../../utils/qualified-name.js';
 import { splitCppInclude, splitCppUsingDecl } from './import-decomposer.js';
-import { classifyCppParameterType, computeCppDeclarationArity, computeCppCallArity, } from './arity-metadata.js';
+import { classifyCppParameterType, computeCppDeclarationArity, computeCppCallArity, normalizeCppParamType, } from './arity-metadata.js';
 import { markCppAnonymousNamespaceRange, markFileLocal } from './file-local-linkage.js';
 import { markCppDependentBase, markCppDependentPackBase } from './two-phase-lookup.js';
 import { markCppAdlSiteArgs, markCppAdlSiteNoAdl } from './adl.js';
@@ -12,6 +12,117 @@ import { markCppInlineNamespaceRange } from './inline-namespaces.js';
 import { extractCppTemplateConstraints } from './constraint-extractor.js';
 import { captureCppMemberLookupFacts } from './member-lookup.js';
 import { CPP_BRACED_INIT_TYPE_PREFIX } from './conversion-rank.js';
+import { logger } from '../../../logger.js';
+import { synthesizeCallableFlowCaptures, } from '../../utils/callable-flow-captures.js';
+const CPP_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set(['function_definition', 'lambda_expression']),
+    callNodeTypes: new Set(['call_expression']),
+    parameterListNodeTypes: new Set(['parameter_list', 'argument_list']),
+    parameterNodeTypes: new Set(['parameter_declaration', 'optional_parameter_declaration']),
+    bindingNodeTypes: new Set(['init_declarator']),
+    assignmentNodeTypes: new Set(['assignment_expression']),
+    identifierNodeTypes: new Set([
+        'identifier',
+        'field_identifier',
+        'type_identifier',
+        'namespace_identifier',
+    ]),
+    callableSignatureDeclarationNodeTypes: new Set([
+        'declaration',
+        'field_declaration',
+        'parameter_declaration',
+        'optional_parameter_declaration',
+    ]),
+    callableReferenceNodeTypes: new Set(['qualified_identifier']),
+    emitCanonicalInvokeReference: true,
+    memberPointerOperators: new Set(['.*', '->*']),
+    memberPointerParts: (node) => cppRecoveredMemberPointerParts(node),
+    parameterPassingMode: (parameter) => cppOutermostPassingMode(parameter),
+    isTrueReferenceBinding: (_container, destination) => cppContainsNodeType(destination, 'reference_declarator'),
+    expectedSignature: (container, destination) => cppFunctionDeclaratorSignature(destination) ?? cppFunctionDeclaratorSignature(container),
+    normalizeQualifiedName: (raw) => raw.replaceAll('::', '.'),
+};
+/**
+ * Passing mode from the parameter's OUTERMOST declarator chain only. A deep
+ * subtree scan inverted copy vs alias: `void reg(void (*cb)(int& out))` has a
+ * `reference_declarator` inside the nested parameter list, but `cb` itself is
+ * a by-value pointer copy — classifying it 'reference' made the solver
+ * back-propagate formal targets into every caller's argument cell (#2522
+ * review, M5). The chain walk never descends into nested parameter lists.
+ */
+function cppOutermostPassingMode(parameter) {
+    let sawReference = false;
+    let sawPointer = false;
+    let node = parameter.childForFieldName('declarator') ?? null;
+    const visited = new Set();
+    while (node !== null && !visited.has(node.id)) {
+        visited.add(node.id);
+        if (node.type === 'reference_declarator' || node.type === 'abstract_reference_declarator') {
+            // A reference ANYWHERE on the chain aliases the caller's storage —
+            // `void (*&cb)(int)` is a reference to pointer, i.e. an alias.
+            sawReference = true;
+        }
+        else if (node.type === 'pointer_declarator' || node.type === 'abstract_pointer_declarator') {
+            sawPointer = true;
+        }
+        const next = node.childForFieldName('declarator');
+        if (next !== null) {
+            node = next;
+            continue;
+        }
+        if (node.type === 'parenthesized_declarator') {
+            node =
+                node.namedChildren.find((child) => child !== null && child.type.includes('declarator')) ?? null;
+            continue;
+        }
+        break;
+    }
+    return sawReference ? 'reference' : sawPointer ? 'pointer' : 'value';
+}
+function cppRecoveredMemberPointerParts(node) {
+    if (!node.type.includes('parenthesized'))
+        return undefined;
+    const recovered = node.namedChildren.find((child) => child !== null && child.type === 'ERROR');
+    if (recovered === undefined)
+        return undefined;
+    const operator = recovered.children.find((child) => child !== null && child.text === '->*');
+    const sibling = node.namedChildren.find((child) => child !== null && child.id !== recovered.id);
+    const errIdentifier = recovered.namedChildren.find((child) => child !== null);
+    if (operator === undefined || sibling === undefined || errIdentifier === undefined) {
+        return undefined;
+    }
+    // tree-sitter's error recovery groups `(obj->*ptr)` two ways depending on
+    // recovery cost (identifier lengths!): either `[identifier, ERROR "->*m"]`
+    // or `[ERROR "obj->*", identifier]`. Disambiguate by token order INSIDE the
+    // ERROR: an identifier BEFORE `->*` is the receiver (the sibling is the
+    // pointer/member); an identifier AFTER `->*` is the member (the sibling is
+    // the receiver). Assuming one fixed grouping swapped the roles and silently
+    // dropped the call site (#2522 review, H2).
+    if (errIdentifier.startIndex < operator.startIndex) {
+        return { receiver: errIdentifier, member: sibling, operator: operator.text };
+    }
+    return { receiver: sibling, member: errIdentifier, operator: operator.text };
+}
+/**
+ * Per-file wall-clock budget for the capture-emit loop (#2432). A worker
+ * thread stuck in this loop cannot be terminated safely (terminating a
+ * thread mid-N-API call aborts the whole process with Napi::Error), so the
+ * loop must bound itself: on breach we return the captures accumulated so
+ * far with a warning — degraded coverage for one file, never a crash or a
+ * thrown error (a throw here would make the language-group catch drop every
+ * remaining file in the batch).
+ *
+ * `GITNEXUS_CPP_CAPTURE_BUDGET_MS`: unset/invalid/negative → 20000; explicit
+ * 0 → expires immediately (deterministic test hook).
+ */
+const CPP_CAPTURE_BUDGET_DEFAULT_MS = 20_000;
+function cppCaptureBudgetMs() {
+    const raw = process.env.GITNEXUS_CPP_CAPTURE_BUDGET_MS;
+    if (raw === undefined || raw === '')
+        return CPP_CAPTURE_BUDGET_DEFAULT_MS;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : CPP_CAPTURE_BUDGET_DEFAULT_MS;
+}
 export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
@@ -21,10 +132,27 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
     }
     const rawMatches = getCppScopeQuery().matches(tree.rootNode);
     const out = [];
+    // #2432: reset the per-file lookup index. The identifier-argument type
+    // lookups below used to re-walk the AST per identifier (full-tree DFS in
+    // isKnownEnumName, per-scope declaration scans) — O(calls × args × treeSize)
+    // per file, 151s on a 194KB file that parses in 46ms. The index makes each
+    // lookup O(1) after a single lazily-built pass.
+    resetCppFileLookupIndex();
     // Track ranges where typedef-struct/enum was captured as its concrete type
     // so we can suppress the duplicate @declaration.typedef match.
     const concreteTypedefRanges = new Set();
+    // #2432: per-file deadline for the loop below (see cppCaptureBudgetMs).
+    // Checked every 64 matches — post-index a single iteration is microseconds,
+    // so the check granularity costs nothing and bounds the drift past the
+    // deadline to well under a second.
+    const budgetMs = cppCaptureBudgetMs();
+    const deadline = Date.now() + budgetMs;
+    let matchIndex = 0;
     for (const m of rawMatches) {
+        if ((matchIndex++ & 63) === 0 && Date.now() >= deadline) {
+            logger.warn({ filePath, budgetMs, processedMatches: matchIndex - 1, totalMatches: rawMatches.length }, `C++ capture extraction exceeded its ${budgetMs}ms budget for ${filePath}; returning partial captures for this file (#2432).`);
+            break;
+        }
         const grouped = {};
         // Parallel tag -> captured SyntaxNode map. The tree-sitter query already
         // hands us each matched node as `c.node`, so anchors resolve via a
@@ -360,8 +488,125 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
     // bases per ISO C++ two-phase lookup.
     detectCppDependentBases(tree.rootNode, filePath);
     captureCppMemberLookupFacts(tree.rootNode, filePath);
+    out.push(...synthesizeCallableFlowCaptures(tree.rootNode, CPP_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }
+function cppFunctionDeclaratorSignature(node) {
+    const declarator = cppFindDescendantOfType(node, 'function_declarator');
+    const parameters = declarator?.childForFieldName('parameters');
+    if (parameters === null || parameters === undefined) {
+        return recoverCppMemberPointerSignature(node.text);
+    }
+    const parameterNodes = parameters.namedChildren.filter((child) => child !== null && child.type.includes('parameter_declaration'));
+    const hasEllipsis = parameters.children.some((child) => child.type === '...' || (!child.isNamed && child.text === '...')) || parameterNodes.some((parameter) => parameter.type === 'variadic_parameter_declaration');
+    const isVoidOnly = parameterNodes.length === 1 &&
+        parameterNodes[0].namedChildCount === 1 &&
+        parameterNodes[0].firstNamedChild?.text === 'void';
+    if (isVoidOnly) {
+        return { parameterCount: 0, parameterTypes: [], parameterTypeClasses: [] };
+    }
+    const parameterTypes = [];
+    const parameterTypeClasses = [];
+    for (const parameter of parameterNodes) {
+        if (parameter.type === 'variadic_parameter_declaration') {
+            parameterTypes.push('...');
+            parameterTypeClasses.push({
+                base: '...',
+                cv: 'unknown',
+                indirection: 'unknown',
+                pointerDepth: 0,
+            });
+            continue;
+        }
+        const rawType = parameter.childForFieldName('type')?.text ?? 'unknown';
+        const declaratorText = parameter.childForFieldName('declarator')?.text;
+        parameterTypes.push(normalizeCppParamType(rawType));
+        parameterTypeClasses.push(classifyCppParameterType(rawType, declaratorText, parameter.text));
+    }
+    if (hasEllipsis && !parameterTypes.includes('...')) {
+        parameterTypes.push('...');
+        parameterTypeClasses.push({
+            base: '...',
+            cv: 'unknown',
+            indirection: 'unknown',
+            pointerDepth: 0,
+        });
+    }
+    return {
+        ...(hasEllipsis ? {} : { parameterCount: parameterNodes.length }),
+        parameterTypes,
+        parameterTypeClasses,
+        isConst: /\)\s*const(?:\s|$)/.test(declarator.text),
+    };
+}
+/**
+ * tree-sitter-cpp parses a non-const pointer-to-member variable such as
+ * `void (Base::*member)()` as nested call expressions (while the cv-qualified
+ * twin is a declaration). Recover the callable shape from the declarator text
+ * so `const`/non-`const` overload sets remain distinguishable.
+ */
+function recoverCppMemberPointerSignature(text) {
+    const match = text.match(/\(\s*[^()]*::\s*\*\s*[A-Za-z_]\w*\s*\)\s*\(([^()]*)\)\s*(const\b)?/);
+    if (match === null)
+        return undefined;
+    const rawParameters = match[1].trim();
+    const parameterCount = rawParameters === '' || rawParameters === 'void'
+        ? 0
+        : splitTopLevelCppParameters(rawParameters).length;
+    return { parameterCount, isConst: match[2] !== undefined };
+}
+function splitTopLevelCppParameters(text) {
+    const out = [];
+    let start = 0;
+    let angleDepth = 0;
+    let parenDepth = 0;
+    let bracketDepth = 0;
+    for (let index = 0; index < text.length; index++) {
+        switch (text[index]) {
+            case '<':
+                angleDepth++;
+                break;
+            case '>':
+                angleDepth = Math.max(0, angleDepth - 1);
+                break;
+            case '(':
+                parenDepth++;
+                break;
+            case ')':
+                parenDepth = Math.max(0, parenDepth - 1);
+                break;
+            case '[':
+                bracketDepth++;
+                break;
+            case ']':
+                bracketDepth = Math.max(0, bracketDepth - 1);
+                break;
+            case ',':
+                if (angleDepth === 0 && parenDepth === 0 && bracketDepth === 0) {
+                    out.push(text.slice(start, index).trim());
+                    start = index + 1;
+                }
+                break;
+        }
+    }
+    out.push(text.slice(start).trim());
+    return out.filter((parameter) => parameter.length > 0);
+}
+function cppContainsNodeType(root, type) {
+    return cppFindDescendantOfType(root, type) !== null;
+}
+function cppFindDescendantOfType(root, type) {
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === type)
+            return node;
+        for (const child of node.namedChildren)
+            if (child !== null)
+                stack.push(child);
+    }
+    return null;
+}
 function extractCppDeclarationReturnType(fnNode) {
     const typeNode = fnNode.childForFieldName('type');
     if (typeNode === null)
@@ -960,6 +1205,47 @@ function inferCppBracedInitType(node) {
         ? `${CPP_BRACED_INIT_TYPE_PREFIX}${first}:${elementTypes.length}`
         : `${CPP_BRACED_INIT_TYPE_PREFIX}unknown:${elementTypes.length}`;
 }
+let fileLookupIndex = {
+    enumNames: null,
+    scopeDecls: new Map(),
+    fnParams: new Map(),
+};
+function resetCppFileLookupIndex() {
+    fileLookupIndex = { enumNames: null, scopeDecls: new Map(), fnParams: new Map() };
+}
+/**
+ * First-declaration-wins map of the scope's `declaration` children that
+ * carry a concrete (non-placeholder) type and a nameable declarator —
+ * exactly the entries the replaced per-identifier scans could match.
+ */
+function scopeDeclarationsFor(scope) {
+    const cached = fileLookupIndex.scopeDecls.get(scope.id);
+    if (cached !== undefined)
+        return cached;
+    const decls = new Map();
+    for (let i = 0; i < scope.childCount; i++) {
+        const stmt = scope.child(i);
+        if (stmt === null || stmt.type !== 'declaration')
+            continue;
+        const typeNode = stmt.childForFieldName('type');
+        if (typeNode === null)
+            continue;
+        if (typeNode.type === 'placeholder_type_specifier')
+            continue;
+        const declarator = stmt.childForFieldName('declarator');
+        if (declarator === null)
+            continue;
+        const nameChild = declaredNameNode(declarator);
+        if (nameChild === null)
+            continue;
+        const name = extractDeclaratorLeafName(nameChild);
+        if (name === '' || decls.has(name))
+            continue;
+        decls.set(name, stmt);
+    }
+    fileLookupIndex.scopeDecls.set(scope.id, decls);
+    return decls;
+}
 /**
  * Look up the declared type of a variable by scanning sibling declarations
  * in the enclosing compound_statement (function body). Handles:
@@ -991,27 +1277,14 @@ function lookupDeclaredTypeForIdentifier(identNode) {
     const paramType = lookupFunctionParameterType(scope, varName);
     if (paramType !== '')
         return paramType;
-    // Scan declarations in the scope for a matching variable name
-    for (let i = 0; i < scope.childCount; i++) {
-        const stmt = scope.child(i);
-        if (stmt === null || stmt.type !== 'declaration')
-            continue;
-        const typeNode = stmt.childForFieldName('type');
-        if (typeNode === null)
-            continue;
-        // Skip auto/placeholder types — those need chain-follow, not literal
-        if (typeNode.type === 'placeholder_type_specifier')
-            continue;
-        // Check init_declarator children for the variable name
-        const declarator = stmt.childForFieldName('declarator');
-        if (declarator === null)
-            continue;
-        const nameChild = declaredNameNode(declarator);
-        if (nameChild !== null && extractDeclaratorLeafName(nameChild) === varName) {
-            return normalizeCppTypeText(typeNode.text);
-        }
-    }
-    return '';
+    // Indexed scope-declaration lookup (#2432; was a per-identifier scan).
+    const stmt = scopeDeclarationsFor(scope).get(varName);
+    if (stmt === undefined)
+        return '';
+    const typeNode = stmt.childForFieldName('type');
+    if (typeNode === null)
+        return '';
+    return normalizeCppTypeText(typeNode.text);
 }
 function lookupDeclaredTypeClassForIdentifier(identNode) {
     const varName = identNode.text;
@@ -1026,28 +1299,20 @@ function lookupDeclaredTypeClassForIdentifier(identNode) {
     const paramTypeClass = lookupFunctionParameterTypeClass(scope, varName, identNode);
     if (paramTypeClass !== undefined)
         return paramTypeClass;
-    for (let i = 0; i < scope.childCount; i++) {
-        const stmt = scope.child(i);
-        if (stmt === null || stmt.type !== 'declaration')
-            continue;
-        const typeNode = stmt.childForFieldName('type');
-        if (typeNode === null)
-            continue;
-        if (typeNode.type === 'placeholder_type_specifier')
-            continue;
-        const declarator = stmt.childForFieldName('declarator');
-        if (declarator === null)
-            continue;
-        const nameChild = declaredNameNode(declarator);
-        if (nameChild === null || extractDeclaratorLeafName(nameChild) !== varName)
-            continue;
-        const typeClass = classifyCppParameterType(typeNode.text, nameChild.text, stmt.text.replace(/;\s*$/, ''));
-        if (isKnownEnumName(identNode, typeClass.base)) {
-            return { ...typeClass, base: `enum:${typeClass.base}` };
-        }
-        return typeClass;
+    // Indexed scope-declaration lookup (#2432; was a per-identifier scan).
+    const stmt = scopeDeclarationsFor(scope).get(varName);
+    if (stmt === undefined)
+        return unknownTypeClass('unknown');
+    const typeNode = stmt.childForFieldName('type');
+    const declarator = stmt.childForFieldName('declarator');
+    const nameChild = declarator !== null ? declaredNameNode(declarator) : null;
+    if (typeNode === null || nameChild === null)
+        return unknownTypeClass('unknown');
+    const typeClass = classifyCppParameterType(typeNode.text, nameChild.text, stmt.text.replace(/;\s*$/, ''));
+    if (isKnownEnumName(identNode, typeClass.base)) {
+        return { ...typeClass, base: `enum:${typeClass.base}` };
     }
-    return unknownTypeClass('unknown');
+    return typeClass;
 }
 function lookupFunctionParameterType(scope, varName) {
     const param = findEnclosingFunctionParameter(scope, varName);
@@ -1078,27 +1343,45 @@ function findEnclosingFunctionParameter(scope, varName) {
     let node = scope.parent;
     while (node !== null) {
         if (node.type === 'function_definition' || node.type === 'function_declarator') {
-            const fnDecl = node.type === 'function_declarator'
-                ? node
-                : findFirstDescendantOfType(node, 'function_declarator');
-            const params = fnDecl?.childForFieldName('parameters') ?? null;
-            if (params !== null) {
-                for (let i = 0; i < params.namedChildCount; i++) {
-                    const param = params.namedChild(i);
-                    if (param === null || param.type !== 'parameter_declaration')
-                        continue;
-                    const declarator = param.childForFieldName('declarator');
-                    if (declarator !== null && extractDeclaratorLeafName(declarator) === varName) {
-                        return param;
-                    }
-                }
-            }
-            return null;
+            return enclosingFunctionParametersFor(node)?.get(varName) ?? null;
         }
         node = node.parent;
     }
     return null;
 }
+/**
+ * First-wins map of a function's `parameter_declaration`s by declarator
+ * leaf name (#2432; was a per-identifier scan). `null` when the function
+ * has no parameter list — the caller returns null without walking further
+ * up, preserving the replaced scan's early-return.
+ */
+function enclosingFunctionParametersFor(fnNode) {
+    const cached = fileLookupIndex.fnParams.get(fnNode.id);
+    if (cached !== undefined)
+        return cached;
+    const fnDecl = fnNode.type === 'function_declarator'
+        ? fnNode
+        : findFirstDescendantOfType(fnNode, 'function_declarator');
+    const params = fnDecl?.childForFieldName('parameters') ?? null;
+    let index = null;
+    if (params !== null) {
+        index = new Map();
+        for (let i = 0; i < params.namedChildCount; i++) {
+            const param = params.namedChild(i);
+            if (param === null || param.type !== 'parameter_declaration')
+                continue;
+            const declarator = param.childForFieldName('declarator');
+            if (declarator === null)
+                continue;
+            const name = extractDeclaratorLeafName(declarator);
+            if (name === '' || index.has(name))
+                continue;
+            index.set(name, param);
+        }
+    }
+    fileLookupIndex.fnParams.set(fnNode.id, index);
+    return index;
+}
 function declaredNameNode(declarator) {
     if (declarator.type !== 'init_declarator')
         return declarator;
@@ -1126,24 +1409,31 @@ function normalizeCppTypeText(text) {
 function isKnownEnumName(node, typeName) {
     if (typeName === '' || typeName === 'unknown')
         return false;
-    let root = node;
-    while (root.parent !== null)
-        root = root.parent;
-    const stack = [root];
-    while (stack.length > 0) {
-        const cur = stack.pop();
-        if (cur.type === 'enum_specifier') {
-            const name = cur.childForFieldName('name');
-            if (name?.text === typeName)
-                return true;
-        }
-        for (let i = 0; i < cur.childCount; i++) {
-            const child = cur.child(i);
-            if (child !== null)
-                stack.push(child);
+    // One full-tree DFS per FILE (lazy), not per identifier argument — the
+    // per-identifier walk here was the dominant cost of #2432 (87s of a 151s
+    // extraction on a file that parses in 46ms).
+    if (fileLookupIndex.enumNames === null) {
+        let root = node;
+        while (root.parent !== null)
+            root = root.parent;
+        const names = new Set();
+        const stack = [root];
+        while (stack.length > 0) {
+            const cur = stack.pop();
+            if (cur.type === 'enum_specifier') {
+                const name = cur.childForFieldName('name');
+                if (name !== null)
+                    names.add(name.text);
+            }
+            for (let i = 0; i < cur.childCount; i++) {
+                const child = cur.child(i);
+                if (child !== null)
+                    stack.push(child);
+            }
         }
+        fileLookupIndex.enumNames = names;
     }
-    return false;
+    return fileLookupIndex.enumNames.has(typeName);
 }
 /**
  * Detect whether a `namespace_definition` AST node is inline.

package/dist/core/ingestion/languages/cpp/scope-resolver.js

@@ -238,6 +238,20 @@ export const cppScopeResolver = {
             return true;
         return false;
     },
+    // Keep declaration/definition identity narrower than the global free-call
+    // visibility gate above: namespace and class ownership do not imply
+    // internal linkage, while a namespace-scope `static` function does.
+    hasFileLocalCallableLinkage: (def) => {
+        // Class members have EXTERNAL linkage even when declared `static` —
+        // inside a class, `static` means "no instance", not internal linkage.
+        // The name-keyed set below is populated from every `static` declaration,
+        // so without this gate a header-declared static member refused its
+        // cross-file definition join (#2522 review, M2).
+        if (def.type === 'Method' || def.type === 'Constructor')
+            return false;
+        const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+        return isFileLocal(def.filePath, simple);
+    },
     // C++ two-phase template lookup: inside a class template body,
     // unqualified calls MUST NOT bind to members of a dependent base
     // class. The standard requires `this->name()` or `Base<T>::name()`

package/dist/core/ingestion/languages/csharp/captures.js

@@ -23,6 +23,7 @@ import { getCsharpParser, getCsharpScopeQuery } from './query.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
 /** Declaration anchors that carry function-like arity metadata. */
 const FUNCTION_DECL_TAGS = [
     '@declaration.method',
@@ -38,6 +39,29 @@ const FUNCTION_NODE_TYPES = [
     'conversion_operator_declaration',
     'local_function_statement',
 ];
+const CSHARP_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set([
+        ...FUNCTION_NODE_TYPES,
+        'lambda_expression',
+        'anonymous_method_expression',
+    ]),
+    callNodeTypes: new Set(['invocation_expression']),
+    parameterListNodeTypes: new Set(['parameter_list', 'argument_list']),
+    parameterNodeTypes: new Set(['parameter']),
+    bindingNodeTypes: new Set(['variable_declarator']),
+    assignmentNodeTypes: new Set(['assignment_expression']),
+    identifierNodeTypes: new Set(['identifier', 'generic_name']),
+    callableProtocolMethods: new Set(['Invoke']),
+    extractAssignment: (node) => {
+        if (node.type !== 'variable_declarator')
+            return undefined;
+        const destination = node.childForFieldName('name');
+        const source = node.lastNamedChild;
+        if (destination === null || source === null || source.id === destination.id)
+            return undefined;
+        return { destination, source };
+    },
+};
 const BUILTIN_TYPE_NAMES = new Set([
     'bool',
     'byte',
@@ -228,6 +252,7 @@ export function emitCsharpScopeCaptures(sourceText, _filePath, cachedTree) {
     out.push(...synthesizeGenericTypeArgumentReferences(tree.rootNode));
     out.push(...synthesizeCsharpInheritanceReferences(tree.rootNode));
     out.push(...synthesizeCsharpConstructorInitializerReferences(tree.rootNode));
+    out.push(...synthesizeCallableFlowCaptures(tree.rootNode, CSHARP_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }
 /**