cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/rust/receiver-binding.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synthesizeRustReceiverBinding = synthesizeRustReceiverBinding;
+exports.getImplTargetType = getImplTargetType;
+exports.getImplTraitName = getImplTraitName;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+/**
+ * Given a function_item node that is inside an impl_item, synthesize a
+ * self-type-binding capture if the function has a `self_parameter`.
+ *
+ * The impl_item structure:
+ *   impl [TraitName for] TypeName { fn method(&self) { ... } }
+ */
+function synthesizeRustReceiverBinding(fnNode, implNode) {
+    if (fnNode.type !== 'function_item')
+        return null;
+    if (implNode === null)
+        return null;
+    const params = fnNode.childForFieldName('parameters');
+    if (params === null)
+        return null;
+    let hasSelf = false;
+    for (let i = 0; i < params.namedChildCount; i++) {
+        if (params.namedChild(i)?.type === 'self_parameter') {
+            hasSelf = true;
+            break;
+        }
+    }
+    if (!hasSelf)
+        return null;
+    const implType = getImplTargetType(implNode);
+    if (implType === null)
+        return null;
+    return {
+        '@type-binding.self': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.self', fnNode, 'self'),
+        '@type-binding.name': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.name', fnNode, 'self'),
+        '@type-binding.type': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.type', fnNode, implType),
+    };
+}
+/**
+ * Extract the target type from an impl_item.
+ * `impl TypeName { ... }` → "TypeName"
+ * `impl TraitName for TypeName { ... }` → "TypeName"
+ */
+function getImplTargetType(implNode) {
+    if (implNode.type !== 'impl_item')
+        return null;
+    // Look for `for` keyword — if present, impl is `impl Trait for Type`
+    let hasFor = false;
+    let typeAfterFor = null;
+    for (let i = 0; i < implNode.childCount; i++) {
+        const child = implNode.child(i);
+        if (child === null)
+            continue;
+        if (child.type === 'for') {
+            hasFor = true;
+            continue;
+        }
+        if (hasFor && child.type === 'type_identifier') {
+            typeAfterFor = child;
+            break;
+        }
+        if (hasFor && child.type === 'scoped_type_identifier') {
+            typeAfterFor = child;
+            break;
+        }
+        if (hasFor && child.type === 'generic_type') {
+            typeAfterFor = child;
+            break;
+        }
+    }
+    if (hasFor && typeAfterFor !== null) {
+        return normalizeRustTypeName(typeAfterFor.text);
+    }
+    // No `for` keyword: impl TypeName { ... }
+    const typeField = implNode.childForFieldName('type');
+    if (typeField !== null) {
+        return normalizeRustTypeName(typeField.text);
+    }
+    // Fallback: find first type_identifier after `impl`
+    let afterImpl = false;
+    for (let i = 0; i < implNode.childCount; i++) {
+        const child = implNode.child(i);
+        if (child === null)
+            continue;
+        if (child.type === 'impl') {
+            afterImpl = true;
+            continue;
+        }
+        if (afterImpl && (child.type === 'type_identifier' || child.type === 'generic_type')) {
+            return normalizeRustTypeName(child.text);
+        }
+    }
+    return null;
+}
+/**
+ * Extract the trait name from an impl_item when it's `impl Trait for Type`.
+ */
+function getImplTraitName(implNode) {
+    if (implNode.type !== 'impl_item')
+        return null;
+    let afterImpl = false;
+    for (let i = 0; i < implNode.childCount; i++) {
+        const child = implNode.child(i);
+        if (child === null)
+            continue;
+        if (child.type === 'impl') {
+            afterImpl = true;
+            continue;
+        }
+        if (child.type === 'for') {
+            break;
+        }
+        if (afterImpl &&
+            (child.type === 'type_identifier' || child.type === 'scoped_type_identifier')) {
+            for (let j = i + 1; j < implNode.childCount; j++) {
+                const next = implNode.child(j);
+                if (next === null)
+                    continue;
+                if (next.type === 'for') {
+                    return normalizeRustTypeName(child.text);
+                }
+                break;
+            }
+        }
+    }
+    return null;
+}
+// NOTE: this strips reference/pointer sigils and generic arguments but NOT a
+// path qualifier, so `crate::traits::Drawable` stays qualified here — whereas
+// the inheritance synth (rust/captures.ts `bareTypeIdentifier`) resolves scoped
+// bases by their trailing simple name (`Drawable`). The two intentionally
+// diverge for scoped paths. This is inert today (`getImplTraitName` has no
+// ingestion consumer and Rust's `isSuperReceiver` is false, so nothing keys an
+// edge on this name); the synth is the single source of truth for the
+// inheritance edge. A future change that wires `getImplTraitName` into
+// resolution must reconcile this with the synth's tail-only normalization.
+function normalizeRustTypeName(text) {
+    let t = text.trim();
+    while (t.startsWith('&'))
+        t = t.replace(/^&\s*(mut\s+)?/, '');
+    while (t.startsWith('*'))
+        t = t.slice(1).trim();
+    const bracket = t.indexOf('<');
+    if (bracket !== -1)
+        t = t.slice(0, bracket);
+    return t.trim();
+}

package/dist/core/code/engine/core/ingestion/languages/rust/scope-resolver.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rustScopeResolver = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const mro_js_1 = require("../../scope-resolution/passes/mro.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+const rust_js_1 = require("../rust.js");
+const index_js_2 = require("./index.js");
+const method_owners_js_1 = require("./method-owners.js");
+const qualified_call_js_1 = require("./qualified-call.js");
+const range_binding_js_1 = require("./range-binding.js");
+const walkers_js_1 = require("../../scope-resolution/scope/walkers.js");
+const ids_js_1 = require("../../scope-resolution/graph-bridge/ids.js");
+const utils_js_1 = require("../../../../lib/utils.js");
+/**
+ * Emit Rust `S IMPLEMENTS T` edges from `impl T for S` trait implementations.
+ *
+ * Rust inheritance is not a base list on the type declaration — it lives on
+ * `impl_item { trait: T, type: S }`. The shared `preEmitInheritanceEdges` pass
+ * derives an `@reference.inherits` site's edge SOURCE from the enclosing class
+ * def, but an `impl_item` scope owns no class-like def, so that pass cannot
+ * produce these edges (it only marks the sites handled). The `@reference.inherits`
+ * sites synthesized in `captures.ts` carry the trait `T` as `site.name` (target)
+ * and the struct `S` as `site.explicitReceiver.name` (source); this hook reads
+ * them back and emits the IMPLEMENTS edge with source `S`, target `T`, and the
+ * legacy `'trait-impl'` reason — matching the legacy heritage DAG (#1951).
+ *
+ * Resolution is scope-aware and import-aware, mirroring the shared
+ * `preEmitInheritanceEdges` pass: both `S` and `T` resolve from the `impl`
+ * block's own scope via `findClassBindingInScope` (scope-chain + single-match
+ * fallbacks), then `resolveAmbiguousInheritanceBaseViaImports` for a name that
+ * several modules declare (disambiguated by the referencing file's `use`
+ * imports). A trait `T` is commonly declared in a different file (e.g. the
+ * `rust-traits` fixture imports `Drawable`/`Clickable` from a sibling module);
+ * the scope chain reaches it through those `use` bindings. When a name does
+ * not resolve to exactly one class-like def — unresolved (e.g. a std trait
+ * like `Default`) OR ambiguous across modules (two same-named `struct`s /
+ * traits) — NO edge is emitted, restoring the legacy file-scoped path's
+ * "a wrong edge is worse than no edge" invariant. (The prior global
+ * simple-name index used last-write-wins and could source an `impl` edge from
+ * the wrong same-named def across modules.) Idempotent: pre-seeds the dedup
+ * set from existing IMPLEMENTS edges so a worker-mode legacy emission (or a
+ * re-resolution) is not duplicated.
+ */
+function emitRustTraitImplEdges(graph, parsedFiles, nodeLookup, scopes) {
+    if (scopes === undefined)
+        return;
+    const emitted = new Set();
+    for (const rel of graph.iterRelationshipsByType('IMPLEMENTS')) {
+        emitted.add(`${rel.sourceId}->${rel.targetId}`);
+    }
+    for (const parsed of parsedFiles) {
+        for (const site of parsed.referenceSites) {
+            if (site.kind !== 'inherits')
+                continue;
+            const structName = site.explicitReceiver?.name;
+            const traitName = site.name;
+            if (structName === undefined || structName === '' || traitName === '')
+                continue;
+            // Scope-aware (+ import-aware) resolution from the impl block's scope.
+            // Refuse when either end is unresolved or ambiguous.
+            const structDef = (0, walkers_js_1.findClassBindingInScope)(site.inScope, structName, scopes) ??
+                (0, walkers_js_1.resolveAmbiguousInheritanceBaseViaImports)(site.inScope, structName, scopes);
+            const traitDef = (0, walkers_js_1.findClassBindingInScope)(site.inScope, traitName, scopes) ??
+                (0, walkers_js_1.resolveAmbiguousInheritanceBaseViaImports)(site.inScope, traitName, scopes);
+            if (structDef === undefined || traitDef === undefined)
+                continue;
+            const structGraphId = (0, ids_js_1.resolveDefGraphId)(structDef.filePath, structDef, nodeLookup);
+            const traitGraphId = (0, ids_js_1.resolveDefGraphId)(traitDef.filePath, traitDef, nodeLookup);
+            if (structGraphId === undefined || traitGraphId === undefined)
+                continue;
+            const edgeKey = `${structGraphId}->${traitGraphId}`;
+            if (emitted.has(edgeKey))
+                continue;
+            emitted.add(edgeKey);
+            graph.addRelationship({
+                id: (0, utils_js_1.generateId)('IMPLEMENTS', `${edgeKey}:trait-impl`),
+                sourceId: structGraphId,
+                targetId: traitGraphId,
+                type: 'IMPLEMENTS',
+                confidence: 0.85,
+                reason: 'trait-impl',
+            });
+        }
+    }
+}
+function buildRustMro(graph, parsedFiles, nodeLookup) {
+    const baseMro = (0, mro_js_1.buildMro)(graph, parsedFiles, nodeLookup, mro_js_1.defaultLinearize);
+    const defIdByGraphId = new Map();
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            if (!(0, walkers_js_1.isClassLike)(def.type))
+                continue;
+            const graphId = (0, ids_js_1.resolveDefGraphId)(parsed.filePath, def, nodeLookup);
+            if (graphId !== undefined)
+                defIdByGraphId.set(graphId, def.nodeId);
+        }
+    }
+    const fileByDefId = new Map();
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            fileByDefId.set(def.nodeId, parsed.filePath);
+        }
+    }
+    for (const rel of graph.iterRelationshipsByType('IMPLEMENTS')) {
+        const childDefId = defIdByGraphId.get(rel.sourceId);
+        const parentDefId = defIdByGraphId.get(rel.targetId);
+        if (childDefId === undefined || parentDefId === undefined)
+            continue;
+        const childFile = fileByDefId.get(childDefId);
+        const parentFile = fileByDefId.get(parentDefId);
+        if (childFile !== parentFile)
+            continue;
+        const existing = baseMro.get(childDefId);
+        if (existing !== undefined) {
+            if (!existing.includes(parentDefId))
+                existing.push(parentDefId);
+        }
+        else {
+            baseMro.set(childDefId, [parentDefId]);
+        }
+    }
+    return baseMro;
+}
+exports.rustScopeResolver = {
+    language: index_js_1.SupportedLanguages.Rust,
+    languageProvider: rust_js_1.rustProvider,
+    importEdgeReason: 'rust-scope: use',
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths, resolutionConfig) => (0, index_js_2.resolveRustImportTarget)(targetRaw, fromFile, allFilePaths, resolutionConfig),
+    mergeBindings: (existing, incoming, scopeId) => (0, index_js_2.rustMergeBindings)(existing, incoming, scopeId),
+    arityCompatibility: (callsite, def) => (0, index_js_2.rustArityCompatibility)(def, callsite),
+    resolveQualifiedFreeCall: (site, callerParsed, scopes, workspaceIndex, allFilePaths) => (0, qualified_call_js_1.resolveRustQualifiedFreeCall)(site, callerParsed, scopes, workspaceIndex, allFilePaths),
+    buildMro: (graph, parsedFiles, nodeLookup) => buildRustMro(graph, parsedFiles, nodeLookup),
+    emitHeritageEdges: (graph, parsedFiles, nodeLookup, scopes) => emitRustTraitImplEdges(graph, parsedFiles, nodeLookup, scopes),
+    populateOwners: (parsed) => (0, method_owners_js_1.populateRustOwners)(parsed),
+    isSuperReceiver: () => false,
+    // Subscript route only — Rust has no property-style collection view; `.iter()`
+    // / `.values()` are method calls the compound resolver's call branch handles.
+    //
+    // Fed the annotation AS WRITTEN (`&Vec<User>`, `HashMap<String, User>`), which
+    // `normalizeRustTypeName` had already collapsed to `User` by the time the fold
+    // saw it. Returning `undefined` is the answer "not a container" and makes the
+    // index step decline rather than fold onto the receiver's own class — an
+    // `Index`-impl type would otherwise take its own members as the element's.
+    elementTypeOf: shared_js_1.indexOnlyElementType,
+    populateRangeBindings: range_binding_js_1.populateRustRangeBindings,
+    fieldFallbackOnMethodLookup: false,
+    hoistTypeBindingsToModule: true,
+    propagatesReturnTypesAcrossImports: true,
+    allowGlobalFreeCallFallback: true,
+};

package/dist/core/code/engine/core/ingestion/languages/rust/simple-hooks.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rustBindingScopeFor = rustBindingScopeFor;
+exports.rustImportOwningScope = rustImportOwningScope;
+exports.rustReceiverBinding = rustReceiverBinding;
+function rustBindingScopeFor(decl, innermost, _tree) {
+    // Keep self typeBindings in the method's Function scope so
+    // populateRustOwners can match Method defs to their receiver types.
+    if (decl['@type-binding.self'] !== undefined) {
+        return innermost.id;
+    }
+    return null;
+}
+/**
+ * Rust `use` statements inside a function body should attach at function scope,
+ * not module scope. If the innermost scope is a Function, attach there.
+ */
+function rustImportOwningScope(_imp, innermost, _tree) {
+    if (innermost.kind === 'Function') {
+        return innermost.id;
+    }
+    return null;
+}
+function rustReceiverBinding(functionScope) {
+    if (functionScope.kind !== 'Function')
+        return null;
+    for (const binding of functionScope.typeBindings.values()) {
+        if (binding.source === 'self')
+            return binding;
+    }
+    return null;
+}

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

@@ -0,0 +1,183 @@
+"use strict";
+/**
+ * Rust Language Provider
+ *
+ * Assembles all Rust-specific ingestion capabilities into a single
+ * LanguageProvider, following the Strategy pattern used by the pipeline.
+ *
+ * Key Rust traits:
+ *   - mroStrategy: 'qualified-syntax' (Rust uses trait qualification, not MRO)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rustProvider = void 0;
+const index_js_1 = require("../../../../shared/index.js");
+const generic_js_1 = require("../class-extractors/generic.js");
+const rust_js_1 = require("../class-extractors/configs/rust.js");
+const language_provider_js_1 = require("../language-provider.js");
+const ast_helpers_js_1 = require("../utils/ast-helpers.js");
+const rust_js_2 = require("../type-extractors/rust.js");
+const export_detection_js_1 = require("../export-detection.js");
+const resolver_factory_js_1 = require("../import-resolvers/resolver-factory.js");
+const rust_js_3 = require("../import-resolvers/configs/rust.js");
+const tree_sitter_queries_js_1 = require("../tree-sitter-queries.js");
+const generic_js_2 = require("../field-extractors/generic.js");
+const rust_js_4 = require("../field-extractors/configs/rust.js");
+const generic_js_3 = require("../method-extractors/generic.js");
+const rust_js_5 = require("../method-extractors/configs/rust.js");
+const generic_js_4 = require("../variable-extractors/generic.js");
+const rust_js_6 = require("../variable-extractors/configs/rust.js");
+const generic_js_5 = require("../call-extractors/generic.js");
+const rust_js_7 = require("../call-extractors/configs/rust.js");
+const rust_js_8 = require("../cfg/visitors/rust.js");
+const index_js_2 = require("./rust/index.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',
+]);
+exports.rustProvider = (0, language_provider_js_1.defineLanguage)({
+    id: index_js_1.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: tree_sitter_queries_js_1.RUST_QUERIES,
+    typeConfig: rust_js_2.typeConfig,
+    exportChecker: export_detection_js_1.rustExportChecker,
+    importResolver: (0, resolver_factory_js_1.createImportResolver)(rust_js_3.rustImportConfig),
+    mroStrategy: 'qualified-syntax',
+    callExtractor: (0, generic_js_5.createCallExtractor)(rust_js_7.rustCallConfig),
+    fieldExtractor: (0, generic_js_2.createFieldExtractor)(rust_js_4.rustConfig),
+    methodExtractor: (0, generic_js_3.createMethodExtractor)({
+        ...rust_js_5.rustMethodConfig,
+        extractFunctionName: rustExtractFunctionName,
+    }),
+    variableExtractor: (0, generic_js_4.createVariableExtractor)(rust_js_6.rustVariableConfig),
+    classExtractor: (0, generic_js_1.createClassExtractor)(rust_js_1.rustClassConfig),
+    // ── Rust outer doc comments (`///`, `/** */`) → description (issue #2270).
+    //    `//!` / `/*!` are INNER docs (document the enclosing item), so they must
+    //    not attach to the following item — opt out of both. ──
+    descriptionExtractor: (0, ast_helpers_js_1.createLeadingDocDescriptionExtractor)({
+        lineCommentPrefixes: ['///'],
+        blockDocPrefixes: ['/**'],
+    }),
+    builtInNames: BUILT_INS,
+    // ── RFC #909 Ring 3: scope-based resolution hooks ──────────
+    emitScopeCaptures: index_js_2.emitRustScopeCaptures,
+    cfgVisitor: (0, rust_js_8.createRustCfgVisitor)(),
+    interpretImport: index_js_2.interpretRustImport,
+    interpretTypeBinding: index_js_2.interpretRustTypeBinding,
+    bindingScopeFor: index_js_2.rustBindingScopeFor,
+    importOwningScope: index_js_2.rustImportOwningScope,
+    receiverBinding: index_js_2.rustReceiverBinding,
+    arityCompatibility: index_js_2.rustArityCompatibility,
+});

package/dist/core/code/engine/core/ingestion/languages/swift/arity-metadata.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Extract Swift arity metadata from a function-like tree-sitter node —
+ * `function_declaration`, `protocol_function_declaration`, or
+ * `init_declaration`.
+ *
+ * Reuses `swiftMethodConfig.extractParameters` so scope-extracted defs
+ * carry the same arity semantics as the legacy parse-worker path:
+ *   - Variadic params (`xs: Int...`) collapse `parameterCount` to
+ *     `undefined`, which `swiftArityCompatibility` treats as "max
+ *     unknown" — the candidate stays eligible at `argCount >= required`.
+ *   - Defaulted params (`= expr`) contribute to `optionalCount`;
+ *     `requiredParameterCount = total − optionalCount`.
+ *   - `parameterTypes` collects declared type names for narrowing; a
+ *     literal `'variadic'` marker is appended for variadic methods so
+ *     `swiftArityCompatibility` can detect them without re-reading AST.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeSwiftArityMetadata = computeSwiftArityMetadata;
+const swift_js_1 = require("../../method-extractors/configs/swift.js");
+function computeSwiftArityMetadata(fnNode) {
+    const params = swift_js_1.swiftMethodConfig.extractParameters?.(fnNode) ?? [];
+    let hasVariadic = false;
+    let optionalCount = 0;
+    const types = [];
+    for (const p of params) {
+        if (p.isVariadic)
+            hasVariadic = true;
+        else if (p.isOptional)
+            optionalCount++;
+        if (p.type !== null)
+            types.push(p.type);
+    }
+    if (hasVariadic)
+        types.push('variadic');
+    const total = params.length;
+    const parameterCount = hasVariadic ? undefined : total;
+    const requiredParameterCount = hasVariadic ? undefined : total - optionalCount;
+    return {
+        parameterCount,
+        requiredParameterCount,
+        parameterTypes: types.length > 0 ? types : undefined,
+    };
+}

package/dist/core/code/engine/core/ingestion/languages/swift/arity.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Swift arity check, accommodating variadic and default parameters.
+ *
+ * Per the migration decision (count-primary, labels soft): we narrow on
+ * arity only. Swift's argument labels are a soft signal — a label
+ * mismatch is NOT treated as incompatible here, mirroring how the other
+ * migrated languages narrow and aligning with RFC §4 soft-penalty
+ * semantics. Label-precise dispatch is left to the registry's
+ * type-binding layer.
+ *
+ * The `def` metadata we care about (synthesized by `arity-metadata.ts`):
+ *   - `parameterCount`         — total formal parameters; `undefined`
+ *                                when the method has a variadic param.
+ *   - `requiredParameterCount` — min required (excludes defaulted params
+ *                                and the variadic).
+ *   - `parameterTypes`         — declared type strings; contains the
+ *                                literal `'variadic'` when variadic.
+ *
+ * Verdicts:
+ *   - `'compatible'`   — `requiredParameterCount <= argCount <= parameterCount`,
+ *                        OR the def is variadic (then any `argCount >= required`).
+ *   - `'incompatible'` — argCount below required, OR above max with no variadic.
+ *   - `'unknown'`      — metadata absent / incomplete.
+ *
+ * `'incompatible'` is a soft signal in `Registry.lookup` (penalized but
+ * still considered when no compatible candidate exists), per RFC §4.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swiftArityCompatibility = swiftArityCompatibility;
+function swiftArityCompatibility(def, callsite) {
+    const max = def.parameterCount;
+    const min = def.requiredParameterCount;
+    if (max === undefined && min === undefined)
+        return 'unknown';
+    const argCount = callsite.arity;
+    if (!Number.isFinite(argCount) || argCount < 0)
+        return 'unknown';
+    const hasVarArgs = def.parameterTypes !== undefined && def.parameterTypes.some((t) => t === 'variadic');
+    if (min !== undefined && argCount < min)
+        return 'incompatible';
+    if (max !== undefined && argCount > max && !hasVarArgs)
+        return 'incompatible';
+    return 'compatible';
+}

package/dist/core/code/engine/core/ingestion/languages/swift/base-type.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swiftQualifiedBaseTail = swiftQualifiedBaseTail;
+/**
+ * Trailing simple-name `type_identifier` of a Swift `user_type` base. A
+ * qualified `Outer.Inner` parses flat as
+ * `(user_type (type_identifier "Outer") (type_identifier "Inner"))`, and the
+ * actual base type is the TRAILING segment `Inner` (mirrors Java
+ * `scoped_type_identifier` → `lastNamedChild` and TS `nested_type_identifier`
+ * → tail). Generic arguments live in a sibling `type_arguments` node — never a
+ * `type_identifier` — so they are skipped: `Box<Int>` → `Box`,
+ * `Outer.Inner<T>` → `Inner`. Returns null when the `user_type` has no
+ * `type_identifier` child.
+ *
+ * Shared by `swiftBaseTypeIdentifier` (captures.ts — returns the node for an
+ * `@reference.inherits` site) and `firstInheritedType` (receiver-binding.ts —
+ * reads `.text` for `super` receiver binding). It lives in this leaf module
+ * rather than being exported from captures.ts because captures.ts already
+ * imports receiver-binding.ts, so a captures.ts export would create a
+ * bidirectional import cycle (#1956 tri-review U7).
+ */
+function swiftQualifiedBaseTail(userType) {
+    let last = null;
+    for (let i = 0; i < userType.namedChildCount; i++) {
+        const child = userType.namedChild(i);
+        if (child !== null && child.type === 'type_identifier')
+            last = child;
+    }
+    return last;
+}

package/dist/core/code/engine/core/ingestion/languages/swift/cache-stats.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Dev-mode counters for the cross-phase scope-captures parse cache
+ * (Swift mirror of `languages/csharp/cache-stats.ts`).
+ *
+ * Gated by `PROF_SCOPE_RESOLUTION=1`. Production builds fold every
+ * increment into dead code via the module-level `PROF` constant, so
+ * the hot path in `captures.ts` stays branch-free.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordCacheHit = recordCacheHit;
+exports.recordCacheMiss = recordCacheMiss;
+exports.getSwiftCaptureCacheStats = getSwiftCaptureCacheStats;
+exports.resetSwiftCaptureCacheStats = resetSwiftCaptureCacheStats;
+const PROF = process.env.PROF_SCOPE_RESOLUTION === '1';
+let CACHE_HITS = 0;
+let CACHE_MISSES = 0;
+function recordCacheHit() {
+    if (PROF)
+        CACHE_HITS++;
+}
+function recordCacheMiss() {
+    if (PROF)
+        CACHE_MISSES++;
+}
+function getSwiftCaptureCacheStats() {
+    return { hits: CACHE_HITS, misses: CACHE_MISSES };
+}
+function resetSwiftCaptureCacheStats() {
+    CACHE_HITS = 0;
+    CACHE_MISSES = 0;
+}