Fix developer dir selection in Swiftly toolchain installation (#1897)

Author: matthewbastien

src/commands/installSwiftlyToolchain.ts

@@ -156,47 +156,53 @@ export async function promptToInstallSwiftlyToolchain(
         toolchain: toolchain,
     }));
 
-    const selected = await vscode.window.showQuickPick(quickPickItems, {
+    const selectedToolchain = await vscode.window.showQuickPick(quickPickItems, {
         title: "Install Swift Toolchain via Swiftly",
         placeHolder: "Pick a Swift toolchain to install",
         canPickMany: false,
     });
-    if (!selected) {
+    if (!selectedToolchain) {
         return;
     }
 
-    const target = await askWhereToSetToolchain();
-    if (!target) {
+    const xcodes = await SwiftToolchain.findXcodeInstalls();
+    const selectedDeveloperDir = await showDeveloperDirQuickPick(xcodes);
+    if (!selectedDeveloperDir) {
         return;
     }
 
-    const xcodes = await SwiftToolchain.findXcodeInstalls();
-    const developerDir = await showDeveloperDirQuickPick(xcodes);
-    if (!developerDir) {
+    const target = await askWhereToSetToolchain();
+    if (!target) {
         return;
     }
 
     // Install the toolchain via Swiftly
-    if (!(await installSwiftlyToolchainWithProgress(selected.toolchain.version.name, ctx.logger))) {
+    if (
+        !(await installSwiftlyToolchainWithProgress(
+            selectedToolchain.toolchain.version.name,
+            ctx.logger
+        ))
+    ) {
         return;
     }
+
     // Tell Swiftly to use the newly installed toolchain
-    if (target === vscode.ConfigurationTarget.Workspace) {
-        await Promise.all(
-            vscode.workspace.workspaceFolders?.map(folder =>
-                Swiftly.use(selected.toolchain.version.name, folder.uri.fsPath)
-            ) ?? []
-        );
-        return;
-    }
     await setToolchainPath(
         {
             category: "swiftly",
             async onDidSelect() {
-                await Swiftly.use(selected.toolchain.version.name);
+                if (target === vscode.ConfigurationTarget.Workspace) {
+                    await Promise.all(
+                        vscode.workspace.workspaceFolders?.map(folder =>
+                            Swiftly.use(selectedToolchain.toolchain.version.name, folder.uri.fsPath)
+                        ) ?? []
+                    );
+                    return;
+                }
+                await Swiftly.use(selectedToolchain.toolchain.version.name);
             },
         },
-        developerDir,
+        selectedDeveloperDir.developerDir,
         target
     );
 }

src/ui/ToolchainSelection.ts

@@ -20,6 +20,7 @@ import configuration from "../configuration";
 import { SwiftLogger } from "../logging/SwiftLogger";
 import { Swiftly } from "../toolchain/swiftly";
 import { SwiftToolchain } from "../toolchain/toolchain";
+import { isEmptyObject } from "../utilities/utilities";
 import { showReloadExtensionNotification } from "./ReloadExtension";
 
 /**
@@ -406,50 +407,48 @@ export async function showToolchainSelectionQuickPick(
     if (selectedToolchain?.type === "toolchain") {
         // Select an Xcode to build with
         let developerDir: string | undefined = undefined;
-        if (process.platform === "darwin") {
-            let selectedXcodePath: string | undefined = undefined;
-            if (selectedToolchain.category === "xcode") {
-                selectedXcodePath = selectedToolchain.xcodePath;
-            } else if (xcodePaths.length === 1) {
-                selectedXcodePath = xcodePaths[0];
-            } else if (xcodePaths.length > 1) {
-                selectedXcodePath = await showDeveloperDirQuickPick(xcodePaths);
-                if (!selectedXcodePath) {
-                    return;
-                }
-            }
-            // Find the actual DEVELOPER_DIR based on the selected Xcode app
-            if (selectedXcodePath) {
-                developerDir = await SwiftToolchain.getXcodeDeveloperDir({
-                    ...process.env,
-                    DEVELOPER_DIR: selectedXcodePath,
-                });
+        if (selectedToolchain.category === "xcode") {
+            developerDir = await SwiftToolchain.getXcodeDeveloperDir({
+                ...process.env,
+                DEVELOPER_DIR: selectedToolchain.xcodePath,
+            });
+        } else {
+            const selectedDeveloperDir = await showDeveloperDirQuickPick(xcodePaths);
+            if (!selectedDeveloperDir) {
+                return;
             }
+            developerDir = selectedDeveloperDir.developerDir;
         }
         // Update the toolchain configuration
         await setToolchainPath(selectedToolchain, developerDir);
         return;
     }
 }
 
-/**
- * Prompt the user to choose a value for the DEVELOPER_DIR environment variable.
- *
- * @param xcodePaths An array of paths to available Xcode installations on the system
- * @returns The selected DEVELOPER_DIR or undefined if the user cancelled selection
- */
-export async function showDeveloperDirQuickPick(xcodePaths: string[]): Promise<string | undefined> {
-    const selected = await vscode.window.showQuickPick<vscode.QuickPickItem>(
+async function showXcodeQuickPick(
+    xcodePaths: string[]
+): Promise<{ type: "selected"; xcodePath: string | undefined } | undefined> {
+    if (process.platform !== "darwin" || xcodePaths.length === 0) {
+        return { type: "selected", xcodePath: undefined };
+    }
+    if (xcodePaths.length === 1) {
+        return { type: "selected", xcodePath: xcodePaths[1] };
+    }
+    type XcodeQuickPickItem = vscode.QuickPickItem & { inUse: boolean; xcodePath: string };
+    const selected = await vscode.window.showQuickPick<XcodeQuickPickItem>(
         SwiftToolchain.getXcodeDeveloperDir(configuration.swiftEnvironmentVariables).then(
             existingDeveloperDir => {
                 return xcodePaths
                     .map(xcodePath => {
-                        const result: vscode.QuickPickItem = {
+                        const result: XcodeQuickPickItem = {
                             label: path.basename(xcodePath, ".app"),
                             detail: xcodePath,
+                            inUse: false,
+                            xcodePath,
                         };
                         if (existingDeveloperDir.startsWith(xcodePath)) {
                             result.description = "$(check) in use";
+                            result.inUse = true;
                         }
                         return result;
                     })
@@ -472,7 +471,35 @@ export async function showDeveloperDirQuickPick(xcodePaths: string[]): Promise<s
             canPickMany: false,
         }
     );
-    return selected?.detail;
+    if (!selected) {
+        return undefined;
+    }
+    return { type: "selected", xcodePath: selected.xcodePath };
+}
+
+/**
+ * Prompt the user to choose a value for the DEVELOPER_DIR environment variable.
+ *
+ * @param xcodePaths An array of paths to available Xcode installations on the system
+ * @returns The selected DEVELOPER_DIR or undefined if the user cancelled selection
+ */
+export async function showDeveloperDirQuickPick(
+    xcodePaths: string[]
+): Promise<{ developerDir: string | undefined } | undefined> {
+    const selectedXcode = await showXcodeQuickPick(xcodePaths);
+    if (!selectedXcode) {
+        return undefined;
+    }
+    if (!selectedXcode.xcodePath) {
+        return { developerDir: undefined };
+    }
+    // Find the actual DEVELOPER_DIR based on the selected Xcode app
+    return {
+        developerDir: await SwiftToolchain.getXcodeDeveloperDir({
+            ...process.env,
+            DEVELOPER_DIR: selectedXcode.xcodePath,
+        }),
+    };
 }
 
 /**
@@ -554,13 +581,13 @@ export async function setToolchainPath(
     const toolchainPath = toolchain.category !== "swiftly" ? toolchain.swiftFolderPath : undefined;
     const swiftConfiguration = vscode.workspace.getConfiguration("swift");
     await swiftConfiguration.update("path", toolchainPath, target);
-    const swiftEnv = configuration.swiftEnvironmentVariables;
+    const swiftEnvironmentVariables = {
+        ...configuration.swiftEnvironmentVariables,
+        DEVELOPER_DIR: developerDir,
+    };
     await swiftConfiguration.update(
         "swiftEnvironmentVariables",
-        {
-            ...swiftEnv,
-            DEVELOPER_DIR: developerDir,
-        },
+        isEmptyObject(swiftEnvironmentVariables) ? undefined : swiftEnvironmentVariables,
         target
     );
     await checkAndRemoveWorkspaceSetting(target);

src/utilities/utilities.ts

@@ -50,6 +50,14 @@ export const IS_RUNNING_UNDER_DOCKER = IS_RUNNING_UNDER_ACT || IS_RUNNING_UNDER_
  */
 export const IS_RUNNING_UNDER_TEST = process.env.RUNNING_UNDER_VSCODE_TEST_CLI === "1";
 
+/** Determines whether the provided object has any properties set to non-null values. */
+export function isEmptyObject(obj: { [key: string]: unknown }): boolean {
+    const properties = Object.getOwnPropertyNames(obj).filter(
+        property => obj[property] !== undefined && obj[property] !== null
+    );
+    return properties.length === 0;
+}
+
 /**
  * Get required environment variable for Swift product
  *