Don't set swift.path if using swiftly

Author: roulpriya

src/commands.ts

@@ -63,14 +63,15 @@ import { generateSourcekitConfiguration } from "./commands/generateSourcekitConf
 export type WorkspaceContextWithToolchain = WorkspaceContext & { toolchain: SwiftToolchain };
 
 export function registerToolchainCommands(
-    toolchain: SwiftToolchain | undefined
+    toolchain: SwiftToolchain | undefined,
+    cwd?: vscode.Uri
 ): vscode.Disposable[] {
     return [
         vscode.commands.registerCommand("swift.createNewProject", () =>
             createNewProject(toolchain)
         ),
         vscode.commands.registerCommand("swift.selectToolchain", () =>
-            showToolchainSelectionQuickPick(toolchain)
+            showToolchainSelectionQuickPick(toolchain, cwd)
         ),
         vscode.commands.registerCommand("swift.pickProcess", configuration =>
             pickProcess(configuration)

src/extension.ts

@@ -81,7 +81,9 @@ export async function activate(context: vscode.ExtensionContext): Promise<Api> {
 
         context.subscriptions.push(new SwiftEnvironmentVariablesManager(context));
         context.subscriptions.push(SwiftTerminalProfileProvider.register());
-        context.subscriptions.push(...commands.registerToolchainCommands(toolchain));
+        context.subscriptions.push(
+            ...commands.registerToolchainCommands(toolchain, workspaceContext.currentFolder?.folder)
+        );
 
         // Watch for configuration changes the trigger a reload of the extension if necessary.
         context.subscriptions.push(

src/toolchain/swiftly.ts

@@ -46,6 +46,10 @@ const ListResult = z.object({
     ),
 });
 
+const InUseVersionResult = z.object({
+    version: z.string(),
+});
+
 export class Swiftly {
     /**
      * Finds the version of Swiftly installed on the system.
@@ -68,6 +72,27 @@ export class Swiftly {
         }
     }
 
+    /**
+     * Checks if the installed version of Swiftly supports JSON output.
+     *
+     * @returns `true` if JSON output is supported, `false` otherwise.
+     */
+    private static async supportsJsonOutput(
+        outputChannel?: vscode.OutputChannel
+    ): Promise<boolean> {
+        if (!Swiftly.isSupported()) {
+            return false;
+        }
+        try {
+            const { stdout } = await execFile("swiftly", ["--version"]);
+            const version = Version.fromString(stdout.trim());
+            return version?.isGreaterThanOrEqual(new Version(1, 1, 0)) ?? false;
+        } catch (error) {
+            outputChannel?.appendLine(`Failed to check Swiftly JSON support: ${error}`);
+            return false;
+        }
+    }
+
     /**
      * Finds the list of toolchains managed by Swiftly.
      *
@@ -85,7 +110,7 @@ export class Swiftly {
             return [];
         }
 
-        if (version.isLessThan(new Version(1, 1, 0))) {
+        if (!(await Swiftly.supportsJsonOutput(outputChannel))) {
             return await Swiftly.getToolchainInstallLegacy(outputChannel);
         }
 
@@ -141,6 +166,25 @@ export class Swiftly {
         return inUse.trimEnd();
     }
 
+    public static async inUseVersion(
+        swiftlyPath: string = "swiftly",
+        cwd?: vscode.Uri
+    ): Promise<string | undefined> {
+        if (!this.isSupported()) {
+            throw new Error("Swiftly is not supported on this platform");
+        }
+
+        if (!(await Swiftly.supportsJsonOutput())) {
+            return undefined;
+        }
+
+        const { stdout } = await execFile(swiftlyPath, ["use", "--format=json"], {
+            cwd: cwd?.fsPath,
+        });
+        const result = InUseVersionResult.parse(JSON.parse(stdout));
+        return result.version;
+    }
+
     public static async use(version: string): Promise<void> {
         if (!this.isSupported()) {
             throw new Error("Swiftly is not supported on this platform");
@@ -182,36 +226,6 @@ 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/ui/ToolchainSelection.ts

@@ -153,7 +153,8 @@ type SelectToolchainItem = SwiftToolchainItem | ActionItem | SeparatorItem;
  * @returns an array of {@link SelectToolchainItem}
  */
 async function getQuickPickItems(
-    activeToolchain: SwiftToolchain | undefined
+    activeToolchain: SwiftToolchain | undefined,
+    cwd?: vscode.Uri
 ): Promise<SelectToolchainItem[]> {
     // Find any Xcode installations on the system
     const xcodes = (await SwiftToolchain.findXcodeInstalls())
@@ -206,17 +207,32 @@ async function getQuickPickItems(
             label: path.basename(toolchainPath),
             category: "swiftly",
             version: path.basename(toolchainPath),
+            onDidSelect: async () => {
+                try {
+                    await Swiftly.use(toolchainPath);
+                    void showReloadExtensionNotification(
+                        "Changing the Swift path requires Visual Studio Code be reloaded."
+                    );
+                } catch (error) {
+                    void vscode.window.showErrorMessage(
+                        `Failed to switch Swiftly toolchain: ${error}`
+                    );
+                }
+            },
         }));
     // Mark which toolchain is being actively used
     if (activeToolchain) {
+        const currentSwiftlyVersion = activeToolchain.isSwiftlyManaged
+            ? await Swiftly.inUseVersion("swiftly", cwd)
+            : undefined;
         const toolchainInUse = [...xcodes, ...toolchains, ...swiftlyToolchains].find(toolchain => {
-            if (activeToolchain.isSwiftlyManaged) {
+            if (currentSwiftlyVersion) {
                 if (toolchain.category !== "swiftly") {
                     return false;
                 }
 
                 // For Swiftly toolchains, check if the label matches the active toolchain version
-                return toolchain.label === activeToolchain.swiftVersion.toString();
+                return currentSwiftlyVersion === toolchain.label;
             }
             // For non-Swiftly toolchains, check if the toolchain path matches
             return (
@@ -278,10 +294,13 @@ async function getQuickPickItems(
  *
  * @param activeToolchain the {@link WorkspaceContext}
  */
-export async function showToolchainSelectionQuickPick(activeToolchain: SwiftToolchain | undefined) {
+export async function showToolchainSelectionQuickPick(
+    activeToolchain: SwiftToolchain | undefined,
+    cwd?: vscode.Uri
+) {
     let xcodePaths: string[] = [];
     const selected = await vscode.window.showQuickPick<SelectToolchainItem>(
-        getQuickPickItems(activeToolchain).then(result => {
+        getQuickPickItems(activeToolchain, cwd).then(result => {
             xcodePaths = result
                 .filter((i): i is XcodeToolchainItem => "category" in i && i.category === "xcode")
                 .map(xcode => xcode.xcodePath);
@@ -319,22 +338,20 @@ export async function showToolchainSelectionQuickPick(activeToolchain: SwiftTool
                 });
             }
         }
-        // Update the toolchain path
-        let swiftPath: string;
+        // Update the toolchain path`
+        let swiftPath: string | undefined;
 
         // 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);
-                swiftPath = Swiftly.getBinDir();
+                swiftPath = undefined;
             } 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;
+            swiftPath = selected.swiftFolderPath;
         }
 
         const isUpdated = await setToolchainPath(swiftPath, developerDir);