detect xcrun shims

Author: matthewbastien

package.json

@@ -492,7 +492,7 @@
           "swift.path": {
             "type": "string",
             "default": "",
-            "markdownDescription": "Override the default path of the folder containing the Swift executables. The default is to look in the `PATH` environment variable. This path is also used to search for other executables used by the extension like `sourcekit-lsp` and `lldb`.",
+            "markdownDescription": "Override the default path of the folder containing the Swift executables. The default is to look in the `PATH` environment variable.",
             "scope": "machine-overridable"
           },
           "swift.buildArguments": {

src/debugger/lldb.ts

@@ -52,10 +52,13 @@ export async function getLLDBLibPath(toolchain: SwiftToolchain): Promise<Result<
     } catch (error) {
         return Result.makeFailure(error);
     }
-    let pathHint = path.dirname(toolchain.swiftFolderPath);
+    let pathHint = toolchain.toolchainPath;
     try {
-        const statement = `print('<!' + lldb.SBHostOS.GetLLDBPath(lldb.ePathTypeLLDBShlibDir).fullpath + '!>')`;
-        const args = ["-b", "-O", `script ${statement}`];
+        const args = [
+            "-b",
+            "-O",
+            `script print('<!' + lldb.SBHostOS.GetLLDBPath(lldb.ePathTypeLLDBShlibDir).fullpath + '!>')`,
+        ];
         const { stdout } = await execFile(executable, args);
         const m = /^<!([^!]*)!>/m.exec(stdout);
         if (m) {
@@ -65,7 +68,7 @@ export async function getLLDBLibPath(toolchain: SwiftToolchain): Promise<Result<
         // If we get an error on Windows here we should not attempt to use the fallback path. If it failed
         // it is most likely due to lldb failing to run because $PYHTONHOME environment variable is setup
         // incorrectly (this is the case in Swift < 5.7). In this situation swift lldb does not work so we
-        // should just the version of lldb that comes with CodeLLDB. We return a failure with no message
+        // should just use the version of lldb that comes with CodeLLDB. We return a failure with no message
         // to indicate we want it to fail silently.
         if (process.platform === "win32") {
             return Result.makeFailure(undefined);
@@ -79,7 +82,7 @@ export async function getLLDBLibPath(toolchain: SwiftToolchain): Promise<Result<
     }
 }
 
-export async function findLibLLDB(pathHint: string): Promise<string | undefined> {
+async function findLibLLDB(pathHint: string): Promise<string | undefined> {
     const stat = await fs.stat(pathHint);
     if (stat.isFile()) {
         return pathHint;
@@ -109,7 +112,7 @@ export async function findLibLLDB(pathHint: string): Promise<string | undefined>
     return undefined;
 }
 
-export async function findFileByPattern(path: string, pattern: RegExp): Promise<string | null> {
+async function findFileByPattern(path: string, pattern: RegExp): Promise<string | null> {
     try {
         const files = await fs.readdir(path);
         for (const file of files) {

src/toolchain/swiftly.ts

@@ -27,7 +27,7 @@ import { ContextKeys } from "../contextKeys";
 import { SwiftLogger } from "../logging/SwiftLogger";
 import { showMissingToolchainDialog } from "../ui/ToolchainSelection";
 import { touch } from "../utilities/filesystem";
-import { findBinaryPath } from "../utilities/shell";
+import { findBinaryInPath } from "../utilities/shell";
 import { ExecFileError, execFile, execFileStreamOutput } from "../utilities/utilities";
 import { Version } from "../utilities/version";
 import { SwiftlyConfig } from "./ToolchainVersion";
@@ -359,72 +359,49 @@ export class Swiftly {
     }
 
     /**
-     * Determine if Swiftly is being used to manage the active toolchain and if so, return
-     * the path to the active toolchain.
+     * Determine whether or not the given swift binary is managed by swiftly.
      *
-     * @returns The location of the active toolchain if swiftly is being used to manage it.
+     * @param swiftBinaryPath The path to the swift binary.
+     * @returns A boolean indicating whether or not the swift binary is managed by swiftly.
      */
-    public static async toolchain(
-        extensionRoot: string,
-        logger?: SwiftLogger,
-        cwd?: vscode.Uri
-    ): Promise<string | undefined> {
+    public static async isManagedBySwiftly(swiftBinaryPath: string): Promise<boolean> {
         const swiftlyHomeDir: string | undefined = process.env["SWIFTLY_HOME_DIR"];
-        if (swiftlyHomeDir) {
-            const { stdout: swiftLocation } = await execFile("which", ["swift"]);
-            if (swiftLocation.startsWith(swiftlyHomeDir)) {
-                // Print the location of the toolchain that swiftly is using. If there
-                // is no cwd specified then it returns the global "inUse" toolchain otherwise
-                // it respects the .swift-version file in the cwd and resolves using that.
-                try {
-                    const inUse = await Swiftly.inUseLocation("swiftly", cwd);
-                    if (inUse.length > 0) {
-                        return path.join(inUse, "usr");
-                    }
-                } catch (err: unknown) {
-                    logger?.error(`Failed to retrieve Swiftly installations: ${err}`);
-                    const error = err as ExecFileError;
-
-                    // Check if this is a missing toolchain error
-                    const missingToolchainError = parseSwiftlyMissingToolchainError(error.stderr);
-                    if (missingToolchainError) {
-                        // Attempt automatic installation
-                        const installed = await handleMissingSwiftlyToolchain(
-                            missingToolchainError.version,
-                            extensionRoot,
-                            logger,
-                            cwd
-                        );
-
-                        if (installed) {
-                            // Retry toolchain location after successful installation
-                            try {
-                                const retryInUse = await Swiftly.inUseLocation("swiftly", cwd);
-                                if (retryInUse.length > 0) {
-                                    return path.join(retryInUse, "usr");
-                                }
-                            } catch (retryError) {
-                                logger?.error(
-                                    `Failed to use toolchain after installation: ${retryError}`
-                                );
-                            }
-                        } else {
-                            // User declined installation - gracefully fall back to global toolchain
-                            logger?.info(
-                                `Falling back to global toolchain after user declined installation of missing toolchain: ${missingToolchainError.version}`
-                            );
-                            return undefined;
-                        }
-                    }
+        if (!swiftlyHomeDir) {
+            return false;
+        }
+        return swiftBinaryPath.startsWith(swiftlyHomeDir);
+    }
 
-                    // Fall back to original error handling for non-missing-toolchain errors
-                    void vscode.window.showErrorMessage(
-                        `Failed to load toolchain from Swiftly: ${error.stderr}`
+    public static async getActiveToolchain(
+        extensionRoot: string,
+        cwd?: vscode.Uri,
+        logger?: SwiftLogger
+    ): Promise<string> {
+        try {
+            return await Swiftly.inUseLocation("swiftly", cwd);
+        } catch (error: unknown) {
+            if (error instanceof ExecFileError) {
+                // Check if this is a missing toolchain error
+                const missingToolchainError = parseSwiftlyMissingToolchainError(error.stderr);
+                if (missingToolchainError) {
+                    // Attempt automatic installation
+                    const installed = await handleMissingSwiftlyToolchain(
+                        missingToolchainError.version,
+                        extensionRoot,
+                        logger,
+                        cwd
                     );
+                    if (installed) {
+                        // Retry toolchain location after successful installation
+                        return await this.getActiveToolchain(extensionRoot, cwd, logger);
+                    }
                 }
             }
+            // We were unable to resolve the active swift toolchain.
+            throw Error("Failed to determine the active swift toolchain via swiftly.", {
+                cause: error,
+            });
         }
-        return undefined;
     }
 
     /**
@@ -901,8 +878,7 @@ export class Swiftly {
             return false;
         }
         try {
-            await findBinaryPath("swiftly");
-            return true;
+            return (await findBinaryInPath("swiftly")).length > 0;
         } catch (error) {
             return false;
         }