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

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

@@ -15,17 +15,21 @@ 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;
+    const name = captures['@import.name']?.text ?? source;
+    const kindText = captures['@import.kind']?.text;
+    if (kindText === 'reexport' || kindText === 'named') {
+        return {
+            kind: kindText,
+            localName: name,
+            importedName: name,
+            targetRaw: source,
+        };
+    }
     return {
         kind: 'namespace',
         localName: source,
-        importedName: fullPath,
+        importedName: name,
         targetRaw: source,
     };
 }

package/dist/core/ingestion/languages/swift/scope-resolver.d.ts

@@ -37,14 +37,15 @@
  *      Array where Element: Equatable`) are not narrowed — the `Self`
  *      type of a protocol method resolves to the protocol, not the
  *      conforming type.
- *   2. **Cross-module `import` resolution** is still directory-segment
- *      based (`import Foo` → files under a `Foo/` dir); explicit imports do
- *      not yet consult the SPM target map (follow-up, tracked under #1935).
- *      Same-target visibility (the common case) IS SPM-target-subtree
- *      accurate — handled by sibling augmentation grouped via
- *      `groupSwiftFilesBySpmTarget`, not by explicit imports.
+ *   2. **Cross-module `import` resolution** uses a Package.swift
+ *      declaration map when one is present, otherwise the directory-segment
+ *      index minus well-known SDK module names (#2964). Same-target
+ *      visibility (the common case) is SPM-target-subtree grouping via
+ *      `groupSwiftFilesBySpmTarget`, not explicit imports.
  *   3. **Operator / subscript overloads** dispatch by name only.
- *   4. **`@_exported import` re-exports** are treated as plain imports.
+ *   4. **`@_exported import`** is `ParsedImport` `kind: 'reexport'` and
+ *      in-repo modules are closed transitively at resolve time. `public
+ *      import` is not a re-export.
  */
 import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolver.js';
 declare const swiftScopeResolver: ScopeResolver;

package/dist/core/ingestion/languages/swift/scope-resolver.js

@@ -37,14 +37,15 @@
  *      Array where Element: Equatable`) are not narrowed — the `Self`
  *      type of a protocol method resolves to the protocol, not the
  *      conforming type.
- *   2. **Cross-module `import` resolution** is still directory-segment
- *      based (`import Foo` → files under a `Foo/` dir); explicit imports do
- *      not yet consult the SPM target map (follow-up, tracked under #1935).
- *      Same-target visibility (the common case) IS SPM-target-subtree
- *      accurate — handled by sibling augmentation grouped via
- *      `groupSwiftFilesBySpmTarget`, not by explicit imports.
+ *   2. **Cross-module `import` resolution** uses a Package.swift
+ *      declaration map when one is present, otherwise the directory-segment
+ *      index minus well-known SDK module names (#2964). Same-target
+ *      visibility (the common case) is SPM-target-subtree grouping via
+ *      `groupSwiftFilesBySpmTarget`, not explicit imports.
  *   3. **Operator / subscript overloads** dispatch by name only.
- *   4. **`@_exported import` re-exports** are treated as plain imports.
+ *   4. **`@_exported import`** is `ParsedImport` `kind: 'reexport'` and
+ *      in-repo modules are closed transitively at resolve time. `public
+ *      import` is not a re-export.
  */
 import { SupportedLanguages } from '../../../../_shared/index.js';
 import { loadSwiftPackageConfig } from '../../language-config.js';
@@ -69,11 +70,17 @@ const swiftScopeResolver = {
     // the SPM target subtree, not the immediate directory. Mirrors
     // `goScopeResolver`'s `loadGoModulePath`.
     loadResolutionConfig: (repoPath) => loadSwiftPackageConfig(repoPath),
-    resolveImportTarget: (targetRaw, fromFile, allFilePaths) => {
-        const ws = { fromFile, allFilePaths };
-        return resolveSwiftImportTarget(interpretSwiftImport({
-            '@import.source': { name: '@import.source', text: targetRaw, range: ZERO_RANGE },
-        }) ?? { kind: 'namespace', localName: targetRaw, importedName: targetRaw, targetRaw }, ws);
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths, resolutionConfig, context) => {
+        const ws = {
+            fromFile,
+            allFilePaths,
+            resolutionConfig,
+            parsedFiles: context?.parsedFiles,
+        };
+        return resolveSwiftImportTarget(context?.parsedImport ??
+            interpretSwiftImport({
+                '@import.source': { name: '@import.source', text: targetRaw, range: ZERO_RANGE },
+            }) ?? { kind: 'namespace', localName: targetRaw, importedName: targetRaw, targetRaw }, ws);
     },
     // Swift shadowing: local declarations hide imports.
     mergeBindings: (existing, incoming) => [...swiftMergeBindings([...existing, ...incoming])],

package/dist/core/ingestion/languages/swift/sdk-modules.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Well-known Apple / Swift SDK module names that must not bind to a
+ * same-named in-repo folder on the no-manifest path (#2964).
+ *
+ * Modeled on `CSHARP_EXTERNAL_ROOTS`. A Package.swift target that uses
+ * one of these names still wins — this set is only the inferred/null path.
+ */
+export declare const SWIFT_SDK_MODULES: ReadonlySet<string>;
+export declare function isSwiftSdkModule(name: string): boolean;

package/dist/core/ingestion/languages/swift/sdk-modules.js

@@ -0,0 +1,28 @@
+/**
+ * Well-known Apple / Swift SDK module names that must not bind to a
+ * same-named in-repo folder on the no-manifest path (#2964).
+ *
+ * Modeled on `CSHARP_EXTERNAL_ROOTS`. A Package.swift target that uses
+ * one of these names still wins — this set is only the inferred/null path.
+ */
+export const SWIFT_SDK_MODULES = new Set([
+    'Foundation',
+    'UIKit',
+    'SwiftUI',
+    'AppKit',
+    'Combine',
+    'Dispatch',
+    'Darwin',
+    'ObjectiveC',
+    'Swift',
+    'CoreFoundation',
+    'CoreData',
+    'CoreGraphics',
+    'XCTest',
+    'Testing',
+    'Observation',
+    'os',
+]);
+export function isSwiftSdkModule(name) {
+    return SWIFT_SDK_MODULES.has(name);
+}

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

@@ -9,31 +9,26 @@
  * 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
+ * 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.
+ * Path matching is the same segment-boundary rule as import-config
+ * (`fileMatchesSwiftTargetDir`). Grouping assigns each file to the FIRST
+ * matching target; import-config fans a file out to every matching target.
  */
+export { coerceDeclaredSwiftTargets } from '../../language-config.js';
 /**
- * Group `items` by SPM target subtree, replicating legacy
- * `groupSwiftFilesByTarget` semantics exactly:
+ * Group `items` by SPM target subtree:
  *
  *   - `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).
+ *     starts with `<targetDir>/` or contains `/<targetDir>/` at a segment
+ *     boundary. Using a segment-aware suffix search matters when an earlier,
+ *     non-boundary occurrence of the same text appears in the path (#2931).
+ *   - 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).
@@ -49,3 +44,5 @@ export declare function groupSwiftFilesBySpmTarget<T>(items: readonly T[], getPa
  * `undefined`, or a config object whose `targets` is a `Map<string,string>`.
  */
 export declare function coerceSwiftTargets(resolutionConfig: unknown): ReadonlyMap<string, string> | null;
+/** Segment-boundary membership used by grouping and declared import resolve. */
+export declare function fileMatchesSwiftTargetDir(normalizedPath: string, targetDir: string): boolean;

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

@@ -9,32 +9,28 @@
  * 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
+ * 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.
+ * Path matching is the same segment-boundary rule as import-config
+ * (`fileMatchesSwiftTargetDir`). Grouping assigns each file to the FIRST
+ * matching target; import-config fans a file out to every matching target.
  */
+import { swiftDeclaredTargetPrefix } from '../../language-config.js';
+export { coerceDeclaredSwiftTargets } from '../../language-config.js';
 const DEFAULT_TARGET = '__default__';
 /**
- * Group `items` by SPM target subtree, replicating legacy
- * `groupSwiftFilesByTarget` semantics exactly:
+ * Group `items` by SPM target subtree:
  *
  *   - `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).
+ *     starts with `<targetDir>/` or contains `/<targetDir>/` at a segment
+ *     boundary. Using a segment-aware suffix search matters when an earlier,
+ *     non-boundary occurrence of the same text appears in the path (#2931).
+ *   - 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).
@@ -44,10 +40,9 @@ export function groupSwiftFilesBySpmTarget(items, getPath, targets) {
     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, '/') + '/',
+        prefix: swiftDeclaredTargetPrefix(dir),
     }));
     const groups = new Map();
     const defaultGroup = [];
@@ -56,8 +51,7 @@ export function groupSwiftFilesBySpmTarget(items, getPath, targets) {
         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] === '/')) {
+            if (pathMatchesTargetPrefix(normalized, prefix)) {
                 let group = groups.get(name);
                 if (group === undefined) {
                     group = [];
@@ -91,3 +85,12 @@ export function coerceSwiftTargets(resolutionConfig) {
     }
     return null;
 }
+function pathMatchesTargetPrefix(normalizedPath, prefix) {
+    if (prefix === '')
+        return true;
+    return normalizedPath.startsWith(prefix) || normalizedPath.includes(`/${prefix}`);
+}
+/** Segment-boundary membership used by grouping and declared import resolve. */
+export function fileMatchesSwiftTargetDir(normalizedPath, targetDir) {
+    return pathMatchesTargetPrefix(normalizedPath, swiftDeclaredTargetPrefix(targetDir));
+}

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

@@ -10,10 +10,13 @@
  * 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__`,
+ * `coerceSwiftTargets`) and grouped by `groupSwiftFilesBySpmTarget`.
+ * The helper preserves the legacy `wireSwiftImplicitImports` bucketing
+ * contract for ordinary layouts (first target wins and unmatched files use
+ * `__default__`) but intentionally fixes #2931's repeated-prefix edge case.
+ * When a target map is present (declared Package.swift or inferred
+ * `Sources/*` folders), files are grouped by SPM target subtree;
+ * otherwise ALL Swift files form one module (`__default__`,
  * single-Xcode-project assumption). Every `.swift` file in the same target
  * sees its siblings' top-level defs.
  *

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

@@ -10,10 +10,13 @@
  * 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__`,
+ * `coerceSwiftTargets`) and grouped by `groupSwiftFilesBySpmTarget`.
+ * The helper preserves the legacy `wireSwiftImplicitImports` bucketing
+ * contract for ordinary layouts (first target wins and unmatched files use
+ * `__default__`) but intentionally fixes #2931's repeated-prefix edge case.
+ * When a target map is present (declared Package.swift or inferred
+ * `Sources/*` folders), files are grouped by SPM target subtree;
+ * otherwise ALL Swift files form one module (`__default__`,
  * single-Xcode-project assumption). Every `.swift` file in the same target
  * sees its siblings' top-level defs.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.13-rc.21",
+  "version": "1.6.13-rc.22",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",