gitnexus 1.6.6-rc.98 → 1.6.6

package/dist/core/ingestion/languages/swift/implicit-imports.js

@@ -0,0 +1,57 @@
+/**
+ * Swift same-module implicit IMPORTS-edge emission for the
+ * `emitImplicitImportEdges` hook.
+ *
+ * Swift gives every file in a module (an SPM target) visibility of every
+ * other file's top-level declarations WITHOUT any `import` statement
+ * (whole-module visibility). The legacy DAG models this with File→File
+ * IMPORTS edges via `wireSwiftImplicitImports`; under registry-primary
+ * that wirer's `addImportEdge` is gated off, and the scope-resolution
+ * import pipeline (`emitImportEdges`) only materializes edges from
+ * finalized `ImportEdge`s — of which there are none here, because there
+ * is no syntactic `import`. This hook emits the missing edges directly.
+ *
+ * Module identity: Swift has no in-source `package X` marker. Module
+ * membership is the SPM target *subtree* (`Sources/<Target>/…`), threaded
+ * in via the SPM target map (`resolutionConfig` → `coerceSwiftTargets`)
+ * and grouped by `groupSwiftFilesBySpmTarget` — replicating legacy
+ * `groupSwiftFilesByTarget`. With no scanned source dir the map is null
+ * and all files form one `__default__` module (single-Xcode-project
+ * assumption). Every pair of distinct `.swift` files in the same module
+ * gets a directed IMPORTS edge in both directions (whole-module
+ * visibility is symmetric).
+ *
+ * Node identity + edge construction mirror the generic `emitImportEdges`
+ * convention (`graph-bridge/imports-to-edges.ts`): `generateId('File', path)`
+ * for endpoints and `generateId('IMPORTS', key)` for the relationship id,
+ * deduped by `(sourceFile -> targetFile)`. Re-invocation idempotency comes
+ * from `graph.addRelationship` id-dedup (the same `IMPORTS` id is produced
+ * for a given ordered pair), so no local `seen` set is needed.
+ */
+import { generateId } from '../../../../lib/utils.js';
+import { coerceSwiftTargets, groupSwiftFilesBySpmTarget } from './target-grouping.js';
+export function emitSwiftImplicitImportEdges(graph, parsedFiles, _nodeLookup, resolutionConfig) {
+    // Group files by SPM target subtree (the module). No-source-dir → all
+    // files in one `__default__` bucket.
+    const targets = coerceSwiftTargets(resolutionConfig);
+    const filesByTarget = groupSwiftFilesBySpmTarget(parsedFiles, (parsed) => parsed.filePath, targets);
+    for (const [, group] of filesByTarget) {
+        if (group.length < 2)
+            continue; // no siblings to import
+        for (const source of group) {
+            for (const target of group) {
+                if (source.filePath === target.filePath)
+                    continue; // no self-import
+                const dedupKey = `${source.filePath}->${target.filePath}`;
+                graph.addRelationship({
+                    id: generateId('IMPORTS', dedupKey),
+                    sourceId: generateId('File', source.filePath),
+                    targetId: generateId('File', target.filePath),
+                    type: 'IMPORTS',
+                    confidence: 1.0,
+                    reason: 'swift-scope: implicit module visibility',
+                });
+            }
+        }
+    }
+}

package/dist/core/ingestion/languages/swift/import-decomposer.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Decompose a Swift `import_declaration` into a `CaptureMatch` carrying
+ * the synthesized markers `@import.kind` / `@import.source` /
+ * `@import.name` / `@import.testable` that `interpretSwiftImport`
+ * consumes.
+ *
+ * Swift imports are whole-module (no named members), so this is 1:1 —
+ * one `import` produces exactly one import. The split layer exposes the
+ * module name and the `@testable` flag without pushing raw-text parsing
+ * into `interpret.ts`.
+ *
+ *   import Foundation        → kind=namespace, source=Foundation
+ *   import Foo.Bar           → kind=namespace, source=Foo (SPM target),
+ *                              name=Foo.Bar (full path, for reference)
+ *   @testable import MyApp   → kind=namespace, source=MyApp, testable=1
+ *
+ * Verified against tree-sitter-swift 0.7.1:
+ *   (import_declaration
+ *     (modifiers (attribute (user_type (type_identifier))))?   ; @testable / @_exported
+ *     (identifier (simple_identifier)+))                        ; one per dotted segment
+ */
+import type { CaptureMatch } from '../../../../_shared/index.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+export declare function splitSwiftImport(stmtNode: SyntaxNode): CaptureMatch | null;

package/dist/core/ingestion/languages/swift/import-decomposer.js

@@ -0,0 +1,84 @@
+/**
+ * Decompose a Swift `import_declaration` into a `CaptureMatch` carrying
+ * the synthesized markers `@import.kind` / `@import.source` /
+ * `@import.name` / `@import.testable` that `interpretSwiftImport`
+ * consumes.
+ *
+ * Swift imports are whole-module (no named members), so this is 1:1 —
+ * one `import` produces exactly one import. The split layer exposes the
+ * module name and the `@testable` flag without pushing raw-text parsing
+ * into `interpret.ts`.
+ *
+ *   import Foundation        → kind=namespace, source=Foundation
+ *   import Foo.Bar           → kind=namespace, source=Foo (SPM target),
+ *                              name=Foo.Bar (full path, for reference)
+ *   @testable import MyApp   → kind=namespace, source=MyApp, testable=1
+ *
+ * Verified against tree-sitter-swift 0.7.1:
+ *   (import_declaration
+ *     (modifiers (attribute (user_type (type_identifier))))?   ; @testable / @_exported
+ *     (identifier (simple_identifier)+))                        ; one per dotted segment
+ */
+import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+export function splitSwiftImport(stmtNode) {
+    if (stmtNode.type !== 'import_declaration')
+        return null;
+    const spec = parseSwiftImport(stmtNode);
+    if (spec === null)
+        return null;
+    return buildImportMatch(stmtNode, spec);
+}
+function parseSwiftImport(node) {
+    let testable = false;
+    let identifierNode = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child === null)
+            continue;
+        if (child.type === 'modifiers') {
+            // Any attribute whose text mentions `testable` flips the flag.
+            if (/\btestable\b/.test(child.text))
+                testable = true;
+        }
+        else if (child.type === 'identifier') {
+            identifierNode = child;
+        }
+    }
+    if (identifierNode === null)
+        return null;
+    // The module path is one or more simple_identifier children, one per
+    // dotted segment. The SPM target is the FIRST segment.
+    const segments = [];
+    for (let i = 0; i < identifierNode.namedChildCount; i++) {
+        const seg = identifierNode.namedChild(i);
+        if (seg !== null && seg.type === 'simple_identifier')
+            segments.push(seg.text);
+    }
+    if (segments.length === 0) {
+        // Fall back to the raw identifier text (e.g. a grammar shape we didn't
+        // anticipate). Split on `.` to recover the target segment.
+        const raw = identifierNode.text.trim();
+        if (raw === '')
+            return null;
+        const parts = raw.split('.');
+        return { source: parts[0], fullPath: raw, testable, atNode: node };
+    }
+    return {
+        source: segments[0],
+        fullPath: segments.join('.'),
+        testable,
+        atNode: node,
+    };
+}
+function buildImportMatch(stmtNode, spec) {
+    const m = {
+        '@import.statement': nodeToCapture('@import.statement', stmtNode),
+        '@import.kind': syntheticCapture('@import.kind', spec.atNode, 'namespace'),
+        '@import.source': syntheticCapture('@import.source', spec.atNode, spec.source),
+        '@import.name': syntheticCapture('@import.name', spec.atNode, spec.fullPath),
+    };
+    if (spec.testable) {
+        m['@import.testable'] = syntheticCapture('@import.testable', spec.atNode, '1');
+    }
+    return m;
+}

package/dist/core/ingestion/languages/swift/import-target.d.ts

@@ -0,0 +1,33 @@
+/**
+ * `resolveImportTarget` adapter for the Swift `ScopeResolver`.
+ *
+ * Swift's `import ModuleName` brings in a whole SPM target / framework
+ * module. The scope-resolution contract passes only `allFilePaths` (no
+ * `SwiftPackageConfig`), so we resolve a module name to the `.swift`
+ * files under a directory segment named after the module — the SPM
+ * convention `Sources/<Module>/*.swift` (and the common
+ * `<Module>/*.swift` layout). This needs no manifest parsing.
+ *
+ * Same-module (intra-target) visibility — the bulk of Swift cross-file
+ * resolution, which needs NO `import` statement — is handled separately
+ * by `populateSwiftTargetSiblings` (see `target-siblings.ts`). This
+ * adapter only resolves EXPLICIT `import` statements (cross-module).
+ *
+ * Returns all matching files (one ImportEdge per file, like Go's
+ * package resolver) so every exported symbol in the module materializes
+ * a binding. Returns `null` for external frameworks (Foundation, UIKit,
+ * …) that have no in-repo directory.
+ *
+ * Performance: the directory→files grouping is memoized on the stable
+ * `allFilePaths` Set identity (the same Set is threaded to every import
+ * in a run), so it is built once per run — NOT once per import. Mirrors
+ * Python's `getPythonFileIndex` WeakMap pattern (PR #1918).
+ */
+import type { ParsedImport, WorkspaceIndex } from '../../../../_shared/index.js';
+export interface SwiftResolveContext {
+    readonly fromFile: string;
+    /** `ReadonlySet` so the orchestrator's stable run-level set flows
+     *  straight through to the memoized index key. */
+    readonly allFilePaths: ReadonlySet<string>;
+}
+export declare function resolveSwiftImportTarget(parsedImport: ParsedImport, workspaceIndex: WorkspaceIndex): string | readonly string[] | null;

package/dist/core/ingestion/languages/swift/import-target.js

@@ -0,0 +1,81 @@
+/**
+ * `resolveImportTarget` adapter for the Swift `ScopeResolver`.
+ *
+ * Swift's `import ModuleName` brings in a whole SPM target / framework
+ * module. The scope-resolution contract passes only `allFilePaths` (no
+ * `SwiftPackageConfig`), so we resolve a module name to the `.swift`
+ * files under a directory segment named after the module — the SPM
+ * convention `Sources/<Module>/*.swift` (and the common
+ * `<Module>/*.swift` layout). This needs no manifest parsing.
+ *
+ * Same-module (intra-target) visibility — the bulk of Swift cross-file
+ * resolution, which needs NO `import` statement — is handled separately
+ * by `populateSwiftTargetSiblings` (see `target-siblings.ts`). This
+ * adapter only resolves EXPLICIT `import` statements (cross-module).
+ *
+ * Returns all matching files (one ImportEdge per file, like Go's
+ * package resolver) so every exported symbol in the module materializes
+ * a binding. Returns `null` for external frameworks (Foundation, UIKit,
+ * …) that have no in-repo directory.
+ *
+ * Performance: the directory→files grouping is memoized on the stable
+ * `allFilePaths` Set identity (the same Set is threaded to every import
+ * in a run), so it is built once per run — NOT once per import. Mirrors
+ * Python's `getPythonFileIndex` WeakMap pattern (PR #1918).
+ */
+const SWIFT_MODULE_INDEX_CACHE = new WeakMap();
+function getSwiftModuleIndex(allFilePaths) {
+    const cached = SWIFT_MODULE_INDEX_CACHE.get(allFilePaths);
+    if (cached !== undefined)
+        return cached;
+    const byModule = new Map();
+    for (const raw of allFilePaths) {
+        const norm = raw.replace(/\\/g, '/');
+        if (!norm.endsWith('.swift'))
+            continue;
+        // Each interior directory segment is a candidate module name. A file
+        // `Sources/Models/User.swift` is attributed to module `Sources` and
+        // module `Models`; an `import Models` then resolves to it.
+        const segments = norm.split('/');
+        // Drop the filename (last segment); the rest are directory segments.
+        for (let i = 0; i < segments.length - 1; i++) {
+            const seg = segments[i];
+            if (seg === '')
+                continue;
+            let bucket = byModule.get(seg);
+            if (bucket === undefined) {
+                bucket = [];
+                byModule.set(seg, bucket);
+            }
+            bucket.push(raw);
+        }
+    }
+    const index = { byModule };
+    SWIFT_MODULE_INDEX_CACHE.set(allFilePaths, index);
+    return index;
+}
+export function resolveSwiftImportTarget(parsedImport, workspaceIndex) {
+    const ctx = workspaceIndex;
+    // Duck-type the set (PR #1918 P2: don't `instanceof Set`).
+    const allFilePaths = ctx?.allFilePaths;
+    if (ctx === undefined ||
+        typeof ctx.fromFile !== 'string' ||
+        typeof allFilePaths?.has !== 'function' ||
+        typeof allFilePaths?.[Symbol.iterator] !== 'function') {
+        return null;
+    }
+    // Swift import target is the SPM module name (first dotted segment).
+    const targetRaw = parsedImport.targetRaw;
+    if (targetRaw === null || targetRaw === '')
+        return null;
+    const moduleName = targetRaw.split('.')[0];
+    if (moduleName === '')
+        return null;
+    const index = getSwiftModuleIndex(ctx.allFilePaths);
+    const files = index.byModule.get(moduleName);
+    if (files === undefined || files.length === 0)
+        return null; // external framework
+    // Exclude the importer itself (a file under `Foo/` importing `Foo`).
+    const out = files.filter((f) => f !== ctx.fromFile);
+    return out.length > 0 ? out : null;
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Swift scope-resolution hooks (RFC #909 Ring 3, issue #937 — the final
+ * per-language migration).
+ *
+ * Public API barrel. Consumers import from this file rather than the
+ * individual modules.
+ *
+ * Module layout (each file is a single concern):
+ *
+ *   - `query.ts`             — tree-sitter query + lazy parser/query singletons
+ *   - `captures.ts`          — `emitSwiftScopeCaptures` orchestrator
+ *   - `import-decomposer.ts` — each `import` → ParsedImport-shaped captures
+ *   - `interpret.ts`         — capture-match → `ParsedImport` / `ParsedTypeBinding`
+ *   - `simple-hooks.ts`      — small/no-op hooks made explicit
+ *   - `receiver-binding.ts`  — synthesize `self` / `super` type-bindings
+ *   - `merge-bindings.ts`    — Swift import-vs-local precedence
+ *   - `arity.ts`             — Swift arity compatibility (count-primary)
+ *   - `arity-metadata.ts`    — synthesize arity metadata from declarations
+ *   - `import-target.ts`     — `(ParsedImport, WorkspaceIndex) → file path` adapter
+ *   - `target-grouping.ts`   — group same-module files by SPM target subtree
+ *   - `target-siblings.ts`   — same-SPM-target implicit cross-file visibility
+ *   - `implicit-imports.ts`  — same-SPM-target File→File IMPORTS edges
+ *   - `sibling-type-bindings.ts` — mirror sibling return-type typeBindings
+ *   - `scope-resolver.ts`    — `ScopeResolver` registered in `SCOPE_RESOLVERS`
+ *   - `cache-stats.ts`       — PROF_SCOPE_RESOLUTION cache hit/miss counters
+ */
+export { emitSwiftScopeCaptures } from './captures.js';
+export { getSwiftCaptureCacheStats, resetSwiftCaptureCacheStats } from './cache-stats.js';
+export { interpretSwiftImport, interpretSwiftTypeBinding } from './interpret.js';
+export { swiftMergeBindings } from './merge-bindings.js';
+export { swiftArityCompatibility } from './arity.js';
+export { resolveSwiftImportTarget, type SwiftResolveContext } from './import-target.js';
+export { groupSwiftFilesBySpmTarget, coerceSwiftTargets } from './target-grouping.js';
+export { populateSwiftTargetSiblings } from './target-siblings.js';
+export { emitSwiftImplicitImportEdges } from './implicit-imports.js';
+export { mirrorSwiftSiblingTypeBindings } from './sibling-type-bindings.js';
+export { swiftBindingScopeFor, swiftImportOwningScope, swiftReceiverBinding, } from './simple-hooks.js';

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

@@ -0,0 +1,37 @@
+/**
+ * Swift scope-resolution hooks (RFC #909 Ring 3, issue #937 — the final
+ * per-language migration).
+ *
+ * Public API barrel. Consumers import from this file rather than the
+ * individual modules.
+ *
+ * Module layout (each file is a single concern):
+ *
+ *   - `query.ts`             — tree-sitter query + lazy parser/query singletons
+ *   - `captures.ts`          — `emitSwiftScopeCaptures` orchestrator
+ *   - `import-decomposer.ts` — each `import` → ParsedImport-shaped captures
+ *   - `interpret.ts`         — capture-match → `ParsedImport` / `ParsedTypeBinding`
+ *   - `simple-hooks.ts`      — small/no-op hooks made explicit
+ *   - `receiver-binding.ts`  — synthesize `self` / `super` type-bindings
+ *   - `merge-bindings.ts`    — Swift import-vs-local precedence
+ *   - `arity.ts`             — Swift arity compatibility (count-primary)
+ *   - `arity-metadata.ts`    — synthesize arity metadata from declarations
+ *   - `import-target.ts`     — `(ParsedImport, WorkspaceIndex) → file path` adapter
+ *   - `target-grouping.ts`   — group same-module files by SPM target subtree
+ *   - `target-siblings.ts`   — same-SPM-target implicit cross-file visibility
+ *   - `implicit-imports.ts`  — same-SPM-target File→File IMPORTS edges
+ *   - `sibling-type-bindings.ts` — mirror sibling return-type typeBindings
+ *   - `scope-resolver.ts`    — `ScopeResolver` registered in `SCOPE_RESOLVERS`
+ *   - `cache-stats.ts`       — PROF_SCOPE_RESOLUTION cache hit/miss counters
+ */
+export { emitSwiftScopeCaptures } from './captures.js';
+export { getSwiftCaptureCacheStats, resetSwiftCaptureCacheStats } from './cache-stats.js';
+export { interpretSwiftImport, interpretSwiftTypeBinding } from './interpret.js';
+export { swiftMergeBindings } from './merge-bindings.js';
+export { swiftArityCompatibility } from './arity.js';
+export { resolveSwiftImportTarget } from './import-target.js';
+export { groupSwiftFilesBySpmTarget, coerceSwiftTargets } from './target-grouping.js';
+export { populateSwiftTargetSiblings } from './target-siblings.js';
+export { emitSwiftImplicitImportEdges } from './implicit-imports.js';
+export { mirrorSwiftSiblingTypeBindings } from './sibling-type-bindings.js';
+export { swiftBindingScopeFor, swiftImportOwningScope, swiftReceiverBinding, } from './simple-hooks.js';

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

@@ -0,0 +1,15 @@
+/**
+ * Capture-match → semantic-shape interpreters for Swift.
+ *
+ *   - `interpretSwiftImport`      → `ParsedImport`
+ *   - `interpretSwiftTypeBinding`  → `ParsedTypeBinding`
+ *
+ * Import matches arrive pre-decomposed by `emitSwiftScopeCaptures` (one
+ * import per match, with synthesized `@import.kind/source/name` markers
+ * and an optional `@import.testable` flag). Type-binding matches arrive
+ * from the raw query captures — each `@type-binding.*` anchor carries
+ * `@type-binding.name` + `@type-binding.type`.
+ */
+import type { CaptureMatch, ParsedImport, ParsedTypeBinding } from '../../../../_shared/index.js';
+export declare function interpretSwiftImport(captures: CaptureMatch): ParsedImport | null;
+export declare function interpretSwiftTypeBinding(captures: CaptureMatch): ParsedTypeBinding | null;

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

@@ -0,0 +1,89 @@
+/**
+ * Capture-match → semantic-shape interpreters for Swift.
+ *
+ *   - `interpretSwiftImport`      → `ParsedImport`
+ *   - `interpretSwiftTypeBinding`  → `ParsedTypeBinding`
+ *
+ * Import matches arrive pre-decomposed by `emitSwiftScopeCaptures` (one
+ * import per match, with synthesized `@import.kind/source/name` markers
+ * and an optional `@import.testable` flag). Type-binding matches arrive
+ * from the raw query captures — each `@type-binding.*` anchor carries
+ * `@type-binding.name` + `@type-binding.type`.
+ */
+// ─── interpretImport ──────────────────────────────────────────────────────
+export function interpretSwiftImport(captures) {
+    const sourceCap = captures['@import.source'];
+    if (sourceCap === undefined)
+        return null;
+    // Swift imports are whole-module (wildcard semantics): `import Foundation`
+    // brings the entire module into scope, no named members. The SPM target
+    // (first dotted segment) is the resolution target; the full path is kept
+    // as importedName for reference. `@testable` resolves identically to a
+    // plain import (same module is visible in test scope).
+    const source = sourceCap.text;
+    const fullPath = captures['@import.name']?.text ?? source;
+    return {
+        kind: 'namespace',
+        localName: source,
+        importedName: fullPath,
+        targetRaw: source,
+    };
+}
+// ─── interpretTypeBinding ─────────────────────────────────────────────────
+export function interpretSwiftTypeBinding(captures) {
+    const nameCap = captures['@type-binding.name'];
+    const typeCap = captures['@type-binding.type'];
+    if (nameCap === undefined || typeCap === undefined)
+        return null;
+    // Normalize so receiver-typed resolution treats these identically:
+    //   `User?` / `User!`           → User   (optional / IUO)
+    //   `[User]`                    → User   (array sugar)
+    //   `Array<User>` / `Optional<User>` → User (single-arg generic)
+    //   `Foundation.URL`            → URL    (qualifier)
+    const rawType = stripQualifier(stripGeneric(stripArraySugar(stripOptional(typeCap.text.trim()))));
+    let source = 'parameter-annotation';
+    if (captures['@type-binding.self'] !== undefined)
+        source = 'self';
+    else if (captures['@type-binding.constructor'] !== undefined)
+        source = 'constructor-inferred';
+    else if (captures['@type-binding.annotation'] !== undefined)
+        source = 'annotation';
+    else if (captures['@type-binding.alias'] !== undefined)
+        source = 'assignment-inferred';
+    else if (captures['@type-binding.return'] !== undefined)
+        source = 'return-annotation';
+    return { boundName: nameCap.text, rawTypeName: rawType, source };
+}
+/** `User?` / `User!` → `User`. */
+function stripOptional(text) {
+    if (text.endsWith('?') || text.endsWith('!'))
+        return text.slice(0, -1).trim();
+    return text;
+}
+/** `[User]` → `User` (array sugar). `[K: V]` (dictionary) is left alone —
+ *  element semantics aren't unambiguous. */
+function stripArraySugar(text) {
+    if (text.startsWith('[') && text.endsWith(']') && !text.includes(':')) {
+        return text.slice(1, -1).trim();
+    }
+    return text;
+}
+/**
+ * Unwrap a single-arg generic collection wrapper — `Array<User>`,
+ * `Optional<User>`, `Set<User>` — to its element type. Mirrors C#'s
+ * `stripGeneric`. Multi-arg generics (`Dictionary<K, V>`,
+ * `Result<T, E>`) are left alone.
+ */
+function stripGeneric(text) {
+    const single = text.match(/^(?:[A-Za-z_][A-Za-z0-9_.]*\.)?(?:Array|Optional|Set|ContiguousArray|ArraySlice)<([^,<>]+)>$/);
+    if (single !== null)
+        return single[1].trim();
+    return text;
+}
+/** `Foundation.URL` → `URL`. */
+function stripQualifier(text) {
+    const lastDot = text.lastIndexOf('.');
+    if (lastDot === -1)
+        return text;
+    return text.slice(lastDot + 1);
+}

package/dist/core/ingestion/languages/swift/merge-bindings.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Swift shadowing precedence for the `mergeBindings` hook.
+ *
+ * Tier ranking (lower wins in shadowing):
+ *
+ *   - 0: `local` — a type member, method, local var, or parameter
+ *        declared in this scope.
+ *   - 1: `import` / `namespace` / `reexport` — names brought in by an
+ *        `import ModuleName` (whole-module, including `@testable`).
+ *   - 2: `wildcard` — reserved; Swift's whole-module import already
+ *        behaves like a namespace tier, so this is rarely populated.
+ *
+ * Swift resolves an ambiguity between two imported modules by requiring
+ * an explicit `Module.Symbol` qualifier; for receiver-typed dispatch we
+ * treat all imports as one tier. Locals always shadow imports.
+ *
+ * Within a surviving tier we de-dup by `DefId`, last-write-wins.
+ */
+import type { BindingRef } from '../../../../_shared/index.js';
+export declare function swiftMergeBindings(bindings: readonly BindingRef[]): readonly BindingRef[];

package/dist/core/ingestion/languages/swift/merge-bindings.js

@@ -0,0 +1,48 @@
+/**
+ * Swift shadowing precedence for the `mergeBindings` hook.
+ *
+ * Tier ranking (lower wins in shadowing):
+ *
+ *   - 0: `local` — a type member, method, local var, or parameter
+ *        declared in this scope.
+ *   - 1: `import` / `namespace` / `reexport` — names brought in by an
+ *        `import ModuleName` (whole-module, including `@testable`).
+ *   - 2: `wildcard` — reserved; Swift's whole-module import already
+ *        behaves like a namespace tier, so this is rarely populated.
+ *
+ * Swift resolves an ambiguity between two imported modules by requiring
+ * an explicit `Module.Symbol` qualifier; for receiver-typed dispatch we
+ * treat all imports as one tier. Locals always shadow imports.
+ *
+ * Within a surviving tier we de-dup by `DefId`, last-write-wins.
+ */
+const TIER_LOCAL = 0;
+const TIER_IMPORT = 1;
+const TIER_WILDCARD = 2;
+const TIER_UNKNOWN = 3;
+function tierOf(b) {
+    switch (b.origin) {
+        case 'local':
+            return TIER_LOCAL;
+        case 'reexport':
+        case 'import':
+        case 'namespace':
+            return TIER_IMPORT;
+        case 'wildcard':
+            return TIER_WILDCARD;
+        default:
+            return TIER_UNKNOWN;
+    }
+}
+export function swiftMergeBindings(bindings) {
+    if (bindings.length === 0)
+        return bindings;
+    let bestTier = Number.POSITIVE_INFINITY;
+    for (const b of bindings)
+        bestTier = Math.min(bestTier, tierOf(b));
+    const survivors = bindings.filter((b) => tierOf(b) === bestTier);
+    const seen = new Map();
+    for (const b of survivors)
+        seen.set(b.def.nodeId, b);
+    return [...seen.values()];
+}

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

@@ -0,0 +1,46 @@
+/**
+ * Tree-sitter query for Swift scope captures (RFC §5.1).
+ *
+ * Captures the structural skeleton the generic scope-resolution
+ * pipeline consumes: scopes (module/class/function), declarations
+ * (class-likes, methods, init, properties), imports, type bindings
+ * (parameter annotations, property/field annotations, constructor
+ * inference, receiver self), and references (call sites, member calls).
+ *
+ * Swift specifics that shape this query (all verified against
+ * tree-sitter-swift 0.7.1 live s-expressions):
+ *
+ *   - `class`, `struct`, AND `extension` all parse to a single node
+ *     type `class_declaration`. They are distinguished by the `name:`
+ *     field node type: class/struct name is a bare `(type_identifier)`,
+ *     while an extension's name field wraps the extended type in a
+ *     `(user_type (type_identifier))`. The capture below grabs all
+ *     three under `@scope.class` + `@declaration.class`; the captures
+ *     orchestrator (`captures.ts`) re-tags extensions via the
+ *     user_type discriminator so extension members hoist onto the
+ *     extended type.
+ *   - `protocol_declaration` is its own node; its bodyless method
+ *     requirements are `protocol_function_declaration` (NOT
+ *     `function_declaration`).
+ *   - `init_declaration` has no `name:` field — identity is the `init`
+ *     keyword. The captures layer synthesizes its `@declaration.name`.
+ *   - Inside a `parameter`, BOTH the label and the type use the field
+ *     name `name:` — disambiguate by child node type (simple_identifier
+ *     = label, user_type = type). Parameter type bindings are therefore
+ *     synthesized in `captures.ts`, not matched here.
+ *   - A labeled call argument wraps its label in a dedicated
+ *     `value_argument_label` node.
+ *   - `self` is its own node `self_expression`; a `self.member()` call
+ *     is `call_expression > navigation_expression(target: self_expression,
+ *     suffix: navigation_suffix > simple_identifier)`.
+ *   - `import_declaration` carries the module path as an `(identifier
+ *     (simple_identifier)+)` — one `simple_identifier` per dotted
+ *     segment. `@testable` and other attributes surface as a leading
+ *     `(modifiers (attribute (user_type (type_identifier))))`.
+ *
+ * Exposes lazy `Parser` and `Query` singletons so callers don't pay
+ * tree-sitter init cost per file.
+ */
+import Parser from 'tree-sitter';
+export declare function getSwiftParser(): Parser;
+export declare function getSwiftScopeQuery(): Parser.Query;