Fix Swiftly toolchain management and selection support

Author: roulpriya

src/toolchain/swiftly.ts

@@ -27,15 +27,15 @@ const ListResult = z.object({
             isDefault: z.boolean(),
             version: z.discriminatedUnion("type", [
                 z.object({
-                    major: z.number(),
-                    minor: z.number(),
+                    major: z.number().optional(),
+                    minor: z.number().optional(),
                     patch: z.number().optional(),
                     name: z.string(),
                     type: z.literal("stable"),
                 }),
                 z.object({
-                    major: z.number(),
-                    minor: z.number(),
+                    major: z.number().optional(),
+                    minor: z.number().optional(),
                     branch: z.string(),
                     date: z.string(),
                     name: z.string(),
@@ -134,7 +134,7 @@ export class Swiftly {
         return process.platform === "linux" || process.platform === "darwin";
     }
 
-    public static async inUseLocation(swiftlyPath: string, cwd?: vscode.Uri) {
+    public static async inUseLocation(swiftlyPath: string = "swiftly", cwd?: vscode.Uri) {
         const { stdout: inUse } = await execFile(swiftlyPath, ["use", "--print-location"], {
             cwd: cwd?.fsPath,
         });
@@ -182,6 +182,36 @@ export class Swiftly {
         return undefined;
     }
 
+    /**
+     * Returns the home directory for Swiftly.
+     *
+     * @returns The path to the Swiftly home directory.
+     */
+    static getHomeDir(): string | undefined {
+        return process.env["SWIFTLY_HOME_DIR"];
+    }
+
+    /**
+     * Returns the directory where Swift binaries managed by Swiftly are installed.
+     * This is a placeholder method and should be implemented based on your environment.
+     *
+     * @returns The path to the Swiftly binaries directory.
+     */
+    static getBinDir(): string {
+        const overriddenBinDir = process.env["SWIFTLY_BIN_DIR"];
+        if (overriddenBinDir) {
+            return overriddenBinDir;
+        }
+
+        // If SWIFTLY_BIN_DIR is not set, use the default location based on SWIFTLY_HOME_DIR
+        // This assumes that the binaries are located in the "bin" subdirectory of SWIFTLY_HOME_DIR
+        const swiftlyHomeDir = Swiftly.getHomeDir();
+        if (!swiftlyHomeDir) {
+            throw new Error("Swiftly is not installed or SWIFTLY_HOME_DIR is not set.");
+        }
+        return path.join(swiftlyHomeDir, "bin");
+    }
+
     /**
      * Reads the Swiftly configuration file, if it exists.
      *

src/toolchain/toolchain.ts

@@ -112,7 +112,8 @@ export class SwiftToolchain {
         public customSDK?: string,
         public xcTestPath?: string,
         public swiftTestingPath?: string,
-        public swiftPMTestingHelperPath?: string
+        public swiftPMTestingHelperPath?: string,
+        public isSwiftlyManaged: boolean = false // true if this toolchain is managed by Swiftly
     ) {
         this.swiftVersionString = targetInfo.compilerVersion;
     }
@@ -121,7 +122,10 @@ export class SwiftToolchain {
         folder?: vscode.Uri,
         outputChannel?: vscode.OutputChannel
     ): Promise<SwiftToolchain> {
-        const swiftFolderPath = await this.getSwiftFolderPath(folder, outputChannel);
+        const { path: swiftFolderPath, isSwiftlyManaged } = await this.getSwiftFolderPath(
+            folder,
+            outputChannel
+        );
         const toolchainPath = await this.getToolchainPath(swiftFolderPath, folder, outputChannel);
         const targetInfo = await this.getSwiftTargetInfo(
             this._getToolchainExecutable(toolchainPath, "swift")
@@ -159,7 +163,8 @@ export class SwiftToolchain {
             customSDK,
             xcTestPath,
             swiftTestingPath,
-            swiftPMTestingHelperPath
+            swiftPMTestingHelperPath,
+            isSwiftlyManaged
         );
     }
 
@@ -518,7 +523,7 @@ export class SwiftToolchain {
     private static async getSwiftFolderPath(
         cwd?: vscode.Uri,
         outputChannel?: vscode.OutputChannel
-    ): Promise<string> {
+    ): Promise<{ path: string; isSwiftlyManaged: boolean }> {
         try {
             let swift: string;
             if (configuration.path !== "") {
@@ -564,18 +569,24 @@ export class SwiftToolchain {
             }
             // swift may be a symbolic link
             let realSwift = await fs.realpath(swift);
+            let isSwiftlyManaged = false;
+
             if (path.basename(realSwift) === "swiftly") {
                 try {
                     const inUse = await Swiftly.inUseLocation(realSwift, cwd);
                     if (inUse) {
                         realSwift = path.join(inUse, "usr", "bin", "swift");
+                        isSwiftlyManaged = true;
                     }
                 } catch {
                     // Ignore, will fall back to original path
                 }
             }
             const swiftPath = expandFilePathTilde(path.dirname(realSwift));
-            return await this.getSwiftEnvPath(swiftPath);
+            return {
+                path: await this.getSwiftEnvPath(swiftPath),
+                isSwiftlyManaged,
+            };
         } catch (error) {
             outputChannel?.appendLine(`Failed to find swift executable: ${error}`);
             throw Error("Failed to find swift executable");

src/ui/ToolchainSelection.ts

@@ -98,25 +98,27 @@ export async function selectToolchain() {
 }
 
 /** A {@link vscode.QuickPickItem} that contains the path to an installed Swift toolchain */
-type SwiftToolchainItem = PublicSwiftToolchainItem | XcodeToolchainItem;
+type SwiftToolchainItem = PublicSwiftToolchainItem | XcodeToolchainItem | SwiftlyToolchainItem;
 
 /** Common properties for a {@link vscode.QuickPickItem} that represents a Swift toolchain */
 interface BaseSwiftToolchainItem extends vscode.QuickPickItem {
     type: "toolchain";
-    toolchainPath: string;
-    swiftFolderPath: string;
     onDidSelect?(): Promise<void>;
 }
 
 /** A {@link vscode.QuickPickItem} for a Swift toolchain that has been installed manually */
 interface PublicSwiftToolchainItem extends BaseSwiftToolchainItem {
-    category: "public" | "swiftly";
+    category: "public";
+    toolchainPath: string;
+    swiftFolderPath: string;
 }
 
 /** A {@link vscode.QuickPickItem} for a Swift toolchain provided by an installed Xcode application */
 interface XcodeToolchainItem extends BaseSwiftToolchainItem {
     category: "xcode";
     xcodePath: string;
+    toolchainPath: string;
+    swiftFolderPath: string;
 }
 
 /** A {@link vscode.QuickPickItem} that performs an action for the user */
@@ -125,6 +127,11 @@ interface ActionItem extends vscode.QuickPickItem {
     run(): Promise<void>;
 }
 
+interface SwiftlyToolchainItem extends BaseSwiftToolchainItem {
+    category: "swiftly";
+    version: string;
+}
+
 /** A {@link vscode.QuickPickItem} that separates items in the UI */
 class SeparatorItem implements vscode.QuickPickItem {
     readonly type = "separator";
@@ -178,7 +185,6 @@ async function getQuickPickItems(
                 type: "toolchain",
                 category: "public",
                 label: path.basename(toolchainPath, ".xctoolchain"),
-                detail: toolchainPath,
                 toolchainPath: path.join(toolchainPath, "usr"),
                 swiftFolderPath: path.join(toolchainPath, "usr", "bin"),
             };
@@ -195,18 +201,28 @@ async function getQuickPickItems(
     // Find any Swift toolchains installed via Swiftly
     const swiftlyToolchains = (await Swiftly.listAvailableToolchains())
         .reverse()
-        .map<SwiftToolchainItem>(toolchainPath => ({
+        .map<SwiftlyToolchainItem>(toolchainPath => ({
             type: "toolchain",
-            category: "swiftly",
             label: path.basename(toolchainPath),
-            detail: toolchainPath,
-            toolchainPath: path.join(toolchainPath, "usr"),
-            swiftFolderPath: path.join(toolchainPath, "usr", "bin"),
+            category: "swiftly",
+            version: path.basename(toolchainPath),
         }));
     // Mark which toolchain is being actively used
     if (activeToolchain) {
         const toolchainInUse = [...xcodes, ...toolchains, ...swiftlyToolchains].find(toolchain => {
-            return toolchain.toolchainPath === activeToolchain.toolchainPath;
+            if (activeToolchain.isSwiftlyManaged) {
+                if (toolchain.category !== "swiftly") {
+                    return false;
+                }
+
+                // For Swiftly toolchains, check if the label matches the active toolchain version
+                return toolchain.label === activeToolchain.swiftVersion.toString();
+            }
+            // For non-Swiftly toolchains, check if the toolchain path matches
+            return (
+                (toolchain as PublicSwiftToolchainItem | XcodeToolchainItem).toolchainPath ===
+                activeToolchain.toolchainPath
+            );
         });
         if (toolchainInUse) {
             toolchainInUse.description = "$(check) in use";
@@ -304,19 +320,21 @@ export async function showToolchainSelectionQuickPick(activeToolchain: SwiftTool
             }
         }
         // Update the toolchain path
-        let swiftPath = selected.swiftFolderPath;
+        let swiftPath: string;
 
         // Handle Swiftly toolchains specially
         if (selected.category === "swiftly") {
             try {
                 // Run swiftly use <version> and get the path to the toolchain
                 await Swiftly.use(selected.label);
-                const inUseLocation = await Swiftly.inUseLocation("swiftly");
-                swiftPath = path.join(inUseLocation, "usr", "bin");
+                swiftPath = Swiftly.getBinDir();
             } catch (error) {
                 void vscode.window.showErrorMessage(`Failed to switch Swiftly toolchain: ${error}`);
                 return;
             }
+        } else {
+            // For non-Swiftly toolchains, use the swiftFolderPath
+            swiftPath = (selected as PublicSwiftToolchainItem | XcodeToolchainItem).swiftFolderPath;
         }
 
         const isUpdated = await setToolchainPath(swiftPath, developerDir);