arceus-s 1.6.4

package/dist/core/ingestion/languages/c/simple-hooks.d.ts

@@ -0,0 +1,14 @@
+import type { CaptureMatch, ParsedImport, Scope, ScopeId, ScopeTree, TypeRef } from '../../../../_shared/index.js';
+/**
+ * C binding scope: always use default auto-hoist (null).
+ * C has no self/receiver bindings that need special scoping.
+ */
+export declare function cBindingScopeFor(_decl: CaptureMatch, _innermost: Scope, _tree: ScopeTree): ScopeId | null;
+/**
+ * C import owning scope: always use default (null).
+ */
+export declare function cImportOwningScope(_imp: ParsedImport, _innermost: Scope, _tree: ScopeTree): ScopeId | null;
+/**
+ * C receiver binding: always null. C has no methods or receivers.
+ */
+export declare function cReceiverBinding(_functionScope: Scope): TypeRef | null;

package/dist/core/ingestion/languages/c/simple-hooks.js

@@ -0,0 +1,19 @@
+/**
+ * C binding scope: always use default auto-hoist (null).
+ * C has no self/receiver bindings that need special scoping.
+ */
+export function cBindingScopeFor(_decl, _innermost, _tree) {
+    return null;
+}
+/**
+ * C import owning scope: always use default (null).
+ */
+export function cImportOwningScope(_imp, _innermost, _tree) {
+    return null;
+}
+/**
+ * C receiver binding: always null. C has no methods or receivers.
+ */
+export function cReceiverBinding(_functionScope) {
+    return null;
+}

package/dist/core/ingestion/languages/c/static-linkage.d.ts

@@ -0,0 +1,13 @@
+import type { ParsedFile, ScopeId } from '../../../../_shared/index.js';
+/** Record a symbol name as `static` (file-local linkage) for the given file. */
+export declare function markStaticName(filePath: string, name: string): void;
+/** Check whether a symbol name has `static` linkage in the given file. */
+export declare function isStaticName(filePath: string, name: string): boolean;
+/** Clear tracked static names (for testing). */
+export declare function clearStaticNames(): void;
+/**
+ * Return the names visible through a C wildcard import (`#include`).
+ * All module-scope defs from the target file are visible EXCEPT those
+ * declared with `static` storage class (file-local linkage in C).
+ */
+export declare function expandCWildcardNames(targetModuleScope: ScopeId, parsedFiles: readonly ParsedFile[]): readonly string[];

package/dist/core/ingestion/languages/c/static-linkage.js

@@ -0,0 +1,57 @@
+/**
+ * Per-file set of function names declared with `static` storage class.
+ * Populated during `emitCScopeCaptures` and consumed by `expandCWildcardNames`
+ * to exclude file-local symbols from cross-file wildcard import visibility.
+ *
+ * NOTE: module-level state, single-process-single-repo use only.
+ * For server-mode or multi-repo-in-one-process use cases, call
+ * `clearStaticNames()` at the start of each resolution pass to avoid
+ * stale static-linkage data from a previous invocation.
+ *
+ * Key: filePath, Value: Set of static function names.
+ */
+const staticNames = new Map();
+/** Record a symbol name as `static` (file-local linkage) for the given file. */
+export function markStaticName(filePath, name) {
+    let names = staticNames.get(filePath);
+    if (names === undefined) {
+        names = new Set();
+        staticNames.set(filePath, names);
+    }
+    names.add(name);
+}
+/** Check whether a symbol name has `static` linkage in the given file. */
+export function isStaticName(filePath, name) {
+    return staticNames.get(filePath)?.has(name) ?? false;
+}
+/** Clear tracked static names (for testing). */
+export function clearStaticNames() {
+    staticNames.clear();
+}
+/**
+ * Return the names visible through a C wildcard import (`#include`).
+ * All module-scope defs from the target file are visible EXCEPT those
+ * declared with `static` storage class (file-local linkage in C).
+ */
+export function expandCWildcardNames(targetModuleScope, parsedFiles) {
+    const target = parsedFiles.find((p) => p.moduleScope === targetModuleScope);
+    if (target === undefined)
+        return [];
+    const seen = new Set();
+    const names = [];
+    for (const def of target.localDefs) {
+        const name = simpleName(def);
+        if (name === '')
+            continue;
+        if (isStaticName(target.filePath, name))
+            continue;
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        names.push(name);
+    }
+    return names;
+}
+function simpleName(def) {
+    return def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+}

package/dist/core/ingestion/languages/c-cpp.d.ts

@@ -0,0 +1,12 @@
+/**
+ * C and C++ language providers.
+ *
+ * Both languages use wildcard import semantics (headers expose all symbols
+ * via #include). Neither language has named binding extraction.
+ *
+ * C uses 'first-wins' MRO (no inheritance). C++ uses 'leftmost-base' MRO
+ * for its left-to-right multiple inheritance resolution order.
+ */
+import type { LanguageProvider } from '../language-provider.js';
+export declare const cProvider: LanguageProvider;
+export declare const cppProvider: LanguageProvider;

package/dist/core/ingestion/languages/c-cpp.js

@@ -0,0 +1,411 @@
+/**
+ * C and C++ language providers.
+ *
+ * Both languages use wildcard import semantics (headers expose all symbols
+ * via #include). Neither language has named binding extraction.
+ *
+ * C uses 'first-wins' MRO (no inheritance). C++ uses 'leftmost-base' MRO
+ * for its left-to-right multiple inheritance resolution order.
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
+import { cClassConfig, cppClassConfig } from '../class-extractors/configs/c-cpp.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as cCppConfig } from '../type-extractors/c-cpp.js';
+import { cCppExportChecker } from '../export-detection.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { cImportConfig, cppImportConfig } from '../import-resolvers/configs/c-cpp.js';
+import { C_QUERIES, CPP_QUERIES } from '../tree-sitter-queries.js';
+/**
+ * Node types for standard function declarations that need C/C++ declarator handling.
+ * Used by cCppExtractFunctionName to determine how to extract the function name.
+ */
+const FUNCTION_DECLARATION_TYPES = new Set([
+    'function_declaration',
+    'function_definition',
+    'async_function_declaration',
+    'generator_function_declaration',
+    'function_item',
+]);
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { cConfig as cFieldConfig, cppConfig as cppFieldConfig, } from '../field-extractors/configs/c-cpp.js';
+import { createMethodExtractor } from '../method-extractors/generic.js';
+import { cMethodConfig, cppMethodConfig } from '../method-extractors/configs/c-cpp.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { cVariableConfig, cppVariableConfig } from '../variable-extractors/configs/c-cpp.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { cCallConfig, cppCallConfig } from '../call-extractors/configs/c-cpp.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+import { stripUeMacros } from '../cpp-ue-preprocessor.js';
+import { emitCScopeCaptures, interpretCImport, interpretCTypeBinding, cArityCompatibility, cBindingScopeFor, cImportOwningScope, cReceiverBinding, } from './c/index.js';
+const C_BUILT_INS = new Set([
+    'printf',
+    'fprintf',
+    'sprintf',
+    'snprintf',
+    'vprintf',
+    'vfprintf',
+    'vsprintf',
+    'vsnprintf',
+    'scanf',
+    'fscanf',
+    'sscanf',
+    'malloc',
+    'calloc',
+    'realloc',
+    'free',
+    'memcpy',
+    'memmove',
+    'memset',
+    'memcmp',
+    'strlen',
+    'strcpy',
+    'strncpy',
+    'strcat',
+    'strncat',
+    'strcmp',
+    'strncmp',
+    'strstr',
+    'strchr',
+    'strrchr',
+    'atoi',
+    'atol',
+    'atof',
+    'strtol',
+    'strtoul',
+    'strtoll',
+    'strtoull',
+    'strtod',
+    'sizeof',
+    'offsetof',
+    'typeof',
+    'assert',
+    'abort',
+    'exit',
+    '_exit',
+    'fopen',
+    'fclose',
+    'fread',
+    'fwrite',
+    'fseek',
+    'ftell',
+    'rewind',
+    'fflush',
+    'fgets',
+    'fputs',
+    'likely',
+    'unlikely',
+    'BUG',
+    'BUG_ON',
+    'WARN',
+    'WARN_ON',
+    'WARN_ONCE',
+    'IS_ERR',
+    'PTR_ERR',
+    'ERR_PTR',
+    'IS_ERR_OR_NULL',
+    'ARRAY_SIZE',
+    'container_of',
+    'list_for_each_entry',
+    'list_for_each_entry_safe',
+    'min',
+    'max',
+    'clamp',
+    'abs',
+    'swap',
+    'pr_info',
+    'pr_warn',
+    'pr_err',
+    'pr_debug',
+    'pr_notice',
+    'pr_crit',
+    'pr_emerg',
+    'printk',
+    'dev_info',
+    'dev_warn',
+    'dev_err',
+    'dev_dbg',
+    'GFP_KERNEL',
+    'GFP_ATOMIC',
+    'spin_lock',
+    'spin_unlock',
+    'spin_lock_irqsave',
+    'spin_unlock_irqrestore',
+    'mutex_lock',
+    'mutex_unlock',
+    'mutex_init',
+    'kfree',
+    'kmalloc',
+    'kzalloc',
+    'kcalloc',
+    'krealloc',
+    'kvmalloc',
+    'kvfree',
+    'get',
+    'put',
+]);
+const cClassExtractor = createClassExtractor(cClassConfig);
+const cppClassExtractor = createClassExtractor(cppClassConfig);
+/**
+ * C/C++ function name extraction — unwraps pointer_declarator / reference_declarator /
+ * function_declarator / qualified_identifier chains to find the actual function name.
+ * Handles field_identifier (method inside class body) and parenthesized_declarator.
+ */
+const cCppExtractFunctionName = (node) => {
+    if (!FUNCTION_DECLARATION_TYPES.has(node.type))
+        return null;
+    let funcName = null;
+    let label = 'Function';
+    // C/C++: function_definition -> [pointer_declarator ->] function_declarator -> qualified_identifier/identifier
+    // Unwrap pointer_declarator / reference_declarator wrappers to reach function_declarator
+    let declarator = node.childForFieldName?.('declarator');
+    if (!declarator) {
+        for (let i = 0; i < node.childCount; i++) {
+            const c = node.child(i);
+            if (c?.type === 'function_declarator') {
+                declarator = c;
+                break;
+            }
+        }
+    }
+    while (declarator &&
+        (declarator.type === 'pointer_declarator' || declarator.type === 'reference_declarator')) {
+        let nextDeclarator = declarator.childForFieldName?.('declarator');
+        if (!nextDeclarator) {
+            for (let i = 0; i < declarator.childCount; i++) {
+                const c = declarator.child(i);
+                if (c?.type === 'function_declarator' ||
+                    c?.type === 'pointer_declarator' ||
+                    c?.type === 'reference_declarator') {
+                    nextDeclarator = c;
+                    break;
+                }
+            }
+        }
+        declarator = nextDeclarator;
+    }
+    if (declarator) {
+        let innerDeclarator = declarator.childForFieldName?.('declarator');
+        if (!innerDeclarator) {
+            for (let i = 0; i < declarator.childCount; i++) {
+                const c = declarator.child(i);
+                if (c?.type === 'qualified_identifier' ||
+                    c?.type === 'identifier' ||
+                    c?.type === 'field_identifier' ||
+                    c?.type === 'parenthesized_declarator') {
+                    innerDeclarator = c;
+                    break;
+                }
+            }
+        }
+        if (innerDeclarator?.type === 'qualified_identifier') {
+            let nameNode = innerDeclarator.childForFieldName?.('name');
+            if (!nameNode) {
+                for (let i = 0; i < innerDeclarator.childCount; i++) {
+                    const c = innerDeclarator.child(i);
+                    if (c?.type === 'identifier') {
+                        nameNode = c;
+                        break;
+                    }
+                }
+            }
+            if (nameNode?.text) {
+                funcName = nameNode.text;
+                label = 'Method';
+            }
+        }
+        else if (innerDeclarator?.type === 'identifier' ||
+            innerDeclarator?.type === 'field_identifier') {
+            // field_identifier is used for method names inside C++ class bodies
+            funcName = innerDeclarator.text;
+            if (innerDeclarator.type === 'field_identifier')
+                label = 'Method';
+        }
+        else if (innerDeclarator?.type === 'parenthesized_declarator') {
+            let nestedId = null;
+            for (let i = 0; i < innerDeclarator.childCount; i++) {
+                const c = innerDeclarator.child(i);
+                if (c?.type === 'qualified_identifier' || c?.type === 'identifier') {
+                    nestedId = c;
+                    break;
+                }
+            }
+            if (nestedId?.type === 'qualified_identifier') {
+                let nameNode = nestedId.childForFieldName?.('name');
+                if (!nameNode) {
+                    for (let i = 0; i < nestedId.childCount; i++) {
+                        const c = nestedId.child(i);
+                        if (c?.type === 'identifier') {
+                            nameNode = c;
+                            break;
+                        }
+                    }
+                }
+                if (nameNode?.text) {
+                    funcName = nameNode.text;
+                    label = 'Method';
+                }
+            }
+            else if (nestedId?.type === 'identifier') {
+                funcName = nestedId.text;
+            }
+        }
+    }
+    // Fallback for other node types in FUNCTION_DECLARATION_TYPES (e.g. function_item for Rust in C++ tree)
+    if (!funcName) {
+        let nameNode = node.childForFieldName?.('name');
+        if (!nameNode) {
+            for (let i = 0; i < node.childCount; i++) {
+                const c = node.child(i);
+                if (c?.type === 'identifier' ||
+                    c?.type === 'property_identifier' ||
+                    c?.type === 'simple_identifier') {
+                    nameNode = c;
+                    break;
+                }
+            }
+        }
+        funcName = nameNode?.text ?? null;
+    }
+    return { funcName, label };
+};
+/** Check if a C/C++ function_definition is inside a class or struct body.
+ *  Used by cppLabelOverride to skip duplicate function captures
+ *  that are already covered by definition.method queries. */
+function isCppInsideClassOrStruct(functionNode) {
+    let ancestor = functionNode?.parent ?? null;
+    while (ancestor) {
+        if (ancestor.type === 'class_specifier' || ancestor.type === 'struct_specifier')
+            return true;
+        ancestor = ancestor.parent;
+    }
+    return false;
+}
+/** Label override shared by C and C++: skip function_definition captures inside class/struct
+ *  bodies (they're duplicates of definition.method captures). */
+const cppLabelOverride = (functionNode, defaultLabel) => {
+    if (defaultLabel !== 'Function')
+        return defaultLabel;
+    return isCppInsideClassOrStruct(functionNode) ? null : defaultLabel;
+};
+export const cProvider = defineLanguage({
+    id: SupportedLanguages.C,
+    extensions: ['.c'],
+    entryPointPatterns: [
+        /^main$/,
+        /^init_/,
+        /_init$/,
+        /^start_/,
+        /_start$/,
+        /^run_/,
+        /_run$/,
+        /^stop_/,
+        /_stop$/,
+        /^open_/,
+        /_open$/,
+        /^close_/,
+        /_close$/,
+        /^create_/,
+        /_create$/,
+        /^destroy_/,
+        /_destroy$/,
+        /^handle_/,
+        /_handler$/,
+        /_callback$/,
+        /^cmd_/,
+        /^server_/,
+        /^client_/,
+        /^session_/,
+        /^window_/,
+        /^key_/,
+        /^input_/,
+        /^output_/,
+        /^notify_/,
+        /^control_/,
+    ],
+    treeSitterQueries: C_QUERIES,
+    typeConfig: cCppConfig,
+    exportChecker: cCppExportChecker,
+    importResolver: createImportResolver(cImportConfig),
+    importSemantics: 'wildcard-transitive',
+    callExtractor: createCallExtractor(cCallConfig),
+    fieldExtractor: createFieldExtractor(cFieldConfig),
+    methodExtractor: createMethodExtractor({
+        ...cMethodConfig,
+        extractFunctionName: cCppExtractFunctionName,
+    }),
+    variableExtractor: createVariableExtractor(cVariableConfig),
+    classExtractor: cClassExtractor,
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.C),
+    labelOverride: cppLabelOverride,
+    builtInNames: C_BUILT_INS,
+    // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
+    emitScopeCaptures: emitCScopeCaptures,
+    interpretImport: interpretCImport,
+    interpretTypeBinding: interpretCTypeBinding,
+    bindingScopeFor: cBindingScopeFor,
+    importOwningScope: cImportOwningScope,
+    receiverBinding: cReceiverBinding,
+    arityCompatibility: cArityCompatibility,
+    // mergeBindings + resolveImportTarget live on ScopeResolver (see c/scope-resolver.ts).
+});
+export const cppProvider = defineLanguage({
+    id: SupportedLanguages.CPlusPlus,
+    extensions: ['.cpp', '.cc', '.cxx', '.h', '.hpp', '.hxx', '.hh'],
+    entryPointPatterns: [
+        /^main$/,
+        /^init_/,
+        /_init$/,
+        /^Create[A-Z]/,
+        /^create_/,
+        /^Run$/,
+        /^run$/,
+        /^Start$/,
+        /^start$/,
+        /^handle_/,
+        /_handler$/,
+        /_callback$/,
+        /^OnEvent/,
+        /^on_/,
+        /::Run$/,
+        /::Start$/,
+        /::Init$/,
+        /::Execute$/,
+    ],
+    astFrameworkPatterns: [
+        {
+            framework: 'qt',
+            entryPointMultiplier: 2.8,
+            reason: 'qt-macro',
+            patterns: [
+                'Q_OBJECT',
+                'Q_INVOKABLE',
+                'Q_PROPERTY',
+                'Q_SIGNALS',
+                'Q_SLOTS',
+                'Q_SIGNAL',
+                'Q_SLOT',
+                'QWidget',
+                'QApplication',
+            ],
+        },
+    ],
+    treeSitterQueries: CPP_QUERIES,
+    preprocessSource: stripUeMacros,
+    typeConfig: cCppConfig,
+    exportChecker: cCppExportChecker,
+    importResolver: createImportResolver(cppImportConfig),
+    importSemantics: 'wildcard-transitive',
+    mroStrategy: 'leftmost-base',
+    callExtractor: createCallExtractor(cppCallConfig),
+    fieldExtractor: createFieldExtractor(cppFieldConfig),
+    methodExtractor: createMethodExtractor({
+        ...cppMethodConfig,
+        extractFunctionName: cCppExtractFunctionName,
+    }),
+    variableExtractor: createVariableExtractor(cppVariableConfig),
+    classExtractor: cppClassExtractor,
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.CPlusPlus),
+    labelOverride: cppLabelOverride,
+    builtInNames: C_BUILT_INS,
+});

package/dist/core/ingestion/languages/cobol.d.ts

@@ -0,0 +1 @@
+export declare const cobolProvider: import("../language-provider.js").LanguageProvider;

package/dist/core/ingestion/languages/cobol.js

@@ -0,0 +1,28 @@
+/**
+ * COBOL Language Provider
+ *
+ * Standalone regex-based processor — no tree-sitter grammar.
+ * COBOL files (.cbl, .cob, .cobol, .cpy, .copybook) are detected and
+ * processed by cobol-processor.ts in pipeline Phase 2.6, not by the
+ * tree-sitter pipeline.
+ *
+ * This provider exists to satisfy the SupportedLanguages exhaustiveness
+ * checks and to declare parseStrategy: 'standalone'.
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { defineLanguage } from '../language-provider.js';
+export const cobolProvider = defineLanguage({
+    id: SupportedLanguages.Cobol,
+    parseStrategy: 'standalone',
+    extensions: [], // COBOL files detected by cobol-processor's isCobolFile/isJclFile
+    entryPointPatterns: [],
+    astFrameworkPatterns: [],
+    treeSitterQueries: '',
+    typeConfig: {
+        declarationNodeTypes: new Set(),
+        extractDeclaration: () => null,
+        extractParameter: () => null,
+    },
+    exportChecker: () => false,
+    importResolver: () => null,
+});

package/dist/core/ingestion/languages/csharp/accessor-unwrap.d.ts

@@ -0,0 +1,21 @@
+/**
+ * C# collection-accessor unwrapping.
+ *
+ * When the compound-receiver resolver encounters a trailing
+ * `.Values` / `.Keys` on a dotted member-access chain, it calls the
+ * provider's `unwrapCollectionAccessor` hook to find the element
+ * type. This module supplies the C# implementation — recognizing
+ * Dictionary-family generics and returning the value or key type.
+ *
+ * Other languages (Python, Java, TypeScript) use method-call syntax
+ * for the same access (`.values()` / `.keys()`), which the compound-
+ * receiver's call-expression branch already handles; they leave this
+ * hook undefined.
+ */
+/**
+ * Resolve `data.Values` / `data.Keys` on a Dictionary-like receiver
+ * to its element-type simple name. Returns `undefined` for any
+ * receiver / accessor combination we don't recognize, letting the
+ * compound-receiver pass fall through to the regular field walk.
+ */
+export declare function unwrapCsharpCollectionAccessor(receiverType: string, accessor: string): string | undefined;

package/dist/core/ingestion/languages/csharp/accessor-unwrap.js

@@ -0,0 +1,56 @@
+/**
+ * C# collection-accessor unwrapping.
+ *
+ * When the compound-receiver resolver encounters a trailing
+ * `.Values` / `.Keys` on a dotted member-access chain, it calls the
+ * provider's `unwrapCollectionAccessor` hook to find the element
+ * type. This module supplies the C# implementation — recognizing
+ * Dictionary-family generics and returning the value or key type.
+ *
+ * Other languages (Python, Java, TypeScript) use method-call syntax
+ * for the same access (`.values()` / `.keys()`), which the compound-
+ * receiver's call-expression branch already handles; they leave this
+ * hook undefined.
+ */
+/** Extract (K, V) from `Dictionary<K, V>` / `IDictionary<K, V>` /
+ *  `IReadOnlyDictionary<K, V>` / `SortedDictionary<K, V>` /
+ *  `ConcurrentDictionary<K, V>` / `ImmutableDictionary<K, V>`.
+ *  Returns undefined if the type name doesn't match or the argument
+ *  list isn't exactly two top-level args. */
+function extractDictionaryArgs(rawName) {
+    const match = rawName.match(/^(?:[A-Za-z_][A-Za-z0-9_.]*\.)?(?:Dictionary|IDictionary|IReadOnlyDictionary|SortedDictionary|ConcurrentDictionary|ImmutableDictionary)<(.+)>$/);
+    if (match === null)
+        return undefined;
+    const inner = match[1];
+    // Split on the top-level comma (tolerate nested `<...>`).
+    let depth = 0;
+    let commaIdx = -1;
+    for (let i = 0; i < inner.length; i++) {
+        const ch = inner[i];
+        if (ch === '<')
+            depth++;
+        else if (ch === '>')
+            depth--;
+        else if (ch === ',' && depth === 0) {
+            commaIdx = i;
+            break;
+        }
+    }
+    if (commaIdx === -1)
+        return undefined;
+    return { key: inner.slice(0, commaIdx).trim(), value: inner.slice(commaIdx + 1).trim() };
+}
+/**
+ * Resolve `data.Values` / `data.Keys` on a Dictionary-like receiver
+ * to its element-type simple name. Returns `undefined` for any
+ * receiver / accessor combination we don't recognize, letting the
+ * compound-receiver pass fall through to the regular field walk.
+ */
+export function unwrapCsharpCollectionAccessor(receiverType, accessor) {
+    if (accessor !== 'Values' && accessor !== 'Keys')
+        return undefined;
+    const args = extractDictionaryArgs(receiverType);
+    if (args === undefined)
+        return undefined;
+    return accessor === 'Values' ? args.value : args.key;
+}

package/dist/core/ingestion/languages/csharp/arity-metadata.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Extract C# arity metadata from a method-like tree-sitter node —
+ * `method_declaration`, `constructor_declaration`, `destructor_declaration`,
+ * `operator_declaration`, `conversion_operator_declaration`, or
+ * `local_function_statement`.
+ *
+ * Reuses `csharpMethodConfig.extractParameters` so scope-extracted defs
+ * carry the same arity semantics as the legacy parse-worker path:
+ *   - `params` variadic collapses `parameterCount` to `undefined`,
+ *     which `csharpArityCompatibility` then treats as "max unknown" —
+ *     the candidate stays eligible at `argCount >= required`.
+ *   - Defaulted parameters (`= expr`) contribute to `optionalCount`;
+ *     `requiredParameterCount = total − optionalCount`.
+ *   - `parameterTypes` collects declared type names (with `ref`/`out`/
+ *     `in` prefix) for overload narrowing; a literal `'params'` marker
+ *     is appended for variadic methods so `csharpArityCompatibility`
+ *     can detect them without re-reading the AST.
+ */
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+interface CsharpArityMetadata {
+    readonly parameterCount: number | undefined;
+    readonly requiredParameterCount: number | undefined;
+    readonly parameterTypes: readonly string[] | undefined;
+}
+export declare function computeCsharpArityMetadata(fnNode: SyntaxNode): CsharpArityMetadata;
+export {};