gitnexus 1.6.13-rc.20 → 1.6.13-rc.22

package/dist/core/ingestion/import-resolvers/configs/swift.d.ts

@@ -13,15 +13,18 @@
  * every strategy invocation, per `import-processor`'s build-once
  * context). Lookup per import is then O(1).
  *
- * Behavior is preserved bit-for-bit: a file is attributed to a target
- * iff its **forward-slash (backslash-normalized), case-sensitive** path
- * starts with `<targetDir>/`, matching the old
- * `normalizedFileList[i].startsWith(targetDir + '/')` comparison
- * (`normalizedFileList` is only backslash→forward-slash normalized — NOT
- * lowercased — so the match is case-sensitive); the returned paths are
- * the original-case `allFileList` entries; and the per-target file ORDER
- * follows `allFileList`, so the emitted `{ kind: 'files', files }` set and
- * ordering are identical to the old scan.
+ * A file is attributed to a target iff its **forward-slash
+ * (backslash-normalized), case-sensitive** path matches at a
+ * **segment boundary**: it starts with `<targetDir>/` or contains
+ * `/<targetDir>/`. `normalizedFileList` is
+ * only backslash→forward-slash normalized — NOT lowercased — so the
+ * match is case-sensitive. The returned paths are the original-case
+ * `allFileList` entries, and the per-target file ORDER follows
+ * `allFileList`.
+ *
+ * Import-config fans a file to every matching declared target. Grouping
+ * (`groupSwiftFilesBySpmTarget`) is first-target-wins. That divergence
+ * is intentional.
  */
 import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
 /** Swift Package.swift target map resolution strategy. */

package/dist/core/ingestion/import-resolvers/configs/swift.js

@@ -13,17 +13,21 @@
  * every strategy invocation, per `import-processor`'s build-once
  * context). Lookup per import is then O(1).
  *
- * Behavior is preserved bit-for-bit: a file is attributed to a target
- * iff its **forward-slash (backslash-normalized), case-sensitive** path
- * starts with `<targetDir>/`, matching the old
- * `normalizedFileList[i].startsWith(targetDir + '/')` comparison
- * (`normalizedFileList` is only backslash→forward-slash normalized — NOT
- * lowercased — so the match is case-sensitive); the returned paths are
- * the original-case `allFileList` entries; and the per-target file ORDER
- * follows `allFileList`, so the emitted `{ kind: 'files', files }` set and
- * ordering are identical to the old scan.
+ * A file is attributed to a target iff its **forward-slash
+ * (backslash-normalized), case-sensitive** path matches at a
+ * **segment boundary**: it starts with `<targetDir>/` or contains
+ * `/<targetDir>/`. `normalizedFileList` is
+ * only backslash→forward-slash normalized — NOT lowercased — so the
+ * match is case-sensitive. The returned paths are the original-case
+ * `allFileList` entries, and the per-target file ORDER follows
+ * `allFileList`.
+ *
+ * Import-config fans a file to every matching declared target. Grouping
+ * (`groupSwiftFilesBySpmTarget`) is first-target-wins. That divergence
+ * is intentional.
  */
 import { SupportedLanguages } from '../../../../_shared/index.js';
+import { coerceDeclaredSwiftTargets, swiftDeclaredTargetPrefix } from '../../language-config.js';
 /**
  * Memoized on the `allFileList` array identity. `import-processor` builds
  * the `ResolveCtx` once per run and threads the same object (and the same
@@ -54,10 +58,10 @@ function getSwiftTargetIndex(ctx, targets) {
     // Pre-compute each target's directory prefix once (original case, to
     // match the legacy comparison against the forward-slash-normalized,
     // case-sensitive file list — see module docstring).
-    const targetPrefixes = [];
+    const targetDirs = [];
     const byTarget = new Map();
     for (const [name, dir] of targets) {
-        targetPrefixes.push({ name, prefix: dir + '/' });
+        targetDirs.push({ name, prefix: swiftDeclaredTargetPrefix(dir) });
         byTarget.set(name, []);
     }
     // Single pass over the file list. `normalizedFileList` is forward-slash
@@ -70,10 +74,12 @@ function getSwiftTargetIndex(ctx, targets) {
         const norm = ctx.normalizedFileList[i];
         if (!norm.endsWith('.swift'))
             continue;
-        for (const { name, prefix } of targetPrefixes) {
-            if (norm.startsWith(prefix)) {
-                byTarget.get(name).push(ctx.allFileList[i]);
-            }
+        for (const { name, prefix } of targetDirs) {
+            if (!norm.startsWith(prefix) && !norm.includes(`/${prefix}`))
+                continue;
+            const bucket = byTarget.get(name);
+            if (bucket !== undefined)
+                bucket.push(ctx.allFileList[i]);
         }
     }
     const index = { byTarget };
@@ -83,19 +89,21 @@ function getSwiftTargetIndex(ctx, targets) {
 /** Swift Package.swift target map resolution strategy. */
 export const swiftPackageStrategy = (rawImportPath, _filePath, ctx) => {
     const swiftPackageConfig = ctx.configs.swiftPackageConfig;
-    if (swiftPackageConfig) {
-        // Only the targets map is needed; build the index lazily so repos
-        // without a Package.swift config pay nothing.
-        if (swiftPackageConfig.targets.has(rawImportPath)) {
-            const index = getSwiftTargetIndex(ctx, swiftPackageConfig.targets);
-            const files = index.byTarget.get(rawImportPath);
-            if (files !== undefined && files.length > 0) {
-                // Copy so callers can't mutate the cached index bucket.
-                return { kind: 'files', files: [...files] };
-            }
-        }
+    if (swiftPackageConfig == null)
+        return null;
+    const declared = coerceDeclaredSwiftTargets(swiftPackageConfig);
+    if (declared == null)
+        return null;
+    const moduleName = rawImportPath.split('.')[0];
+    if (moduleName === '' || !declared.has(moduleName)) {
+        return null;
+    }
+    const index = getSwiftTargetIndex(ctx, declared);
+    const files = index.byTarget.get(moduleName);
+    if (files !== undefined && files.length > 0) {
+        return { kind: 'files', files: [...files] };
     }
-    return null; // External framework (Foundation, UIKit, etc.)
+    return null;
 };
 export const swiftImportConfig = {
     language: SupportedLanguages.Swift,

package/dist/core/ingestion/language-config.d.ts

@@ -64,10 +64,37 @@ export interface CSharpProjectScan {
  *  Keeps the field mapping in one place so the two carriers can't drift. */
 export declare function csharpScanToEvidence(scan: CSharpProjectScan): CSharpNamespaceEvidence;
 /** Swift Package Manager module config */
+export type SwiftPackageConfigOrigin = 'package.swift' | 'directories';
 export interface SwiftPackageConfig {
     /** Map of target name -> source directory path (e.g., "SiuperModel" -> "Package/Sources/SiuperModel") */
     targets: Map<string, string>;
+    /**
+     * `package.swift` — extracted from a readable Package.swift with no
+     * completeness hazards. Explicit import resolve may treat this as a
+     * declaration map (empty means every name is external).
+     * `directories` — inferred from `Sources/*` (or Package/Sources / src)
+     * when no usable declaration exists. Grouping uses this; import resolve
+     * must not.
+     * Omitted on hand-built test configs: treated as a declaration map so
+     * existing `{ targets }` fixtures stay valid.
+     */
+    origin?: SwiftPackageConfigOrigin;
+    /**
+     * Declaration map when `origin` is `package.swift` (may be empty).
+     * Grouping uses `targets`, which is this map when it is non-empty and the
+     * inferred `Sources/*` map when the declaration is empty — so a
+     * binary-only Package.swift does not collapse every file into `__default__`.
+     */
+    declaredTargets?: Map<string, string>;
 }
+/**
+ * Declaration view for explicit import resolve. `origin: 'directories'`
+ * is grouping-only. A hand-built `{ targets }` with no origin stays a
+ * declaration so existing fixtures keep working.
+ */
+export declare function coerceDeclaredSwiftTargets(resolutionConfig: unknown): ReadonlyMap<string, string> | null;
+/** Segment-boundary prefix for a Package.swift `path:`. `"."` / `"./"` is the package root. */
+export declare function swiftDeclaredTargetPrefix(dir: string): string;
 /** Zig package config parsed from build.zig.zon and the root build.zig */
 export interface ZigBuildZonConfig {
     /**
@@ -185,6 +212,11 @@ export declare function loadComposerConfig(repoRoot: string): Promise<ComposerCo
  * windows (see below); directories are still visited breadth-first.
  */
 export declare function scanCSharpProject(repoRoot: string): Promise<CSharpProjectScan>;
+/** Heuristic Package.swift scan. Never shells out to `swift package dump-package`. */
+export declare function parseSwiftPackageManifest(source: string): {
+    targets: Map<string, string>;
+    complete: boolean;
+};
 export declare function loadSwiftPackageConfig(repoRoot: string): Promise<SwiftPackageConfig | null>;
 /**
  * Load the Zig build configuration a repo's `build.zig.zon` + root `build.zig`