gitnexus 1.6.6-rc.99 → 1.6.6

package/dist/core/ingestion/languages/swift/sibling-type-bindings.js

@@ -0,0 +1,65 @@
+/**
+ * Swift same-module return-type typeBinding mirroring for the
+ * `mirrorNamespaceTypeBindings` hook.
+ *
+ * Swift gives every file in a module (an SPM target) visibility of every
+ * sibling's top-level declarations without a syntactic `import`. For a
+ * chained call like
+ *
+ *   App.swift:    let user = getUser(); user.save()   // user → getUser → ?
+ *   Models.swift: func getUser() -> User { … }        // getUser → User
+ *
+ * to resolve `user.save()` cross-file, App.swift's scope chain must be
+ * able to follow `getUser → User`. The function return-type binding
+ * (`getUser → User`) lives on Models.swift's module scope, so we mirror
+ * sibling module-scope typeBindings into the importer's module scope —
+ * the same trick Go uses (`mirrorGoNamespaceTypeBindings`), but Swift has
+ * no namespace-import edges, so 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`;
+ * no-source-dir → all files form one `__default__` module).
+ *
+ * Runs after `populateNamespaceSiblings` and before
+ * `propagateImportedReturnTypes`, so the SCC-ordered propagation pass
+ * sees the mirrored bindings and chains `user → getUser → User` to the
+ * terminal class. Each mirrored binding is chain-followed inside its
+ * source module first so we mirror the terminal type, not an intermediate
+ * intra-module reference. `Scope.typeBindings` is mutated via the
+ * sanctioned non-frozen Map cast (Contract Invariant I6).
+ */
+import { followChainPostFinalize } from '../../scope-resolution/passes/imported-return-types.js';
+import { coerceSwiftTargets, groupSwiftFilesBySpmTarget } from './target-grouping.js';
+export function mirrorSwiftSiblingTypeBindings(parsedFiles, indexes, workspaceIndex, resolutionConfig) {
+    const moduleScopeByFile = workspaceIndex.moduleScopeByFile;
+    // 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 mirror from
+        const files = group.map((parsed) => parsed.filePath);
+        for (const importerFile of files) {
+            const importerModule = moduleScopeByFile.get(importerFile);
+            if (importerModule === undefined)
+                continue;
+            for (const sourceFile of files) {
+                if (sourceFile === importerFile)
+                    continue;
+                const sourceModule = moduleScopeByFile.get(sourceFile);
+                if (sourceModule === undefined)
+                    continue;
+                for (const [name, ref] of sourceModule.typeBindings) {
+                    if (name.length === 0)
+                        continue;
+                    // A local annotation on the importer must win over a sibling's.
+                    if (importerModule.typeBindings.has(name))
+                        continue;
+                    const terminal = followChainPostFinalize(ref, sourceModule.id, indexes);
+                    importerModule.typeBindings.set(name, terminal);
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+/**
+ * Synthesize parameter-type and function return-type `@type-binding.*`
+ * captures for a Swift function-like node.
+ *
+ * Why synthesized rather than queried: Swift's tree-sitter grammar reuses
+ * the field name `name:` for the function name, each parameter's label,
+ * each parameter's type, AND the function's return type. A tree-sitter
+ * query with two `name:` fields cross-assigns those captures and produces
+ * garbage bindings (e.g. `save: save`). Reading the node via the existing
+ * `swiftMethodConfig.extractParameters` / `extractReturnType` extractors
+ * — which already handle the grammar correctly for the legacy parse path
+ * — yields the right name→type pairs. This mirrors how receiver and arity
+ * metadata are synthesized in `captures.ts` instead of queried.
+ *
+ *   - **Parameter bindings** anchor inside the function body so the
+ *     binding lands in the Function scope: `func f(u: User) { u.save() }`
+ *     → `u: User` visible in f's body.
+ *   - **Return-type binding** anchors at the function node and carries
+ *     `@type-binding.return`, which `swiftBindingScopeFor` hoists to the
+ *     Module scope so `propagateImportedReturnTypes` mirrors it across
+ *     files and callers see `let u = getUser(); u.save()`.
+ */
+import type { CaptureMatch } from '../../../../_shared/index.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+export declare function synthesizeSwiftSignatureBindings(fnNode: SyntaxNode): CaptureMatch[];

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

@@ -0,0 +1,66 @@
+/**
+ * Synthesize parameter-type and function return-type `@type-binding.*`
+ * captures for a Swift function-like node.
+ *
+ * Why synthesized rather than queried: Swift's tree-sitter grammar reuses
+ * the field name `name:` for the function name, each parameter's label,
+ * each parameter's type, AND the function's return type. A tree-sitter
+ * query with two `name:` fields cross-assigns those captures and produces
+ * garbage bindings (e.g. `save: save`). Reading the node via the existing
+ * `swiftMethodConfig.extractParameters` / `extractReturnType` extractors
+ * — which already handle the grammar correctly for the legacy parse path
+ * — yields the right name→type pairs. This mirrors how receiver and arity
+ * metadata are synthesized in `captures.ts` instead of queried.
+ *
+ *   - **Parameter bindings** anchor inside the function body so the
+ *     binding lands in the Function scope: `func f(u: User) { u.save() }`
+ *     → `u: User` visible in f's body.
+ *   - **Return-type binding** anchors at the function node and carries
+ *     `@type-binding.return`, which `swiftBindingScopeFor` hoists to the
+ *     Module scope so `propagateImportedReturnTypes` mirrors it across
+ *     files and callers see `let u = getUser(); u.save()`.
+ */
+import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+import { swiftMethodConfig } from '../../method-extractors/configs/swift.js';
+const NAMED_FUNCTION_NODE_TYPES = new Set([
+    'function_declaration',
+    'protocol_function_declaration',
+]);
+export function synthesizeSwiftSignatureBindings(fnNode) {
+    const out = [];
+    // ── Parameter bindings (anchor in the body for Function-scope landing) ──
+    const params = swiftMethodConfig.extractParameters?.(fnNode) ?? [];
+    if (params.length > 0) {
+        const bodyNode = fnNode.childForFieldName('body');
+        // Anchor params inside the body when present; for bodyless protocol
+        // requirements there is no Function scope to bind locals into, so skip.
+        if (bodyNode !== null) {
+            for (const p of params) {
+                if (p.type === null || p.name === '')
+                    continue;
+                out.push(buildBindingMatch(bodyNode, '@type-binding.parameter', p.name, p.type));
+            }
+        }
+    }
+    // ── Return-type binding (function name → return type, hoisted to Module) ──
+    // Only named functions have a name to bind; init/deinit have no return.
+    if (NAMED_FUNCTION_NODE_TYPES.has(fnNode.type)) {
+        const funcName = swiftMethodConfig.extractName?.(fnNode);
+        const returnType = swiftMethodConfig.extractReturnType?.(fnNode);
+        if (funcName !== undefined &&
+            funcName !== '' &&
+            returnType !== undefined &&
+            returnType !== '') {
+            out.push(buildBindingMatch(fnNode, '@type-binding.return', funcName, returnType));
+        }
+    }
+    return out;
+}
+function buildBindingMatch(anchorNode, sourceTag, name, typeText) {
+    const m = {
+        [sourceTag]: nodeToCapture(sourceTag, anchorNode),
+        '@type-binding.name': syntheticCapture('@type-binding.name', anchorNode, name),
+        '@type-binding.type': syntheticCapture('@type-binding.type', anchorNode, typeText),
+    };
+    return m;
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Trivial / no-op-ish hooks for the Swift provider. Kept together
+ * because each is a few lines and they share a theme: they make the
+ * provider's choice explicit rather than relying on "absence == default"
+ * so reviewers don't have to re-derive the analysis.
+ */
+import type { CaptureMatch, ParsedImport, Scope, ScopeId, ScopeTree, TypeRef } from '../../../../_shared/index.js';
+/** Swift uses the central extractor's "innermost enclosing scope" default
+ *  for most declarations: class-body declarations attach to the Class
+ *  scope, function-body locals to the Function scope.
+ *
+ *  Exception: **function return-type bindings** (`@type-binding.return`)
+ *  must hoist to the Module scope. The default auto-hoist promotes only
+ *  one level (Function → its parent). For top-level functions the parent
+ *  is already the Module so the default works, but for methods declared
+ *  inside a class/struct/extension the parent is the Class — the return
+ *  binding would get stuck there, invisible to:
+ *    - chain-follow's parent-chain walk (`let u = getUser(); u.save()`);
+ *    - cross-file `propagateImportedReturnTypes`, which reads only
+ *      `sourceModule.typeBindings`.
+ *  Walking to Module restores both. Mirrors `csharpBindingScopeFor`. */
+export declare function swiftBindingScopeFor(decl: CaptureMatch, innermost: Scope, tree: ScopeTree): ScopeId | null;
+/** Swift imports only appear at file (module) scope and bring a whole
+ *  module into view there. Attach the import to the Module scope; for any
+ *  other innermost scope delegate to the default (returns null). */
+export declare function swiftImportOwningScope(_imp: ParsedImport, innermost: Scope, _tree: ScopeTree): ScopeId | null;
+/** Look up `self` (or `super`) in the function scope's type bindings.
+ *
+ *  `self` / `super` are synthesized as type bindings on instance methods
+ *  during capture emission (`receiver-binding.ts`) — `self` for every
+ *  method inside a class/struct/extension/protocol body, and `super`
+ *  additionally for methods of a class with a declared superclass. This
+ *  hook returns a non-null `TypeRef` for instance-method bodies.
+ *
+ *  Returns `null` for static methods (no `self` synthesized), free
+ *  functions (no enclosing type), and non-Function scopes. */
+export declare function swiftReceiverBinding(functionScope: Scope): TypeRef | null;

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

@@ -0,0 +1,60 @@
+/**
+ * Trivial / no-op-ish hooks for the Swift provider. Kept together
+ * because each is a few lines and they share a theme: they make the
+ * provider's choice explicit rather than relying on "absence == default"
+ * so reviewers don't have to re-derive the analysis.
+ */
+// ─── bindingScopeFor ──────────────────────────────────────────────────────
+/** Swift uses the central extractor's "innermost enclosing scope" default
+ *  for most declarations: class-body declarations attach to the Class
+ *  scope, function-body locals to the Function scope.
+ *
+ *  Exception: **function return-type bindings** (`@type-binding.return`)
+ *  must hoist to the Module scope. The default auto-hoist promotes only
+ *  one level (Function → its parent). For top-level functions the parent
+ *  is already the Module so the default works, but for methods declared
+ *  inside a class/struct/extension the parent is the Class — the return
+ *  binding would get stuck there, invisible to:
+ *    - chain-follow's parent-chain walk (`let u = getUser(); u.save()`);
+ *    - cross-file `propagateImportedReturnTypes`, which reads only
+ *      `sourceModule.typeBindings`.
+ *  Walking to Module restores both. Mirrors `csharpBindingScopeFor`. */
+export function swiftBindingScopeFor(decl, innermost, tree) {
+    if (decl['@type-binding.return'] !== undefined) {
+        let cur = innermost;
+        while (cur !== undefined && cur.kind !== 'Module') {
+            const parentId = cur.parent ?? null;
+            if (parentId === null)
+                break;
+            cur = tree.getScope(parentId);
+        }
+        if (cur !== undefined && cur.kind === 'Module')
+            return cur.id;
+    }
+    return null;
+}
+// ─── importOwningScope ────────────────────────────────────────────────────
+/** Swift imports only appear at file (module) scope and bring a whole
+ *  module into view there. Attach the import to the Module scope; for any
+ *  other innermost scope delegate to the default (returns null). */
+export function swiftImportOwningScope(_imp, innermost, _tree) {
+    if (innermost.kind === 'Module')
+        return innermost.id;
+    return null;
+}
+// ─── receiverBinding ──────────────────────────────────────────────────────
+/** Look up `self` (or `super`) in the function scope's type bindings.
+ *
+ *  `self` / `super` are synthesized as type bindings on instance methods
+ *  during capture emission (`receiver-binding.ts`) — `self` for every
+ *  method inside a class/struct/extension/protocol body, and `super`
+ *  additionally for methods of a class with a declared superclass. This
+ *  hook returns a non-null `TypeRef` for instance-method bodies.
+ *
+ *  Returns `null` for static methods (no `self` synthesized), free
+ *  functions (no enclosing type), and non-Function scopes. */
+export function swiftReceiverBinding(functionScope) {
+    if (functionScope.kind !== 'Function')
+        return null;
+    return functionScope.typeBindings.get('self') ?? functionScope.typeBindings.get('super') ?? null;
+}

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

@@ -0,0 +1,51 @@
+/**
+ * Swift SPM-target file grouping for the registry-primary same-module
+ * hooks (`implicit-imports.ts`, `target-siblings.ts`,
+ * `sibling-type-bindings.ts`).
+ *
+ * A Swift module is an SPM *target* — a directory *subtree*
+ * (`Sources/<Target>/…`), not a single immediate directory. Grouping by
+ * the immediate containing directory (the prior `containingDir` proxy)
+ * drops cross-directory same-module edges and can mis-resolve a
+ * constructor call to a wrong same-simple-named type in another target.
+ *
+ * This module duplicates the legacy `groupSwiftFilesByTarget`
+ * (`languages/swift.ts`) semantics **verbatim** so the registry-primary
+ * path matches legacy SPM-subtree grouping without touching the legacy
+ * pipeline (hard constraint: legacy stays byte-identical). The SPM target
+ * map is threaded in via the `resolutionConfig` channel
+ * (`loadSwiftPackageConfig` → `resolutionConfig` → these hooks); see
+ * `scope-resolver.ts` and `scope-resolution/pipeline/run.ts`.
+ *
+ * NOTE: This intentionally differs from the import-config module's
+ * leading-`startsWith` (`import-resolvers/configs/swift.ts`): that module
+ * fans a file out to EVERY matching target (a nested file can belong to
+ * multiple configured target dirs there), whereas legacy module grouping
+ * assigns each file to the FIRST matching target only (legacy `break`s) —
+ * one bucket per file. Do not copy the import-config behavior here.
+ */
+/**
+ * Group `items` by SPM target subtree, replicating legacy
+ * `groupSwiftFilesByTarget` semantics exactly:
+ *
+ *   - `targets` null/empty (no scanned source dir found) → ALL items go to
+ *     a single `__default__` bucket (single-Xcode-project assumption).
+ *   - Otherwise: a file matches a target when its normalized path either
+ *     starts with `<targetDir>/` (`indexOf === 0`) OR contains it at a `/`
+ *     boundary (`norm[idx - 1] === '/'`). Each file is assigned to the
+ *     FIRST matching target only (one bucket per file, no fan-out).
+ *   - Files matching no target fall into the `__default__` bucket.
+ *
+ * `targets` is `name → directory` (the `SwiftPackageConfig.targets` map).
+ */
+export declare function groupSwiftFilesBySpmTarget<T>(items: readonly T[], getPath: (item: T) => string, targets: ReadonlyMap<string, string> | null): Map<string, T[]>;
+/**
+ * Duck-type the opaque `resolutionConfig` (loaded by
+ * `loadSwiftPackageConfig` and threaded through the orchestrator) into the
+ * SPM `targets` map, or `null` when no Swift package config is present.
+ *
+ * Uses structural duck-typing (no `instanceof`) because the value crosses
+ * the `unknown`-typed `resolutionConfig` channel and may be `null`,
+ * `undefined`, or a config object whose `targets` is a `Map<string,string>`.
+ */
+export declare function coerceSwiftTargets(resolutionConfig: unknown): ReadonlyMap<string, string> | null;

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

@@ -0,0 +1,93 @@
+/**
+ * Swift SPM-target file grouping for the registry-primary same-module
+ * hooks (`implicit-imports.ts`, `target-siblings.ts`,
+ * `sibling-type-bindings.ts`).
+ *
+ * A Swift module is an SPM *target* — a directory *subtree*
+ * (`Sources/<Target>/…`), not a single immediate directory. Grouping by
+ * the immediate containing directory (the prior `containingDir` proxy)
+ * drops cross-directory same-module edges and can mis-resolve a
+ * constructor call to a wrong same-simple-named type in another target.
+ *
+ * This module duplicates the legacy `groupSwiftFilesByTarget`
+ * (`languages/swift.ts`) semantics **verbatim** so the registry-primary
+ * path matches legacy SPM-subtree grouping without touching the legacy
+ * pipeline (hard constraint: legacy stays byte-identical). The SPM target
+ * map is threaded in via the `resolutionConfig` channel
+ * (`loadSwiftPackageConfig` → `resolutionConfig` → these hooks); see
+ * `scope-resolver.ts` and `scope-resolution/pipeline/run.ts`.
+ *
+ * NOTE: This intentionally differs from the import-config module's
+ * leading-`startsWith` (`import-resolvers/configs/swift.ts`): that module
+ * fans a file out to EVERY matching target (a nested file can belong to
+ * multiple configured target dirs there), whereas legacy module grouping
+ * assigns each file to the FIRST matching target only (legacy `break`s) —
+ * one bucket per file. Do not copy the import-config behavior here.
+ */
+const DEFAULT_TARGET = '__default__';
+/**
+ * Group `items` by SPM target subtree, replicating legacy
+ * `groupSwiftFilesByTarget` semantics exactly:
+ *
+ *   - `targets` null/empty (no scanned source dir found) → ALL items go to
+ *     a single `__default__` bucket (single-Xcode-project assumption).
+ *   - Otherwise: a file matches a target when its normalized path either
+ *     starts with `<targetDir>/` (`indexOf === 0`) OR contains it at a `/`
+ *     boundary (`norm[idx - 1] === '/'`). Each file is assigned to the
+ *     FIRST matching target only (one bucket per file, no fan-out).
+ *   - Files matching no target fall into the `__default__` bucket.
+ *
+ * `targets` is `name → directory` (the `SwiftPackageConfig.targets` map).
+ */
+export function groupSwiftFilesBySpmTarget(items, getPath, targets) {
+    // No SPM config -> single target (common for Xcode projects).
+    if (targets === null || targets.size === 0) {
+        return new Map([[DEFAULT_TARGET, [...items]]]);
+    }
+    // Pre-convert target dirs to normalized prefix format once.
+    const targetPrefixes = [...targets.entries()].map(([name, dir]) => ({
+        name,
+        prefix: dir.replace(/\\/g, '/') + '/',
+    }));
+    const groups = new Map();
+    const defaultGroup = [];
+    for (const item of items) {
+        const rawPath = getPath(item);
+        const normalized = rawPath.includes('\\') ? rawPath.replace(/\\/g, '/') : rawPath;
+        let assigned = false;
+        for (const { name, prefix } of targetPrefixes) {
+            const idx = normalized.indexOf(prefix);
+            if (idx === 0 || (idx > 0 && normalized[idx - 1] === '/')) {
+                let group = groups.get(name);
+                if (group === undefined) {
+                    group = [];
+                    groups.set(name, group);
+                }
+                group.push(item);
+                assigned = true;
+                break; // FIRST match only — one bucket per file, no fan-out.
+            }
+        }
+        if (!assigned)
+            defaultGroup.push(item);
+    }
+    if (defaultGroup.length > 0)
+        groups.set(DEFAULT_TARGET, defaultGroup);
+    return groups;
+}
+/**
+ * Duck-type the opaque `resolutionConfig` (loaded by
+ * `loadSwiftPackageConfig` and threaded through the orchestrator) into the
+ * SPM `targets` map, or `null` when no Swift package config is present.
+ *
+ * Uses structural duck-typing (no `instanceof`) because the value crosses
+ * the `unknown`-typed `resolutionConfig` channel and may be `null`,
+ * `undefined`, or a config object whose `targets` is a `Map<string,string>`.
+ */
+export function coerceSwiftTargets(resolutionConfig) {
+    const config = resolutionConfig;
+    if (config != null && config.targets instanceof Map) {
+        return config.targets;
+    }
+    return null;
+}

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

@@ -0,0 +1,30 @@
+/**
+ * Swift same-module (SPM target) implicit visibility for the
+ * `populateNamespaceSiblings` hook.
+ *
+ * Swift gives every file in a module access to every other file's
+ * top-level declarations WITHOUT any `import` statement (whole-module
+ * visibility). This is the Swift analogue of Go's same-package sibling
+ * visibility — `populateGoPackageSiblings` is the template.
+ *
+ * Module identity: Swift has no in-source `package X` marker. The SPM
+ * target is a directory subtree (`Sources/<Target>/…`). Module membership
+ * is threaded in via the SPM target map (`ctx.resolutionConfig` →
+ * `coerceSwiftTargets`) and grouped by `groupSwiftFilesBySpmTarget`,
+ * replicating legacy `wireSwiftImplicitImports`'s `groupSwiftFilesByTarget`:
+ * files are grouped by SPM target subtree when a package config is present,
+ * else ALL Swift files form one module (`__default__`,
+ * single-Xcode-project assumption). Every `.swift` file in the same target
+ * sees its siblings' top-level defs.
+ *
+ * Bindings are added through the append-only `bindingAugmentations`
+ * channel (Contract Invariant I8) with `origin: 'namespace'`, exactly
+ * like the Go implementation — `indexes.bindings` is frozen post-
+ * finalize and must not be mutated.
+ */
+import type { ParsedFile } from '../../../../_shared/index.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+export declare function populateSwiftTargetSiblings(parsedFiles: readonly ParsedFile[], indexes: ScopeResolutionIndexes, ctx: {
+    readonly fileContents: ReadonlyMap<string, string>;
+    readonly resolutionConfig?: unknown;
+}): void;

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

@@ -0,0 +1,71 @@
+/**
+ * Swift same-module (SPM target) implicit visibility for the
+ * `populateNamespaceSiblings` hook.
+ *
+ * Swift gives every file in a module access to every other file's
+ * top-level declarations WITHOUT any `import` statement (whole-module
+ * visibility). This is the Swift analogue of Go's same-package sibling
+ * visibility — `populateGoPackageSiblings` is the template.
+ *
+ * Module identity: Swift has no in-source `package X` marker. The SPM
+ * target is a directory subtree (`Sources/<Target>/…`). Module membership
+ * is threaded in via the SPM target map (`ctx.resolutionConfig` →
+ * `coerceSwiftTargets`) and grouped by `groupSwiftFilesBySpmTarget`,
+ * replicating legacy `wireSwiftImplicitImports`'s `groupSwiftFilesByTarget`:
+ * files are grouped by SPM target subtree when a package config is present,
+ * else ALL Swift files form one module (`__default__`,
+ * single-Xcode-project assumption). Every `.swift` file in the same target
+ * sees its siblings' top-level defs.
+ *
+ * Bindings are added through the append-only `bindingAugmentations`
+ * channel (Contract Invariant I8) with `origin: 'namespace'`, exactly
+ * like the Go implementation — `indexes.bindings` is frozen post-
+ * finalize and must not be mutated.
+ */
+import { coerceSwiftTargets, groupSwiftFilesBySpmTarget } from './target-grouping.js';
+export function populateSwiftTargetSiblings(parsedFiles, indexes, ctx) {
+    // Group files by SPM target subtree (the module). No-source-dir → all
+    // files in one `__default__` bucket.
+    const targets = coerceSwiftTargets(ctx.resolutionConfig);
+    const filesByTarget = groupSwiftFilesBySpmTarget(parsedFiles, (parsed) => parsed.filePath, targets);
+    const augmentations = indexes.bindingAugmentations;
+    for (const [, group] of filesByTarget) {
+        if (group.length < 2)
+            continue; // no siblings to share
+        const siblings = group.map((parsed) => ({
+            filePath: parsed.filePath,
+            defs: [...parsed.localDefs],
+        }));
+        for (const target of siblings) {
+            for (const receiver of siblings) {
+                if (receiver.filePath === target.filePath)
+                    continue; // no self-reference
+                const receiverModule = indexes.moduleScopes.byFilePath.get(receiver.filePath);
+                if (receiverModule === undefined)
+                    continue;
+                for (const def of target.defs) {
+                    const name = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+                    if (name === '')
+                        continue;
+                    const bucket = getAugmentationBucket(augmentations, receiverModule, name);
+                    if (bucket.some((b) => b.def.nodeId === def.nodeId))
+                        continue;
+                    bucket.push({ def, origin: 'namespace' });
+                }
+            }
+        }
+    }
+}
+function getAugmentationBucket(augmentations, scopeId, name) {
+    let scopeBindings = augmentations.get(scopeId);
+    if (scopeBindings === undefined) {
+        scopeBindings = new Map();
+        augmentations.set(scopeId, scopeBindings);
+    }
+    let bucketArr = scopeBindings.get(name);
+    if (bucketArr === undefined) {
+        bucketArr = [];
+        scopeBindings.set(name, bucketArr);
+    }
+    return bucketArr;
+}

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

@@ -3,10 +3,5 @@
  *
  * 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

@@ -3,11 +3,6 @@
  *
  * 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';
@@ -26,84 +21,7 @@ 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]);
-                    }
-                }
-            }
-        }
-    }
-}
+import { emitSwiftScopeCaptures, interpretSwiftImport, interpretSwiftTypeBinding, swiftBindingScopeFor, swiftImportOwningScope, swiftReceiverBinding, swiftMergeBindings, swiftArityCompatibility, } from './swift/index.js';
 /** Swift init/deinit declarations have special names and Constructor label. */
 const swiftExtractFunctionName = (node) => {
     if (node.type === 'init_declaration')
@@ -295,8 +213,6 @@ export const swiftProvider = defineLanguage({
     typeConfig: swiftConfig,
     exportChecker: swiftExportChecker,
     importResolver: createImportResolver(swiftImportConfig),
-    importSemantics: 'wildcard-leaf',
-    heritageDefaultEdge: 'IMPLEMENTS',
     callExtractor: createCallExtractor(swiftCallConfig),
     fieldExtractor: createFieldExtractor(swiftFieldConfig),
     methodExtractor: createMethodExtractor({
@@ -305,8 +221,16 @@ export const swiftProvider = defineLanguage({
     }),
     variableExtractor: createVariableExtractor(swiftVariableConfig),
     classExtractor: createClassExtractor(swiftClassConfig),
-    heritageExtractor: createHeritageExtractor(SupportedLanguages.Swift),
-    implicitImportWirer: wireSwiftImplicitImports,
     orderSameNameTypeCandidates: orderSwiftSameNameTypeCandidates,
     builtInNames: BUILT_INS,
+    // ── Scope-based resolution hooks (RFC #909 Ring 3, issue #937). See
+    //    languages/swift/ for the implementations. ──────────────────────
+    emitScopeCaptures: emitSwiftScopeCaptures,
+    interpretImport: interpretSwiftImport,
+    interpretTypeBinding: interpretSwiftTypeBinding,
+    bindingScopeFor: swiftBindingScopeFor,
+    importOwningScope: swiftImportOwningScope,
+    receiverBinding: swiftReceiverBinding,
+    mergeBindings: (_scope, bindings) => swiftMergeBindings(bindings),
+    arityCompatibility: swiftArityCompatibility,
 });