only return a single path from findBinaryInPath

Author: matthewbastien

src/toolchain/toolchain.ts

@@ -134,7 +134,7 @@ export class SwiftToolchain {
         folder?: vscode.Uri,
         logger?: SwiftLogger
     ): Promise<SwiftToolchain> {
-        const swiftBinaryPath = await this.findSwiftBinaryInPath(logger);
+        const swiftBinaryPath = await this.findSwiftBinaryInPath();
         const { toolchainPath, toolchainManager } = await this.getToolchainPath(
             swiftBinaryPath,
             extensionRoot,
@@ -519,21 +519,14 @@ export class SwiftToolchain {
         logger.debug(this.diagnostics);
     }
 
-    private static async findSwiftBinaryInPath(logger?: SwiftLogger): Promise<string> {
+    private static async findSwiftBinaryInPath(): Promise<string> {
         if (configuration.path !== "") {
             const pathFromSettings = expandFilePathTilde(configuration.path);
             const windowsExeSuffix = process.platform === "win32" ? ".exe" : "";
 
             return path.join(pathFromSettings, `swift${windowsExeSuffix}`);
         }
-        const foundPaths = await findBinaryInPath("swift");
-        if (foundPaths.length > 1) {
-            logger?.warn(
-                `Found multiple swift binaries in PATH: ${foundPaths.map(p => `"${p}"`).join(", ")}`
-            );
-            logger?.warn(`Using swift binary path "${foundPaths[0]}"`);
-        }
-        return foundPaths[0];
+        return await findBinaryInPath("swift");
     }
 
     private static async isXcrunShim(binary: string): Promise<boolean> {

src/utilities/shell.ts

@@ -17,17 +17,15 @@ import { execFile } from "./utilities";
  * Asks the shell where a binary is located. Will always return at least one path unless
  * resolution fails completely, in which case the function will throw.
  *
- * Note: On Windows this has the potential to return multiple paths.
- *
  * @param binaryName The name of the binary to search for.
  * @returns An array of paths found on the system.
  */
-export async function findBinaryInPath(binaryName: string): Promise<string[]> {
+export async function findBinaryInPath(binaryName: string): Promise<string> {
     try {
         switch (process.platform) {
             case "darwin": {
                 const { stdout } = await execFile("which", [binaryName]);
-                return [stdout.trimEnd()];
+                return stdout.trimEnd();
             }
             case "win32": {
                 const command = "where.exe";
@@ -37,7 +35,7 @@ export async function findBinaryInPath(binaryName: string): Promise<string[]> {
                 if (foundPaths.length === 0) {
                     throw createParsingError({ command, args, stdout, stderr });
                 }
-                return foundPaths;
+                return foundPaths[0];
             }
             default: {
                 // use `type` to find the binary on Linux. Run inside /bin/sh to ensure
@@ -52,7 +50,7 @@ export async function findBinaryInPath(binaryName: string): Promise<string[]> {
                 if (!binaryNameMatch) {
                     throw createParsingError({ command, args, stdout, stderr });
                 }
-                return [binaryNameMatch[1]];
+                return binaryNameMatch[1];
             }
         }
     } catch (error) {

test/unit-tests/utilities/shell.test.ts

@@ -40,9 +40,9 @@ suite("Shell Unit Test Suite", () => {
                     stderr: "",
                 });
 
-                await expect(findBinaryInPath("node")).to.eventually.deep.equal([
-                    "/usr/local/bin/node",
-                ]);
+                await expect(findBinaryInPath("node")).to.eventually.equalPath(
+                    "/usr/local/bin/node"
+                );
             });
 
             test("throws for a non-existent binary", async () => {
@@ -67,9 +67,9 @@ suite("Shell Unit Test Suite", () => {
                         stderr: "",
                     });
 
-                await expect(findBinaryInPath("node")).to.eventually.deep.equal([
-                    "/usr/local/bin/node",
-                ]);
+                await expect(findBinaryInPath("node")).to.eventually.equalPath(
+                    "/usr/local/bin/node"
+                );
             });
 
             test("throws for a non-existent binary", async () => {
@@ -92,10 +92,9 @@ suite("Shell Unit Test Suite", () => {
                     stderr: "",
                 });
 
-                await expect(findBinaryInPath("node")).to.eventually.deep.equal([
-                    "/usr/local/bin/node",
-                    "/usr/local/other/bin/node",
-                ]);
+                await expect(findBinaryInPath("node")).to.eventually.equalPath(
+                    "/usr/local/bin/node"
+                );
             });
 
             test("throws for a non-existent binary", async () => {