gitnexus 1.6.13-rc.21 → 1.6.13-rc.22

package/dist/core/ingestion/languages/swift/implicit-imports.d.ts

@@ -14,12 +14,15 @@
  * 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 grouped by `groupSwiftFilesBySpmTarget`. The helper preserves the
+ * legacy `groupSwiftFilesByTarget` bucketing contract for ordinary layouts
+ * while intentionally fixing #2931's repeated-prefix edge case. With no
+ * target map (no Package.swift and no scanned `Sources/*`) 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).
+ * assumption). An inferred folder map must keep sibling folders isolated.
+ * 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)`

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

@@ -14,12 +14,15 @@
  * 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 grouped by `groupSwiftFilesBySpmTarget`. The helper preserves the
+ * legacy `groupSwiftFilesByTarget` bucketing contract for ordinary layouts
+ * while intentionally fixing #2931's repeated-prefix edge case. With no
+ * target map (no Package.swift and no scanned `Sources/*`) 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).
+ * assumption). An inferred folder map must keep sibling folders isolated.
+ * 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)`
@@ -31,22 +34,20 @@
 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
+            continue;
         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}`;
+            for (const dest of group) {
+                if (source.filePath === dest.filePath)
+                    continue;
+                const dedupKey = `${source.filePath}->${dest.filePath}`;
                 graph.addRelationship({
                     id: generateId('IMPORTS', dedupKey),
                     sourceId: generateId('File', source.filePath),
-                    targetId: generateId('File', target.filePath),
+                    targetId: generateId('File', dest.filePath),
                     type: 'IMPORTS',
                     confidence: 1.0,
                     reason: 'swift-scope: implicit module visibility',

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

@@ -4,20 +4,16 @@
  * `@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
+ *   import struct Foo.Bar          → kind=named, source=Foo, name=Bar
+ *   @testable import MyApp         → kind=namespace, source=MyApp, testable=1
+ *   @_exported import Foo          → kind=reexport, source=Foo, name=Foo
+ *   @_exported import struct Foo.Bar → kind=reexport, source=Foo, name=Bar
  *
- *   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-kind (`struct`/`class`/…) is not a named tree-sitter child
+ * (hidden `_import_kind` in 0.7.1). Read it from the statement text.
+ * `@_exported` / `@testable` live on `modifiers`.
  */
 import type { CaptureMatch } from '../../../../_shared/index.js';
 import { type SyntaxNode } from '../../utils/ast-helpers.js';

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

@@ -4,22 +4,19 @@
  * `@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
+ *   import struct Foo.Bar          → kind=named, source=Foo, name=Bar
+ *   @testable import MyApp         → kind=namespace, source=MyApp, testable=1
+ *   @_exported import Foo          → kind=reexport, source=Foo, name=Foo
+ *   @_exported import struct Foo.Bar → kind=reexport, source=Foo, name=Bar
  *
- *   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-kind (`struct`/`class`/…) is not a named tree-sitter child
+ * (hidden `_import_kind` in 0.7.1). Read it from the statement text.
+ * `@_exported` / `@testable` live on `modifiers`.
  */
 import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+const IMPORT_KIND_TOKEN_RE = /^(struct|class|enum|protocol|func|let|var|typealias)\b/;
 export function splitSwiftImport(stmtNode) {
     if (stmtNode.type !== 'import_declaration')
         return null;
@@ -30,15 +27,17 @@ export function splitSwiftImport(stmtNode) {
 }
 function parseSwiftImport(node) {
     let testable = false;
+    let exported = 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))
+            if (swiftModifiersHaveAttribute(child.text, 'testable'))
                 testable = true;
+            if (swiftModifiersHaveAttribute(child.text, '_exported'))
+                exported = true;
         }
         else if (child.type === 'identifier') {
             identifierNode = child;
@@ -46,8 +45,7 @@ function parseSwiftImport(node) {
     }
     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 importKind = importKindFromClause(node, identifierNode);
     const segments = [];
     for (let i = 0; i < identifierNode.namedChildCount; i++) {
         const seg = identifierNode.namedChild(i);
@@ -55,27 +53,219 @@ function parseSwiftImport(node) {
             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 };
+        segments.push(...raw.split('.'));
     }
     return {
         source: segments[0],
+        memberName: segments.length > 1 ? segments[segments.length - 1] : segments[0],
         fullPath: segments.join('.'),
         testable,
+        exported,
+        importKind,
         atNode: node,
     };
 }
+function isSwiftIdentCont(ch) {
+    return ch !== undefined && /[A-Za-z0-9_]/.test(ch);
+}
+/** First `word` outside comments and strings. Linear scan. */
+function indexOfBareWord(text, word) {
+    let inString = null;
+    let escape = false;
+    let inLineComment = false;
+    let blockCommentDepth = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        const next = text[i + 1];
+        if (inLineComment) {
+            if (ch === '\n')
+                inLineComment = false;
+            continue;
+        }
+        if (blockCommentDepth > 0) {
+            if (ch === '*' && next === '/') {
+                blockCommentDepth--;
+                i++;
+            }
+            else if (ch === '/' && next === '*') {
+                blockCommentDepth++;
+                i++;
+            }
+            continue;
+        }
+        if (inString !== null) {
+            if (escape) {
+                escape = false;
+                continue;
+            }
+            if (ch === '\\') {
+                escape = true;
+                continue;
+            }
+            if (ch === inString)
+                inString = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            inString = ch;
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            inLineComment = true;
+            i++;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            blockCommentDepth = 1;
+            i++;
+            continue;
+        }
+        if (text.startsWith(word, i) &&
+            !isSwiftIdentCont(text[i + word.length]) &&
+            (i === 0 || !isSwiftIdentCont(text[i - 1]))) {
+            return i;
+        }
+    }
+    return -1;
+}
+/** `@name` token in modifier text — not `_exported` / `testable` inside a string. */
+function swiftModifiersHaveAttribute(text, name) {
+    let inString = null;
+    let escape = false;
+    let inLineComment = false;
+    let blockCommentDepth = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        const next = text[i + 1];
+        if (inLineComment) {
+            if (ch === '\n')
+                inLineComment = false;
+            continue;
+        }
+        if (blockCommentDepth > 0) {
+            if (ch === '*' && next === '/') {
+                blockCommentDepth--;
+                i++;
+            }
+            else if (ch === '/' && next === '*') {
+                blockCommentDepth++;
+                i++;
+            }
+            continue;
+        }
+        if (inString !== null) {
+            if (escape) {
+                escape = false;
+                continue;
+            }
+            if (ch === '\\') {
+                escape = true;
+                continue;
+            }
+            if (ch === inString)
+                inString = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            inString = ch;
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            inLineComment = true;
+            i++;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            blockCommentDepth = 1;
+            i++;
+            continue;
+        }
+        if (ch !== '@')
+            continue;
+        let j = i + 1;
+        while (j < text.length && /\s/.test(text[j]))
+            j++;
+        if (text.startsWith(name, j) && !isSwiftIdentCont(text[j + name.length]))
+            return true;
+    }
+    return false;
+}
+/** Kind token from the import clause only — skip `@available(..., message: "import struct")`. */
+function importKindFromClause(node, identifierNode) {
+    const identRel = identifierNode.startIndex - node.startIndex;
+    const before = identRel >= 0 ? node.text.slice(0, identRel) : node.text;
+    const importAt = indexOfBareWord(before, 'import');
+    const clause = importAt === -1 ? before : before.slice(importAt);
+    return kindAfterImportKeyword(clause);
+}
+/** After `import`, skip whitespace and comments, then read a kind token. Linear: no nested-quantifier backtracking. */
+function kindAfterImportKeyword(clause) {
+    const start = indexOfBareWord(clause, 'import');
+    if (start === -1)
+        return null;
+    let i = start + 'import'.length;
+    let skipped = false;
+    while (i < clause.length) {
+        const ch = clause[i];
+        const next = clause[i + 1];
+        if (/\s/.test(ch)) {
+            skipped = true;
+            i += 1;
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            const nl = clause.indexOf('\n', i + 2);
+            if (nl === -1)
+                return null;
+            skipped = true;
+            i = nl + 1;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            let depth = 1;
+            i += 2;
+            while (i < clause.length && depth > 0) {
+                if (clause[i] === '/' && clause[i + 1] === '*') {
+                    depth++;
+                    i += 2;
+                }
+                else if (clause[i] === '*' && clause[i + 1] === '/') {
+                    depth--;
+                    i += 2;
+                }
+                else {
+                    i++;
+                }
+            }
+            if (depth !== 0)
+                return null;
+            skipped = true;
+            continue;
+        }
+        break;
+    }
+    if (!skipped)
+        return null;
+    return IMPORT_KIND_TOKEN_RE.exec(clause.slice(i))?.[1] ?? null;
+}
+function bindingKind(spec) {
+    if (spec.exported)
+        return 'reexport';
+    if (spec.importKind !== null && spec.fullPath.includes('.'))
+        return 'named';
+    return 'namespace';
+}
 function buildImportMatch(stmtNode, spec) {
+    const kind = bindingKind(spec);
+    const nameText = kind === 'namespace' ? spec.fullPath : spec.memberName;
     const m = {
         '@import.statement': nodeToCapture('@import.statement', stmtNode),
-        '@import.kind': syntheticCapture('@import.kind', spec.atNode, 'namespace'),
+        '@import.kind': syntheticCapture('@import.kind', spec.atNode, kind),
         '@import.source': syntheticCapture('@import.source', spec.atNode, spec.source),
-        '@import.name': syntheticCapture('@import.name', spec.atNode, spec.fullPath),
+        '@import.name': syntheticCapture('@import.name', spec.atNode, nameText),
     };
     if (spec.testable) {
         m['@import.testable'] = syntheticCapture('@import.testable', spec.atNode, '1');

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

@@ -1,33 +1,21 @@
 /**
  * `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.
+ * A Package.swift declaration map (`origin: 'package.swift'`) resolves
+ * only declared target names. Otherwise refuse well-known SDK module
+ * names and fall back to the memoized directory-segment index so local
+ * folder modules still resolve without a manifest.
  *
- * 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).
+ * Same-module visibility without `import` is `populateSwiftTargetSiblings`.
+ * This adapter only resolves EXPLICIT cross-module `import`s.
  */
-import type { ParsedImport, WorkspaceIndex } from '../../../../_shared/index.js';
+import type { ParsedFile, 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>;
+    readonly resolutionConfig?: unknown;
+    readonly parsedFiles?: readonly ParsedFile[];
 }
 export declare function resolveSwiftImportTarget(parsedImport: ParsedImport, workspaceIndex: WorkspaceIndex): string | readonly string[] | null;

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

@@ -1,40 +1,24 @@
 /**
  * `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.
+ * A Package.swift declaration map (`origin: 'package.swift'`) resolves
+ * only declared target names. Otherwise refuse well-known SDK module
+ * names and fall back to the memoized directory-segment index so local
+ * folder modules still resolve without a manifest.
  *
- * 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).
+ * Same-module visibility without `import` is `populateSwiftTargetSiblings`.
+ * This adapter only resolves EXPLICIT cross-module `import`s.
  */
 import { perFileSet } from '../../import-resolvers/per-file-set.js';
+import { coerceDeclaredSwiftTargets, swiftDeclaredTargetPrefix } from '../../language-config.js';
+import { isSwiftSdkModule } from './sdk-modules.js';
 const getSwiftModuleIndex = perFileSet((allFilePaths) => {
     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 === '')
@@ -49,9 +33,61 @@ const getSwiftModuleIndex = perFileSet((allFilePaths) => {
     }
     return { byModule };
 });
-export function resolveSwiftImportTarget(parsedImport, workspaceIndex) {
+const SWIFT_DECLARED_INDEX = new WeakMap();
+function getDeclaredFilesByName(allFilePaths, declared) {
+    const hit = SWIFT_DECLARED_INDEX.get(allFilePaths);
+    if (hit !== undefined && hit.declared === declared)
+        return hit.byName;
+    const dirs = [...declared.entries()].map(([name, dir]) => ({
+        name,
+        prefix: swiftDeclaredTargetPrefix(dir),
+    }));
+    const byName = new Map();
+    for (const { name } of dirs)
+        byName.set(name, []);
+    for (const raw of allFilePaths) {
+        const norm = raw.replace(/\\/g, '/');
+        if (!norm.endsWith('.swift'))
+            continue;
+        for (const { name, prefix } of dirs) {
+            if (!norm.startsWith(prefix) && !norm.includes(`/${prefix}`))
+                continue;
+            const bucket = byName.get(name);
+            if (bucket !== undefined)
+                bucket.push(raw);
+        }
+    }
+    const index = { declared, byName };
+    SWIFT_DECLARED_INDEX.set(allFilePaths, index);
+    return byName;
+}
+const getSwiftReexportFlag = perFileSet((parsedFiles) => {
+    for (const parsed of parsedFiles) {
+        for (const imp of parsed.parsedImports) {
+            if (imp.kind === 'reexport')
+                return { hasReexport: true };
+        }
+    }
+    return { hasReexport: false };
+});
+const getSwiftParsedByPath = perFileSet((parsedFiles) => {
+    const byPath = new Map();
+    for (const parsed of parsedFiles) {
+        byPath.set(parsed.filePath, parsed);
+    }
+    return byPath;
+});
+function excludeImporter(files, fromFile) {
+    return files.filter((f) => f !== fromFile);
+}
+function firstSwiftModuleSegment(targetRaw) {
+    if (targetRaw === '')
+        return null;
+    const moduleName = targetRaw.split('.')[0];
+    return moduleName === '' ? null : moduleName;
+}
+function narrowContext(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' ||
@@ -59,18 +95,88 @@ export function resolveSwiftImportTarget(parsedImport, workspaceIndex) {
         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];
+    return ctx;
+}
+/** Module files only — no @_exported closure. Null means external / unknown. */
+function resolveSwiftModuleFiles(moduleName, ctx) {
     if (moduleName === '')
         return null;
+    const declared = coerceDeclaredSwiftTargets(ctx.resolutionConfig);
+    if (declared !== null) {
+        if (!declared.has(moduleName))
+            return null;
+        const files = getDeclaredFilesByName(ctx.allFilePaths, declared).get(moduleName);
+        if (files === undefined)
+            return null;
+        const out = excludeImporter(files, ctx.fromFile);
+        return out.length > 0 ? out : null;
+    }
+    if (isSwiftSdkModule(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 null;
+    const out = excludeImporter(files, ctx.fromFile);
     return out.length > 0 ? out : null;
 }
+function expandSwiftReexportFiles(seed, ctx) {
+    const parsedFiles = ctx.parsedFiles;
+    if (parsedFiles === undefined || parsedFiles.length === 0)
+        return [...seed];
+    if (!getSwiftReexportFlag(parsedFiles).hasReexport)
+        return [...seed];
+    const byPath = getSwiftParsedByPath(parsedFiles);
+    const seenModules = new Set();
+    const out = new Set(seed);
+    const queue = [...seed];
+    let head = 0;
+    while (head < queue.length) {
+        const file = queue[head++];
+        const parsed = byPath.get(file);
+        if (parsed === undefined)
+            continue;
+        for (const imp of parsed.parsedImports) {
+            if (imp.kind !== 'reexport')
+                continue;
+            const targetRaw = imp.targetRaw;
+            if (targetRaw === null)
+                continue;
+            const moduleName = firstSwiftModuleSegment(targetRaw);
+            if (moduleName === null || seenModules.has(moduleName))
+                continue;
+            // `@_exported import struct Models.User` re-exports User, not Models.
+            // File-level resolve cannot attribute a member to a file, so skip
+            // the whole-module enqueue rather than painting every Models file.
+            if (imp.importedName !== moduleName)
+                continue;
+            seenModules.add(moduleName);
+            const more = resolveSwiftModuleFiles(moduleName, ctx);
+            if (more === null)
+                continue;
+            for (const next of more) {
+                if (out.has(next))
+                    continue;
+                out.add(next);
+                queue.push(next);
+            }
+        }
+    }
+    return [...out];
+}
+export function resolveSwiftImportTarget(parsedImport, workspaceIndex) {
+    const ctx = narrowContext(workspaceIndex);
+    if (ctx === null)
+        return null;
+    const targetRaw = parsedImport.targetRaw;
+    if (targetRaw === null)
+        return null;
+    const moduleName = firstSwiftModuleSegment(targetRaw);
+    if (moduleName === null)
+        return null;
+    const files = resolveSwiftModuleFiles(moduleName, ctx);
+    if (files === null)
+        return null;
+    const expanded = expandSwiftReexportFiles(files, ctx);
+    return expanded.length > 0 ? expanded : null;
+}