Use swift build --show-bin-path to compute paths (#1831)

plemarquand · web-flow · commit 2a3ba9ff8a2b · 2025-09-16T09:24:48.000-04:00
* Use `swift build --show-bin-path` to compute paths Several paths are hard coded to use the `debug` folder inside `.build`. While this works for the native build system, the swiftbuild build system stores build artifacts in a different set of folders. Use `--show-bin-path` to determine where `swift build` is going to put the binaries and rely on that instead of hard coding. Ensure that any additional user arguments that affect the bin path are passed to the command so the true bin path is calculated. Issue: #1830
diff --git a/src/SwiftSnippets.ts b/src/SwiftSnippets.ts
@@ -98,7 +98,7 @@ export async function debugSnippetWithOptions(
         },
         folderContext.toolchain
     );
-    const snippetDebugConfig = createSnippetConfiguration(snippetName, folderContext);
+    const snippetDebugConfig = await createSnippetConfiguration(snippetName, folderContext);
     try {
         ctx.buildStarted(snippetName, snippetDebugConfig, options);
 
diff --git a/src/WorkspaceContext.ts b/src/WorkspaceContext.ts
@@ -32,6 +32,7 @@ import { DocCDocumentationRequest, ReIndexProjectRequest } from "./sourcekit-lsp
 import { SwiftPluginTaskProvider } from "./tasks/SwiftPluginTaskProvider";
 import { SwiftTaskProvider } from "./tasks/SwiftTaskProvider";
 import { TaskManager } from "./tasks/TaskManager";
+import { BuildFlags } from "./toolchain/BuildFlags";
 import { SwiftToolchain } from "./toolchain/toolchain";
 import { StatusItem } from "./ui/StatusItem";
 import { SwiftBuildStatus } from "./ui/SwiftBuildStatus";
@@ -103,6 +104,17 @@ export class WorkspaceContext implements vscode.Disposable {
         this.commentCompletionProvider = new CommentCompletionProviders();
 
         const onChangeConfig = vscode.workspace.onDidChangeConfiguration(async event => {
+            // Clear build path cache when build-related configurations change
+            if (
+                event.affectsConfiguration("swift.buildArguments") ||
+                event.affectsConfiguration("swift.buildPath") ||
+                event.affectsConfiguration("swift.sdk") ||
+                event.affectsConfiguration("swift.swiftSDK")
+            ) {
+                // Clear the build path cache since configuration affects paths
+                BuildFlags.clearBuildPathCache();
+            }
+
             // on runtime path config change, regenerate launch.json
             if (event.affectsConfiguration("swift.runtimePath")) {
                 if (!(await this.needToAutoGenerateLaunchConfig())) {
@@ -122,14 +134,20 @@ export class WorkspaceContext implements vscode.Disposable {
                         }
                     });
             }
-            // on change of swift build path, regenerate launch.json
-            if (event.affectsConfiguration("swift.buildPath")) {
+            // on change of swift build path or build arguments, regenerate launch.json
+            if (
+                event.affectsConfiguration("swift.buildPath") ||
+                event.affectsConfiguration("swift.buildArguments")
+            ) {
                 if (!(await this.needToAutoGenerateLaunchConfig())) {
                     return;
                 }
+                const configType = event.affectsConfiguration("swift.buildPath")
+                    ? "build path"
+                    : "build arguments";
                 void vscode.window
                     .showInformationMessage(
-                        `Launch configurations need to be updated after changing the Swift build path. Do you want to update?`,
+                        `Launch configurations need to be updated after changing the Swift ${configType}. Do you want to update?`,
                         "Update",
                         "Cancel"
                     )
diff --git a/src/commands/build.ts b/src/commands/build.ts
@@ -107,7 +107,7 @@ export async function debugBuildWithOptions(
         return;
     }
 
-    const launchConfig = getLaunchConfiguration(target.name, current);
+    const launchConfig = await getLaunchConfiguration(target.name, current);
     if (launchConfig) {
         ctx.buildStarted(target.name, launchConfig, options);
         const result = await debugLaunchConfig(
diff --git a/src/debugger/launch.ts b/src/debugger/launch.ts
@@ -121,26 +121,44 @@ export async function makeDebugConfigurations(
 }
 
 // Return debug launch configuration for an executable in the given folder
-export function getLaunchConfiguration(
+export async function getLaunchConfiguration(
     target: string,
     folderCtx: FolderContext
-): vscode.DebugConfiguration | undefined {
+): Promise<vscode.DebugConfiguration | undefined> {
     const wsLaunchSection = vscode.workspace.workspaceFile
         ? vscode.workspace.getConfiguration("launch")
         : vscode.workspace.getConfiguration("launch", folderCtx.workspaceFolder);
     const launchConfigs = wsLaunchSection.get<vscode.DebugConfiguration[]>("configurations") || [];
     const { folder } = getFolderAndNameSuffix(folderCtx);
-    const targetPath = path.join(
-        BuildFlags.buildDirectoryFromWorkspacePath(folder, true),
-        "debug",
-        target
-    );
-    // Users could be on different platforms with different path annotations,
-    // so normalize before we compare.
-    const launchConfig = launchConfigs.find(
-        config => path.normalize(config.program) === path.normalize(targetPath)
-    );
-    return launchConfig;
+
+    try {
+        // Use dynamic path resolution with --show-bin-path
+        const binPath = await folderCtx.toolchain.buildFlags.getBuildBinaryPath(
+            folderCtx.folder.fsPath,
+            folder,
+            "debug",
+            folderCtx.workspaceContext.logger
+        );
+        const targetPath = path.join(binPath, target);
+
+        // Users could be on different platforms with different path annotations,
+        // so normalize before we compare.
+        const launchConfig = launchConfigs.find(
+            config => path.normalize(config.program) === path.normalize(targetPath)
+        );
+        return launchConfig;
+    } catch (error) {
+        // Fallback to traditional path construction if dynamic resolution fails
+        const targetPath = path.join(
+            BuildFlags.buildDirectoryFromWorkspacePath(folder, true),
+            "debug",
+            target
+        );
+        const launchConfig = launchConfigs.find(
+            config => path.normalize(config.program) === path.normalize(targetPath)
+        );
+        return launchConfig;
+    }
 }
 
 // Return array of DebugConfigurations for executables based on what is in Package.swift
@@ -152,30 +170,73 @@ async function createExecutableConfigurations(
     // Windows understand the forward slashes, so make the configuration unified as posix path
     // to make it easier for users switching between platforms.
     const { folder, nameSuffix } = getFolderAndNameSuffix(ctx, undefined, "posix");
-    const buildDirectory = BuildFlags.buildDirectoryFromWorkspacePath(folder, true, "posix");
 
-    return executableProducts.flatMap(product => {
-        const baseConfig = {
-            type: SWIFT_LAUNCH_CONFIG_TYPE,
-            request: "launch",
-            args: [],
-            cwd: folder,
-        };
-        return [
-            {
-                ...baseConfig,
-                name: `Debug ${product.name}${nameSuffix}`,
-                program: path.posix.join(buildDirectory, "debug", product.name),
-                preLaunchTask: `swift: Build Debug ${product.name}${nameSuffix}`,
-            },
-            {
-                ...baseConfig,
-                name: `Release ${product.name}${nameSuffix}`,
-                program: path.posix.join(buildDirectory, "release", product.name),
-                preLaunchTask: `swift: Build Release ${product.name}${nameSuffix}`,
-            },
-        ];
-    });
+    try {
+        // Get dynamic build paths for both debug and release configurations
+        const [debugBinPath, releaseBinPath] = await Promise.all([
+            ctx.toolchain.buildFlags.getBuildBinaryPath(
+                ctx.folder.fsPath,
+                folder,
+                "debug",
+                ctx.workspaceContext.logger
+            ),
+            ctx.toolchain.buildFlags.getBuildBinaryPath(
+                ctx.folder.fsPath,
+                folder,
+                "release",
+                ctx.workspaceContext.logger
+            ),
+        ]);
+
+        return executableProducts.flatMap(product => {
+            const baseConfig = {
+                type: SWIFT_LAUNCH_CONFIG_TYPE,
+                request: "launch",
+                args: [],
+                cwd: folder,
+            };
+            return [
+                {
+                    ...baseConfig,
+                    name: `Debug ${product.name}${nameSuffix}`,
+                    program: path.posix.join(debugBinPath, product.name),
+                    preLaunchTask: `swift: Build Debug ${product.name}${nameSuffix}`,
+                },
+                {
+                    ...baseConfig,
+                    name: `Release ${product.name}${nameSuffix}`,
+                    program: path.posix.join(releaseBinPath, product.name),
+                    preLaunchTask: `swift: Build Release ${product.name}${nameSuffix}`,
+                },
+            ];
+        });
+    } catch (error) {
+        // Fallback to traditional path construction if dynamic resolution fails
+        const buildDirectory = BuildFlags.buildDirectoryFromWorkspacePath(folder, true, "posix");
+
+        return executableProducts.flatMap(product => {
+            const baseConfig = {
+                type: SWIFT_LAUNCH_CONFIG_TYPE,
+                request: "launch",
+                args: [],
+                cwd: folder,
+            };
+            return [
+                {
+                    ...baseConfig,
+                    name: `Debug ${product.name}${nameSuffix}`,
+                    program: path.posix.join(buildDirectory, "debug", product.name),
+                    preLaunchTask: `swift: Build Debug ${product.name}${nameSuffix}`,
+                },
+                {
+                    ...baseConfig,
+                    name: `Release ${product.name}${nameSuffix}`,
+                    program: path.posix.join(buildDirectory, "release", product.name),
+                    preLaunchTask: `swift: Build Release ${product.name}${nameSuffix}`,
+                },
+            ];
+        });
+    }
 }
 
 /**
@@ -184,22 +245,44 @@ async function createExecutableConfigurations(
  * @param ctx Folder context for project
  * @returns Debug configuration for running Swift Snippet
  */
-export function createSnippetConfiguration(
+export async function createSnippetConfiguration(
     snippetName: string,
     ctx: FolderContext
-): vscode.DebugConfiguration {
+): Promise<vscode.DebugConfiguration> {
     const { folder } = getFolderAndNameSuffix(ctx);
-    const buildDirectory = BuildFlags.buildDirectoryFromWorkspacePath(folder, true);
-
-    return {
-        type: SWIFT_LAUNCH_CONFIG_TYPE,
-        request: "launch",
-        name: `Run ${snippetName}`,
-        program: path.posix.join(buildDirectory, "debug", snippetName),
-        args: [],
-        cwd: folder,
-        runType: "snippet",
-    };
+
+    try {
+        // Use dynamic path resolution with --show-bin-path
+        const binPath = await ctx.toolchain.buildFlags.getBuildBinaryPath(
+            ctx.folder.fsPath,
+            folder,
+            "debug",
+            ctx.workspaceContext.logger
+        );
+
+        return {
+            type: SWIFT_LAUNCH_CONFIG_TYPE,
+            request: "launch",
+            name: `Run ${snippetName}`,
+            program: path.posix.join(binPath, snippetName),
+            args: [],
+            cwd: folder,
+            runType: "snippet",
+        };
+    } catch (error) {
+        // Fallback to traditional path construction if dynamic resolution fails
+        const buildDirectory = BuildFlags.buildDirectoryFromWorkspacePath(folder, true);
+
+        return {
+            type: SWIFT_LAUNCH_CONFIG_TYPE,
+            request: "launch",
+            name: `Run ${snippetName}`,
+            program: path.posix.join(buildDirectory, "debug", snippetName),
+            args: [],
+            cwd: folder,
+            runType: "snippet",
+        };
+    }
 }
 
 /**
diff --git a/src/toolchain/BuildFlags.ts b/src/toolchain/BuildFlags.ts
@@ -14,6 +14,8 @@
 import * as path from "path";
 
 import configuration from "../configuration";
+import { SwiftLogger } from "../logging/SwiftLogger";
+import { execSwift } from "../utilities/utilities";
 import { Version } from "../utilities/version";
 import { DarwinCompatibleTarget, SwiftToolchain, getDarwinTargetTriple } from "./toolchain";
 
@@ -30,6 +32,8 @@ export interface ArgumentFilter {
 }
 
 export class BuildFlags {
+    private static buildPathCache = new Map<string, string>();
+
     constructor(public toolchain: SwiftToolchain) {}
 
     /**
@@ -221,6 +225,70 @@ export class BuildFlags {
         }
     }
 
+    /**
+     * Get the build binary path using swift build --show-bin-path.
+     * This respects all build configuration including buildArguments, buildSystem, etc.
+     *
+     * @param workspacePath Path to the workspace
+     * @param configuration Build configuration (debug or release)
+     * @returns Promise resolving to the build binary path
+     */
+    async getBuildBinaryPath(
+        cwd: string,
+        workspacePath: string,
+        buildConfiguration: "debug" | "release" = "debug",
+        logger: SwiftLogger
+    ): Promise<string> {
+        // Checking the bin path requires a swift process execution, so we maintain a cache.
+        // The cache key is based on workspace, configuration, and build arguments.
+        const buildArgsHash = JSON.stringify(configuration.buildArguments);
+        const cacheKey = `${workspacePath}:${buildConfiguration}:${buildArgsHash}`;
+
+        if (BuildFlags.buildPathCache.has(cacheKey)) {
+            return BuildFlags.buildPathCache.get(cacheKey)!;
+        }
+
+        // Filters down build arguments to those affecting the bin path
+        const binPathAffectingArgs = (args: string[]) =>
+            BuildFlags.filterArguments(args, [
+                { argument: "--scratch-path", include: 1 },
+                { argument: "--build-system", include: 1 },
+            ]);
+
+        const baseArgs = ["build", "--show-bin-path", "--configuration", buildConfiguration];
+        const fullArgs = [
+            ...this.withAdditionalFlags(baseArgs),
+            ...binPathAffectingArgs(configuration.buildArguments),
+        ];
+
+        try {
+            // Execute swift build --show-bin-path
+            const result = await execSwift(fullArgs, this.toolchain, { cwd });
+            const binPath = result.stdout.trim();
+
+            // Cache the result
+            BuildFlags.buildPathCache.set(cacheKey, binPath);
+            return binPath;
+        } catch (error) {
+            logger.warn(
+                `Failed to get build binary path using 'swift ${fullArgs.join(" ")}. Falling back to traditional path construction. error: ${error}`
+            );
+            // Fallback to traditional path construction if command fails
+            const fallbackPath = path.join(
+                BuildFlags.buildDirectoryFromWorkspacePath(workspacePath, true),
+                buildConfiguration
+            );
+            return fallbackPath;
+        }
+    }
+
+    /**
+     * Clear the build path cache. Should be called when build configuration changes.
+     */
+    static clearBuildPathCache(): void {
+        BuildFlags.buildPathCache.clear();
+    }
+
     withAdditionalFlags(args: string[]): string[] {
         return this.withSwiftPackageFlags(
             this.withDisableSandboxFlags(this.withSwiftSDKFlags(args))
diff --git a/test/unit-tests/toolchain/BuildFlags.test.ts b/test/unit-tests/toolchain/BuildFlags.test.ts

Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ export async function debugBuildWithOptions(`
`107`	`107`	`return;`
`108`	`108`	`}`
`109`	`109`
`110`		`- const launchConfig = getLaunchConfiguration(target.name, current);`
	`110`	`+ const launchConfig = await getLaunchConfiguration(target.name, current);`
`111`	`111`	`if (launchConfig) {`
`112`	`112`	`ctx.buildStarted(target.name, launchConfig, options);`
`113`	`113`	`const result = await debugLaunchConfig(`