Fix Several Windows Debugging Issues

Fixes up some issues with Windows debugging found in the latest 6.0
toolchain:
- Add Testing.dll to the PATH same as XCTest.dll
- Don't append .exe when debugging testing binaries
- TODO: Don't follow incorrectly created symlink at `.\build\debug`

Author: plemarquand

src/debugger/buildConfig.ts

@@ -191,14 +191,19 @@ export class TestingConfigurationFactory {
                 ...swiftRuntimeEnv(),
                 ...configuration.folder(this.ctx.workspaceFolder).testEnvironmentVariables,
             };
-            // On Windows, add XCTest.dll to the Path
+            // On Windows, add XCTest.dll/Testing.dll to the Path
             // and run the .xctest executable from the .build directory.
             const runtimePath = this.ctx.workspaceContext.toolchain.runtimePath;
             const xcTestPath = this.ctx.workspaceContext.toolchain.xcTestPath;
             if (xcTestPath && xcTestPath !== runtimePath) {
                 testEnv.Path = `${xcTestPath};${testEnv.Path ?? process.env.Path}`;
             }
 
+            const swiftTestingPath = this.ctx.workspaceContext.toolchain.swiftTestingPath;
+            if (swiftTestingPath && swiftTestingPath !== runtimePath) {
+                testEnv.Path = `${swiftTestingPath};${testEnv.Path ?? process.env.Path}`;
+            }
+
             return {
                 ...this.baseConfig,
                 program: await this.testExecutableOutputPath(),

src/debugger/debugAdapterFactory.ts

@@ -77,9 +77,14 @@ export class LLDBDebugConfigurationProvider implements vscode.DebugConfiguration
     ): Promise<vscode.DebugConfiguration> {
         launchConfig.env = this.convertEnvironmentVariables(launchConfig.env);
         // Fix the program path on Windows to include the ".exe" extension
-        if (this.platform === "win32" && path.extname(launchConfig.program) !== ".exe") {
+        if (
+            this.platform === "win32" &&
+            launchConfig.testType === undefined &&
+            path.extname(launchConfig.program) !== ".exe"
+        ) {
             launchConfig.program += ".exe";
         }
+
         // Delegate to CodeLLDB if that's the debug adapter we have selected
         if (DebugAdapter.getDebugAdapterType(this.swiftVersion) === "lldb-vscode") {
             launchConfig.type = "lldb";

src/toolchain/toolchain.ts

@@ -31,6 +31,7 @@ import { Sanitizer } from "./Sanitizer";
 interface InfoPlist {
     DefaultProperties: {
         XCTEST_VERSION: string | undefined;
+        SWIFT_TESTING_VERSION: string | undefined;
     };
 }
 
@@ -107,6 +108,7 @@ export class SwiftToolchain {
         public defaultSDK?: string,
         public customSDK?: string,
         public xcTestPath?: string,
+        public swiftTestingPath?: string,
         public swiftPMTestingHelperPath?: string
     ) {}
 
@@ -125,6 +127,12 @@ export class SwiftToolchain {
             runtimePath,
             customSDK ?? defaultSDK
         );
+        const swiftTestingPath = await this.getSwiftTestingPath(
+            targetInfo,
+            swiftVersion,
+            runtimePath,
+            customSDK ?? defaultSDK
+        );
         const swiftPMTestingHelperPath = await this.getSwiftPMTestingHelperPath(toolchainPath);
 
         return new SwiftToolchain(
@@ -137,6 +145,7 @@ export class SwiftToolchain {
             defaultSDK,
             customSDK,
             xcTestPath,
+            swiftTestingPath,
             swiftPMTestingHelperPath
         );
     }
@@ -638,6 +647,31 @@ export class SwiftToolchain {
         return undefined;
     }
 
+    /**
+     * @param targetInfo swift target info
+     * @param swiftVersion parsed swift version
+     * @param runtimePath path to Swift runtime
+     * @param sdkroot path to swift SDK
+     * @returns path to folder where xctest can be found
+     */
+    private static async getSwiftTestingPath(
+        targetInfo: SwiftTargetInfo,
+        swiftVersion: Version,
+        runtimePath: string | undefined,
+        sdkroot: string | undefined
+    ): Promise<string | undefined> {
+        if (process.platform !== "win32") {
+            return undefined;
+        }
+        return this.getWindowsPlatformDLLPath(
+            "Testing",
+            targetInfo,
+            swiftVersion,
+            runtimePath,
+            sdkroot
+        );
+    }
+
     /**
      * @param targetInfo swift target info
      * @param swiftVersion parsed swift version
@@ -663,80 +697,95 @@ export class SwiftToolchain {
                 return path.join(developerDir, "usr", "bin");
             }
             case "win32": {
-                // look up runtime library directory for XCTest alternatively
-                const fallbackPath =
-                    runtimePath !== undefined &&
-                    (await pathExists(path.join(runtimePath, "XCTest.dll")))
-                        ? runtimePath
-                        : undefined;
-                if (!sdkroot) {
-                    return fallbackPath;
-                }
-                const platformPath = path.dirname(path.dirname(path.dirname(sdkroot)));
-                const platformManifest = path.join(platformPath, "Info.plist");
-                if ((await pathExists(platformManifest)) !== true) {
-                    if (fallbackPath) {
-                        return fallbackPath;
-                    }
-                    vscode.window.showWarningMessage(
-                        "XCTest not found due to non-standardized library layout. Tests explorer won't work as expected."
-                    );
-                    return undefined;
-                }
-                const data = await fs.readFile(platformManifest, "utf8");
-                let infoPlist;
-                try {
-                    infoPlist = plist.parse(data) as unknown as InfoPlist;
-                } catch (error) {
-                    vscode.window.showWarningMessage(
-                        `Unable to parse ${platformManifest}: ${error}`
-                    );
-                    return undefined;
-                }
-                const version = infoPlist.DefaultProperties.XCTEST_VERSION;
-                if (!version) {
-                    throw Error("Info.plist is missing the XCTEST_VERSION key.");
-                }
-
-                if (swiftVersion.isGreaterThanOrEqual(new Version(5, 7, 0))) {
-                    let bindir: string;
-                    const arch = targetInfo.target?.triple.split("-", 1)[0];
-                    switch (arch) {
-                        case "x86_64":
-                            bindir = "bin64";
-                            break;
-                        case "i686":
-                            bindir = "bin32";
-                            break;
-                        case "aarch64":
-                            bindir = "bin64a";
-                            break;
-                        default:
-                            throw Error(`unsupported architecture ${arch}`);
-                    }
-                    return path.join(
-                        platformPath,
-                        "Developer",
-                        "Library",
-                        `XCTest-${version}`,
-                        "usr",
-                        bindir
-                    );
-                } else {
-                    return path.join(
-                        platformPath,
-                        "Developer",
-                        "Library",
-                        `XCTest-${version}`,
-                        "usr",
-                        "bin"
-                    );
-                }
+                return await this.getWindowsPlatformDLLPath(
+                    "XCTest",
+                    targetInfo,
+                    swiftVersion,
+                    runtimePath,
+                    sdkroot
+                );
             }
         }
         return undefined;
     }
 
+    private static async getWindowsPlatformDLLPath(
+        type: "XCTest" | "Testing",
+        targetInfo: SwiftTargetInfo,
+        swiftVersion: Version,
+        runtimePath: string | undefined,
+        sdkroot: string | undefined
+    ): Promise<string | undefined> {
+        // look up runtime library directory for XCTest/Testing alternatively
+        const fallbackPath =
+            runtimePath !== undefined && (await pathExists(path.join(runtimePath, `${type}.dll`)))
+                ? runtimePath
+                : undefined;
+        if (!sdkroot) {
+            return fallbackPath;
+        }
+
+        const platformPath = path.dirname(path.dirname(path.dirname(sdkroot)));
+        const platformManifest = path.join(platformPath, "Info.plist");
+        if ((await pathExists(platformManifest)) !== true) {
+            if (fallbackPath) {
+                return fallbackPath;
+            }
+            vscode.window.showWarningMessage(
+                `${type} not found due to non-standardized library layout. Tests explorer won't work as expected.`
+            );
+            return undefined;
+        }
+        const data = await fs.readFile(platformManifest, "utf8");
+        let infoPlist;
+        try {
+            infoPlist = plist.parse(data) as unknown as InfoPlist;
+        } catch (error) {
+            vscode.window.showWarningMessage(`Unable to parse ${platformManifest}: ${error}`);
+            return undefined;
+        }
+        const plistKey = type === "XCTest" ? "XCTEST_VERSION" : "SWIFT_TESTING_VERSION";
+        const version = infoPlist.DefaultProperties[plistKey];
+        if (!version) {
+            throw Error(`Info.plist is missing the ${plistKey} key.`);
+        }
+
+        if (swiftVersion.isGreaterThanOrEqual(new Version(5, 7, 0))) {
+            let bindir: string;
+            const arch = targetInfo.target?.triple.split("-", 1)[0];
+            switch (arch) {
+                case "x86_64":
+                    bindir = "bin64";
+                    break;
+                case "i686":
+                    bindir = "bin32";
+                    break;
+                case "aarch64":
+                    bindir = "bin64a";
+                    break;
+                default:
+                    throw Error(`unsupported architecture ${arch}`);
+            }
+            return path.join(
+                platformPath,
+                "Developer",
+                "Library",
+                `${type}-${version}`,
+                "usr",
+                bindir
+            );
+        } else {
+            return path.join(
+                platformPath,
+                "Developer",
+                "Library",
+                `${type}-${version}`,
+                "usr",
+                "bin"
+            );
+        }
+    }
+
     /** @returns swift target info */
     private static async getSwiftTargetInfo(): Promise<SwiftTargetInfo> {
         try {