arceus-s 1.6.4

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

@@ -0,0 +1,167 @@
+/**
+ * Rust Language Provider
+ *
+ * Assembles all Rust-specific ingestion capabilities into a single
+ * LanguageProvider, following the Strategy pattern used by the pipeline.
+ *
+ * Key Rust traits:
+ *   - importSemantics: 'named' (Rust has use X::{a, b})
+ *   - mroStrategy: 'qualified-syntax' (Rust uses trait qualification, not MRO)
+ *   - namedBindingExtractor: present (use X::{a, b} extracts named bindings)
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
+import { rustClassConfig } from '../class-extractors/configs/rust.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as rustConfig } from '../type-extractors/rust.js';
+import { rustExportChecker } from '../export-detection.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { rustImportConfig } from '../import-resolvers/configs/rust.js';
+import { extractRustNamedBindings } from '../named-bindings/rust.js';
+import { RUST_QUERIES } from '../tree-sitter-queries.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { rustConfig as rustFieldConfig } from '../field-extractors/configs/rust.js';
+import { createMethodExtractor } from '../method-extractors/generic.js';
+import { rustMethodConfig } from '../method-extractors/configs/rust.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { rustVariableConfig } from '../variable-extractors/configs/rust.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { rustCallConfig } from '../call-extractors/configs/rust.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+/** Rust impl_item: find the function_item child and extract its name as a Method. */
+const rustExtractFunctionName = (node) => {
+    if (node.type !== 'impl_item')
+        return null;
+    let funcItem = null;
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c?.type === 'function_item') {
+            funcItem = c;
+            break;
+        }
+    }
+    if (!funcItem)
+        return null;
+    let nameNode = funcItem.childForFieldName?.('name');
+    if (!nameNode) {
+        for (let i = 0; i < funcItem.childCount; i++) {
+            const c = funcItem.child(i);
+            if (c?.type === 'identifier') {
+                nameNode = c;
+                break;
+            }
+        }
+    }
+    return { funcName: nameNode?.text ?? null, label: 'Method' };
+};
+const BUILT_INS = new Set([
+    'unwrap',
+    'expect',
+    'unwrap_or',
+    'unwrap_or_else',
+    'unwrap_or_default',
+    'ok',
+    'err',
+    'is_ok',
+    'is_err',
+    'map',
+    'map_err',
+    'and_then',
+    'or_else',
+    'clone',
+    'to_string',
+    'to_owned',
+    'into',
+    'from',
+    'as_ref',
+    'as_mut',
+    'iter',
+    'into_iter',
+    'collect',
+    'filter',
+    'fold',
+    'for_each',
+    'len',
+    'is_empty',
+    'push',
+    'pop',
+    'insert',
+    'remove',
+    'contains',
+    'format',
+    'write',
+    'writeln',
+    'panic',
+    'unreachable',
+    'todo',
+    'unimplemented',
+    'vec',
+    'println',
+    'eprintln',
+    'dbg',
+    'lock',
+    'read',
+    'try_lock',
+    'spawn',
+    'join',
+    'sleep',
+    'Some',
+    'None',
+    'Ok',
+    'Err',
+]);
+export const rustProvider = defineLanguage({
+    id: SupportedLanguages.Rust,
+    extensions: ['.rs'],
+    entryPointPatterns: [/^(get|post|put|delete)_handler$/i, /^handle_/, /^new$/, /^run$/, /^spawn/],
+    astFrameworkPatterns: [
+        {
+            framework: 'actix-web',
+            entryPointMultiplier: 3.0,
+            reason: 'actix-attribute',
+            patterns: [
+                '#[get',
+                '#[post',
+                '#[put',
+                '#[delete',
+                '#[actix_web',
+                'HttpRequest',
+                'HttpResponse',
+            ],
+        },
+        {
+            framework: 'axum',
+            entryPointMultiplier: 3.0,
+            reason: 'axum-routing',
+            patterns: ['Router::new', 'axum::extract', 'axum::routing'],
+        },
+        {
+            framework: 'rocket',
+            entryPointMultiplier: 3.0,
+            reason: 'rocket-attribute',
+            patterns: ['#[get', '#[post', '#[launch', 'rocket::'],
+        },
+        {
+            framework: 'tokio',
+            entryPointMultiplier: 2.5,
+            reason: 'tokio-runtime',
+            patterns: ['#[tokio::main]', '#[tokio::test]'],
+        },
+    ],
+    treeSitterQueries: RUST_QUERIES,
+    typeConfig: rustConfig,
+    exportChecker: rustExportChecker,
+    importResolver: createImportResolver(rustImportConfig),
+    namedBindingExtractor: extractRustNamedBindings,
+    mroStrategy: 'qualified-syntax',
+    callExtractor: createCallExtractor(rustCallConfig),
+    fieldExtractor: createFieldExtractor(rustFieldConfig),
+    methodExtractor: createMethodExtractor({
+        ...rustMethodConfig,
+        extractFunctionName: rustExtractFunctionName,
+    }),
+    variableExtractor: createVariableExtractor(rustVariableConfig),
+    classExtractor: createClassExtractor(rustClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.Rust),
+    builtInNames: BUILT_INS,
+});

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

@@ -0,0 +1,12 @@
+/**
+ * Swift Language Provider
+ *
+ * Assembles all Swift-specific ingestion capabilities into a single
+ * LanguageProvider, following the Strategy pattern used by the pipeline.
+ *
+ * Key Swift traits:
+ *   - importSemantics: 'wildcard-leaf' (Swift imports entire modules)
+ *   - heritageDefaultEdge: 'IMPLEMENTS' (protocols are more common than class inheritance)
+ *   - implicitImportWirer: all files in the same SPM target see each other
+ */
+export declare const swiftProvider: import("../language-provider.js").LanguageProvider;

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

@@ -0,0 +1,312 @@
+/**
+ * Swift Language Provider
+ *
+ * Assembles all Swift-specific ingestion capabilities into a single
+ * LanguageProvider, following the Strategy pattern used by the pipeline.
+ *
+ * Key Swift traits:
+ *   - importSemantics: 'wildcard-leaf' (Swift imports entire modules)
+ *   - heritageDefaultEdge: 'IMPLEMENTS' (protocols are more common than class inheritance)
+ *   - implicitImportWirer: all files in the same SPM target see each other
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
+import { swiftClassConfig } from '../class-extractors/configs/swift.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as swiftConfig } from '../type-extractors/swift.js';
+import { swiftExportChecker } from '../export-detection.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { swiftImportConfig } from '../import-resolvers/configs/swift.js';
+import { SWIFT_QUERIES } from '../tree-sitter-queries.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { swiftConfig as swiftFieldConfig } from '../field-extractors/configs/swift.js';
+import { createMethodExtractor } from '../method-extractors/generic.js';
+import { swiftMethodConfig } from '../method-extractors/configs/swift.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { swiftVariableConfig } from '../variable-extractors/configs/swift.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { swiftCallConfig } from '../call-extractors/configs/swift.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+/**
+ * Group Swift files by SPM target for implicit module visibility.
+ * If SwiftPackageConfig is available, use target -> directory mappings.
+ * Otherwise, group all Swift files under a single "default" target
+ * (assumes a single-module Xcode project).
+ */
+function groupSwiftFilesByTarget(swiftFiles, swiftPackageConfig) {
+    // No SPM config -> single target (common for Xcode projects)
+    if (!swiftPackageConfig || swiftPackageConfig.targets.size === 0) {
+        return new Map([['__default__', swiftFiles]]);
+    }
+    // Pre-convert target dirs to normalized prefix format once
+    const targets = [...swiftPackageConfig.targets.entries()].map(([name, dir]) => ({
+        name,
+        prefix: dir.replace(/\\/g, '/') + '/',
+    }));
+    const groups = new Map();
+    const defaultGroup = [];
+    for (const file of swiftFiles) {
+        const normalized = file.includes('\\') ? file.replace(/\\/g, '/') : file;
+        let assigned = false;
+        for (const { name, prefix } of targets) {
+            const idx = normalized.indexOf(prefix);
+            if (idx === 0 || (idx > 0 && normalized[idx - 1] === '/')) {
+                let group = groups.get(name);
+                if (!group) {
+                    group = [];
+                    groups.set(name, group);
+                }
+                group.push(file);
+                assigned = true;
+                break;
+            }
+        }
+        if (!assigned)
+            defaultGroup.push(file);
+    }
+    if (defaultGroup.length > 0)
+        groups.set('__default__', defaultGroup);
+    return groups;
+}
+/**
+ * Wire implicit inter-file imports for Swift.
+ * All files in the same SPM target see each other (full module visibility).
+ * Two fast paths avoid unnecessary work:
+ *   1. No existing imports for src -> emit all (m-1) edges without Set.has checks
+ *   2. Existing imports present -> skip already-connected pairs
+ */
+function wireSwiftImplicitImports(swiftFiles, importMap, addImportEdge, projectConfig) {
+    const configs = projectConfig;
+    const targetGroups = groupSwiftFilesByTarget(swiftFiles, configs?.swiftPackageConfig ?? null);
+    for (const group of targetGroups.values()) {
+        const m = group.length;
+        if (m <= 1)
+            continue;
+        // All-pairs implicit edges: O(m²) is inherent for full module visibility.
+        for (let i = 0; i < m; i++) {
+            const src = group[i];
+            const existing = importMap.get(src);
+            if (!existing || existing.size === 0) {
+                // Fast path: no prior imports — emit all peers unconditionally
+                for (let j = 0; j < m; j++) {
+                    if (i !== j)
+                        addImportEdge(src, group[j]);
+                }
+            }
+            else {
+                // Dedup path: skip already-connected pairs
+                for (let j = 0; j < m; j++) {
+                    if (i !== j && !existing.has(group[j])) {
+                        addImportEdge(src, group[j]);
+                    }
+                }
+            }
+        }
+    }
+}
+/** Swift init/deinit declarations have special names and Constructor label. */
+const swiftExtractFunctionName = (node) => {
+    if (node.type === 'init_declaration')
+        return { funcName: 'init', label: 'Constructor' };
+    if (node.type === 'deinit_declaration')
+        return { funcName: 'deinit', label: 'Constructor' };
+    return null; // fall through to generic
+};
+const orderSwiftSameNameTypeCandidates = ({ callSiteFilePath, candidates, }) => {
+    if (!callSiteFilePath.endsWith('.swift'))
+        return null;
+    if (candidates.length <= 1)
+        return null;
+    if (!candidates.every((c) => c.type === candidates[0].type))
+        return null;
+    if (candidates[0].type !== 'Class' && candidates[0].type !== 'Struct')
+        return null;
+    if (!candidates.every((c) => c.filePath.endsWith('.swift')))
+        return null;
+    return [...candidates].sort((a, b) => a.filePath.length - b.filePath.length || a.filePath.localeCompare(b.filePath));
+};
+const BUILT_INS = new Set([
+    'print',
+    'debugPrint',
+    'dump',
+    'fatalError',
+    'precondition',
+    'preconditionFailure',
+    'assert',
+    'assertionFailure',
+    'NSLog',
+    'abs',
+    'min',
+    'max',
+    'zip',
+    'stride',
+    'sequence',
+    'repeatElement',
+    'swap',
+    'withUnsafePointer',
+    'withUnsafeMutablePointer',
+    'withUnsafeBytes',
+    'autoreleasepool',
+    'unsafeBitCast',
+    'unsafeDowncast',
+    'numericCast',
+    'type',
+    'MemoryLayout',
+    'map',
+    'flatMap',
+    'compactMap',
+    'filter',
+    'reduce',
+    'forEach',
+    'contains',
+    'first',
+    'last',
+    'prefix',
+    'suffix',
+    'dropFirst',
+    'dropLast',
+    'sorted',
+    'reversed',
+    'enumerated',
+    'joined',
+    'split',
+    'append',
+    'insert',
+    'remove',
+    'removeAll',
+    'removeFirst',
+    'removeLast',
+    'isEmpty',
+    'count',
+    'index',
+    'startIndex',
+    'endIndex',
+    'addSubview',
+    'removeFromSuperview',
+    'layoutSubviews',
+    'setNeedsLayout',
+    'layoutIfNeeded',
+    'setNeedsDisplay',
+    'invalidateIntrinsicContentSize',
+    'addTarget',
+    'removeTarget',
+    'addGestureRecognizer',
+    'addConstraint',
+    'addConstraints',
+    'removeConstraint',
+    'removeConstraints',
+    'NSLocalizedString',
+    'Bundle',
+    'reloadData',
+    'reloadSections',
+    'reloadRows',
+    'performBatchUpdates',
+    'register',
+    'dequeueReusableCell',
+    'dequeueReusableSupplementaryView',
+    'beginUpdates',
+    'endUpdates',
+    'insertRows',
+    'deleteRows',
+    'insertSections',
+    'deleteSections',
+    'present',
+    'dismiss',
+    'pushViewController',
+    'popViewController',
+    'popToRootViewController',
+    'performSegue',
+    'prepare',
+    'DispatchQueue',
+    'async',
+    'sync',
+    'asyncAfter',
+    'Task',
+    'withCheckedContinuation',
+    'withCheckedThrowingContinuation',
+    'sink',
+    'store',
+    'assign',
+    'receive',
+    'subscribe',
+    'addObserver',
+    'removeObserver',
+    'post',
+    'NotificationCenter',
+]);
+export const swiftProvider = defineLanguage({
+    id: SupportedLanguages.Swift,
+    extensions: ['.swift'],
+    entryPointPatterns: [
+        /^viewDidLoad$/,
+        /^viewWillAppear$/,
+        /^viewDidAppear$/,
+        /^viewWillDisappear$/,
+        /^viewDidDisappear$/,
+        /^application\(/,
+        /^scene\(/,
+        /^body$/,
+        /Coordinator$/,
+        /^sceneDidBecomeActive$/,
+        /^sceneWillResignActive$/,
+        /^didFinishLaunchingWithOptions$/,
+        /ViewController$/,
+        /^configure[A-Z]/,
+        /^setup[A-Z]/,
+        /^makeBody$/,
+    ],
+    astFrameworkPatterns: [
+        {
+            framework: 'uikit',
+            entryPointMultiplier: 2.5,
+            reason: 'uikit-lifecycle',
+            patterns: [
+                'viewDidLoad',
+                'viewWillAppear',
+                'viewDidAppear',
+                'UIViewController',
+                '@IBOutlet',
+                '@IBAction',
+                '@objc',
+            ],
+        },
+        {
+            framework: 'swiftui',
+            entryPointMultiplier: 2.8,
+            reason: 'swiftui-pattern',
+            patterns: [
+                '@main',
+                'WindowGroup',
+                'ContentView',
+                '@StateObject',
+                '@ObservedObject',
+                '@EnvironmentObject',
+                '@Published',
+            ],
+        },
+        {
+            framework: 'vapor',
+            entryPointMultiplier: 3.0,
+            reason: 'vapor-routing',
+            patterns: ['app.get', 'app.post', 'req.content.decode', 'Vapor'],
+        },
+    ],
+    treeSitterQueries: SWIFT_QUERIES,
+    typeConfig: swiftConfig,
+    exportChecker: swiftExportChecker,
+    importResolver: createImportResolver(swiftImportConfig),
+    importSemantics: 'wildcard-leaf',
+    heritageDefaultEdge: 'IMPLEMENTS',
+    callExtractor: createCallExtractor(swiftCallConfig),
+    fieldExtractor: createFieldExtractor(swiftFieldConfig),
+    methodExtractor: createMethodExtractor({
+        ...swiftMethodConfig,
+        extractFunctionName: swiftExtractFunctionName,
+    }),
+    variableExtractor: createVariableExtractor(swiftVariableConfig),
+    classExtractor: createClassExtractor(swiftClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.Swift),
+    implicitImportWirer: wireSwiftImplicitImports,
+    orderSameNameTypeCandidates: orderSwiftSameNameTypeCandidates,
+    builtInNames: BUILT_INS,
+});

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

@@ -0,0 +1,59 @@
+/**
+ * Extract TypeScript arity metadata from a method-like tree-sitter node —
+ * `method_definition`, `method_signature`, `abstract_method_signature`,
+ * `function_declaration`, `generator_function_declaration`, or
+ * `function_signature` (overload signature).
+ *
+ * Reuses `typescriptMethodConfig.extractParameters` so scope-extracted defs
+ * carry the same arity semantics as the legacy parse-worker path:
+ *   - Rest parameters (`...args: T[]`) collapse `parameterCount` to
+ *     `undefined`, which `typescriptArityCompatibility` treats as
+ *     "max unknown" — the candidate stays eligible at
+ *     `argCount >= required` (mirrors Python `*args` / C# `params`).
+ *   - Optional (`p?: T`) and defaulted (`p: T = …`) parameters both
+ *     contribute to `optionalCount`;
+ *     `requiredParameterCount = total − optionalCount`.
+ *   - `parameterTypes` collects declared type-annotation text for
+ *     overload narrowing; TypeScript supports function overloading
+ *     (`function f(x: string); function f(x: number); function f(x) {}`),
+ *     so populated types let the registry disambiguate same-arity
+ *     siblings by declared types.
+ *   - A literal `'params'` marker is appended for variadic methods so
+ *     `typescriptArityCompatibility` can detect rest params without
+ *     re-reading the AST.
+ *
+ * ## Generics stripping
+ *
+ * TypeScript parameter types frequently contain generic instantiations
+ * (`User<string>`, `Array<User>`, `Promise<User[]>`). For overload
+ * narrowing by declared type, we want the "head" name — `User`,
+ * `Array`, `Promise` — so `arity-metadata` applies a light strip to
+ * each `parameterTypes[i]`:
+ *
+ *   - `Foo<Bar>`          → `Foo`
+ *   - `Foo<Bar, Baz>`     → `Foo`
+ *   - `Foo[]`             → `Foo`
+ *   - `Foo<Bar>[]`        → `Foo`
+ *   - `Foo<Bar<Baz>>`     → `Foo`   (greedy — strip the outermost once)
+ *   - plain `Foo`         → `Foo`
+ *
+ * We do NOT strip unions / intersections at this layer — those stay
+ * intact because the registry's overload narrowing is a string
+ * equality check; union types shouldn't match anything and we prefer
+ * "unknown" to "accidental match". `undefined` / `null` in unions
+ * (TS strict mode) is handled by `interpret.ts`'s `stripNullableUnion`
+ * when the name would be consumed as a receiver type — that path is
+ * separate from this arity-metadata path.
+ *
+ * Generic type parameters on the function itself (`function f<T>(x: T)`)
+ * do NOT enter here — the method extractor reads the `parameters`
+ * field only, which contains value parameters, not type parameters.
+ */
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+interface TsArityMetadata {
+    readonly parameterCount: number | undefined;
+    readonly requiredParameterCount: number | undefined;
+    readonly parameterTypes: readonly string[] | undefined;
+}
+export declare function computeTsArityMetadata(fnNode: SyntaxNode): TsArityMetadata;
+export {};

package/dist/core/ingestion/languages/typescript/arity-metadata.js

@@ -0,0 +1,103 @@
+/**
+ * Extract TypeScript arity metadata from a method-like tree-sitter node —
+ * `method_definition`, `method_signature`, `abstract_method_signature`,
+ * `function_declaration`, `generator_function_declaration`, or
+ * `function_signature` (overload signature).
+ *
+ * Reuses `typescriptMethodConfig.extractParameters` so scope-extracted defs
+ * carry the same arity semantics as the legacy parse-worker path:
+ *   - Rest parameters (`...args: T[]`) collapse `parameterCount` to
+ *     `undefined`, which `typescriptArityCompatibility` treats as
+ *     "max unknown" — the candidate stays eligible at
+ *     `argCount >= required` (mirrors Python `*args` / C# `params`).
+ *   - Optional (`p?: T`) and defaulted (`p: T = …`) parameters both
+ *     contribute to `optionalCount`;
+ *     `requiredParameterCount = total − optionalCount`.
+ *   - `parameterTypes` collects declared type-annotation text for
+ *     overload narrowing; TypeScript supports function overloading
+ *     (`function f(x: string); function f(x: number); function f(x) {}`),
+ *     so populated types let the registry disambiguate same-arity
+ *     siblings by declared types.
+ *   - A literal `'params'` marker is appended for variadic methods so
+ *     `typescriptArityCompatibility` can detect rest params without
+ *     re-reading the AST.
+ *
+ * ## Generics stripping
+ *
+ * TypeScript parameter types frequently contain generic instantiations
+ * (`User<string>`, `Array<User>`, `Promise<User[]>`). For overload
+ * narrowing by declared type, we want the "head" name — `User`,
+ * `Array`, `Promise` — so `arity-metadata` applies a light strip to
+ * each `parameterTypes[i]`:
+ *
+ *   - `Foo<Bar>`          → `Foo`
+ *   - `Foo<Bar, Baz>`     → `Foo`
+ *   - `Foo[]`             → `Foo`
+ *   - `Foo<Bar>[]`        → `Foo`
+ *   - `Foo<Bar<Baz>>`     → `Foo`   (greedy — strip the outermost once)
+ *   - plain `Foo`         → `Foo`
+ *
+ * We do NOT strip unions / intersections at this layer — those stay
+ * intact because the registry's overload narrowing is a string
+ * equality check; union types shouldn't match anything and we prefer
+ * "unknown" to "accidental match". `undefined` / `null` in unions
+ * (TS strict mode) is handled by `interpret.ts`'s `stripNullableUnion`
+ * when the name would be consumed as a receiver type — that path is
+ * separate from this arity-metadata path.
+ *
+ * Generic type parameters on the function itself (`function f<T>(x: T)`)
+ * do NOT enter here — the method extractor reads the `parameters`
+ * field only, which contains value parameters, not type parameters.
+ */
+import { typescriptMethodConfig } from '../../method-extractors/configs/typescript-javascript.js';
+export function computeTsArityMetadata(fnNode) {
+    const params = typescriptMethodConfig.extractParameters?.(fnNode) ?? [];
+    let hasRest = false;
+    let optionalCount = 0;
+    const types = [];
+    for (const p of params) {
+        if (p.isVariadic)
+            hasRest = true;
+        else if (p.isOptional)
+            optionalCount++;
+        const t = p.type !== null && p.type !== undefined ? stripGenericsAndArraySuffix(p.type) : '';
+        types.push(t);
+    }
+    if (hasRest)
+        types.push('params');
+    const total = params.length;
+    const parameterCount = hasRest ? undefined : total;
+    const requiredParameterCount = hasRest ? undefined : total - optionalCount;
+    // Only emit parameterTypes when at least one param carries a non-
+    // empty type name. An array of all empty strings adds noise to the
+    // registry without aiding narrowing — callers treat absence as
+    // "types unknown".
+    const hasAnyType = types.some((t) => t !== '' && t !== 'params');
+    const parameterTypes = hasAnyType || hasRest ? (types.length > 0 ? types : undefined) : undefined;
+    return {
+        parameterCount,
+        requiredParameterCount,
+        parameterTypes,
+    };
+}
+/**
+ * Light generic + array-suffix strip used only for registry overload
+ * narrowing. See file-level JSDoc for the exact transformation table.
+ *
+ * Handles nesting greedily at the outermost level:
+ *   `Foo<Bar<Baz>>[]` — strip `[]` → `Foo<Bar<Baz>>`, then strip
+ *   outermost `<>` → `Foo`.
+ */
+function stripGenericsAndArraySuffix(raw) {
+    let t = raw.trim();
+    // Repeatedly peel trailing `[]` pairs, then peel the outermost `<…>`
+    // block once. We don't loop the `<>` peel since nesting is rare and
+    // the head name is already reached after one peel.
+    while (t.endsWith('[]'))
+        t = t.slice(0, -2).trim();
+    const lt = t.indexOf('<');
+    if (lt > 0 && t.endsWith('>')) {
+        t = t.slice(0, lt).trim();
+    }
+    return t;
+}