Switch to Build All task when listing tests fails (#814)

Use the buildAllTask instead of SwiftExecOperation to make long this
behaviour the same as other builds in the extension.

Added a task cache since provideTasks can be called multiple times and
the most recently returned task is held by VSCode. If we attempted
created the build all task and hooked up the event listeners but then
provideTasks was called again before the task was executed, the executed
task would not be the one we were listening to.

Fixes #808

Author: plemarquand

src/TestExplorer/TestExplorer.ts

@@ -243,20 +243,18 @@ export class TestExplorer {
                 // If a test list fails its possible the tests have not been built.
                 // Build them and try again, and if we still fail then notify the user.
                 if (firstTry) {
-                    await new Promise<string>(resolve => {
-                        const swiftBuildOperation = new SwiftExecOperation(
-                            ["build", "--build-tests"],
-                            explorer.folderContext,
-                            "Building",
-                            {
-                                showStatusItem: true,
-                                checkAlreadyRunning: true,
-                                log: "Performing initial build",
-                            },
-                            resolve
+                    const backgroundTask = await getBuildAllTask(explorer.folderContext);
+                    if (!backgroundTask) {
+                        return;
+                    }
+
+                    try {
+                        await explorer.folderContext.taskQueue.queueOperation(
+                            new TaskOperation(backgroundTask)
                         );
-                        explorer.folderContext.taskQueue.queueOperation(swiftBuildOperation);
-                    });
+                    } catch {
+                        // can ignore if running task fails
+                    }
 
                     // Retry test discovery after performing a build.
                     await runDiscover(explorer, false);

src/tasks/SwiftTaskProvider.ts

@@ -111,6 +111,21 @@ function getBuildRevealOption(): vscode.TaskRevealKind {
         : vscode.TaskRevealKind.Never;
 }
 
+const buildAllTaskCache = (() => {
+    const cache = new Map<string, vscode.Task>();
+    const key = (name: string, folderContext: FolderContext) => {
+        return `${name}:${buildOptions(folderContext.workspaceContext.toolchain).join(",")}`;
+    };
+    return {
+        get(name: string, folderContext: FolderContext): vscode.Task | undefined {
+            return cache.get(key(name, folderContext));
+        },
+        set(name: string, folderContext: FolderContext, task: vscode.Task) {
+            cache.set(key(name, folderContext), task);
+        },
+    };
+})();
+
 /**
  * Creates a {@link vscode.Task Task} to build all targets in this package.
  */
@@ -127,7 +142,16 @@ export function createBuildAllTask(folderContext: FolderContext): vscode.Task {
     if (folderContext.workspaceContext.toolchain.buildFlags.getDarwinTarget() === undefined) {
         additionalArgs = ["--build-tests", ...additionalArgs];
     }
-    return createSwiftTask(
+
+    // Create one Build All task per folder context, since this can be called multiple
+    // times and we want the same instance each time. Otherwise, VSCode may try and execute
+    // one instance while our extension code tries to listen to events on an instance created earlier/later.
+    const existingTask = buildAllTaskCache.get(buildTaskName, folderContext);
+    if (existingTask) {
+        return existingTask;
+    }
+
+    const task = createSwiftTask(
         ["build", ...additionalArgs],
         buildTaskName,
         {
@@ -143,6 +167,8 @@ export function createBuildAllTask(folderContext: FolderContext): vscode.Task {
         },
         folderContext.workspaceContext.toolchain
     );
+    buildAllTaskCache.set(buildTaskName, folderContext, task);
+    return task;
 }
 
 /**
@@ -206,10 +232,13 @@ function createBuildTasks(product: Product, folderContext: FolderContext): vscod
     if (folderContext.relativePath.length > 0) {
         buildTaskNameSuffix = ` (${folderContext.relativePath})`;
     }
-    return [
-        createSwiftTask(
+
+    const buildDebugName = `Build Debug ${product.name}${buildTaskNameSuffix}`;
+    let buildDebug = buildAllTaskCache.get(buildDebugName, folderContext);
+    if (!buildDebug) {
+        buildDebug = createSwiftTask(
             ["build", "--product", product.name, ...buildOptions(toolchain)],
-            `Build Debug ${product.name}${buildTaskNameSuffix}`,
+            buildDebugName,
             {
                 group: vscode.TaskGroup.Build,
                 cwd: folderContext.folder,
@@ -223,8 +252,14 @@ function createBuildTasks(product: Product, folderContext: FolderContext): vscod
                 showBuildStatus: configuration.showBuildStatus,
             },
             folderContext.workspaceContext.toolchain
-        ),
-        createSwiftTask(
+        );
+        buildAllTaskCache.set(buildDebugName, folderContext, buildDebug);
+    }
+
+    const buildReleaseName = `Build Release ${product.name}${buildTaskNameSuffix}`;
+    let buildRelease = buildAllTaskCache.get(buildReleaseName, folderContext);
+    if (!buildRelease) {
+        buildRelease = createSwiftTask(
             ["build", "-c", "release", "--product", product.name, ...configuration.buildArguments],
             `Build Release ${product.name}${buildTaskNameSuffix}`,
             {
@@ -240,8 +275,11 @@ function createBuildTasks(product: Product, folderContext: FolderContext): vscod
                 showBuildStatus: configuration.showBuildStatus,
             },
             folderContext.workspaceContext.toolchain
-        ),
-    ];
+        );
+        buildAllTaskCache.set(buildReleaseName, folderContext, buildRelease);
+    }
+
+    return [buildDebug, buildRelease];
 }
 
 /**

src/tasks/TaskQueue.ts

@@ -253,7 +253,10 @@ export class TaskQueue {
                     .catch(error => {
                         // log error
                         if (operation.log) {
-                            this.workspaceContext.outputChannel.logEnd(`${error}`);
+                            this.workspaceContext.outputChannel.logEnd(
+                                `${operation.log}: ${error}`,
+                                this.folderContext.name
+                            );
                         }
                         this.finishTask(operation, { fail: error });
                     });

src/ui/SwiftOutputChannel.ts

@@ -65,9 +65,8 @@ export class SwiftOutputChannel {
         console.log(line);
     }
 
-    logEnd(message: string) {
-        this.channel.appendLine(message);
-        console.log(message);
+    logEnd(message: string, label?: string) {
+        this.logStart(message, label);
     }
 
     get nowFormatted(): string {

src/utilities/utilities.ts

@@ -89,7 +89,7 @@ export async function execFile(
     return new Promise<{ stdout: string; stderr: string }>((resolve, reject) =>
         cp.execFile(executable, args, options, (error, stdout, stderr) => {
             if (error) {
-                reject({ error, stdout, stderr });
+                reject({ error, stdout, stderr, toString: () => error.message });
             }
             resolve({ stdout, stderr });
         })