Fix cmake.buildTask build failures not aborting debug launches (#4785)

* Initial plan

* Fix build diagnostics and exit code not propagating when using cmake.buildTask (#4489)

When cmake.buildTask is true, the CustomBuildTaskTerminal captures build
output but never forwards it to the CMakeBuildConsumer for diagnostic
parsing. This means compiler errors never appear in the Problems tab.

Additionally, setBuildProcessForTask always resolved with exit code 0
regardless of the actual build result, causing failed builds to appear
successful (related to #3389).

Changes:
- Forward build output from CustomBuildTaskTerminal to an external
  OutputConsumer so diagnostics are parsed during task builds
- Pass the consumer through resolveInternalTask to the terminal
- Use onDidEndTaskProcess instead of onDidEndTask to capture the
  actual exit code from the build task

Co-authored-by: Omotola <[email protected]>

* Revert #4489 changes, keep only #3389 fix (build task exit code propagation)

Co-authored-by: Omotola <[email protected]>

* Fix stale target path on build failure by using direct exit code promise from CustomBuildTaskTerminal (#3389)

Co-authored-by: Omotola <[email protected]>

* Dispose onDidClose listener after resolving exit code

Co-authored-by: Omotola <[email protected]>

* Merge main into copilot/fix-build-task-error-reporting, resolve CHANGELOG conflict

Co-authored-by: Omotola <[email protected]>

* Fix brace-style lint error in cmakeTaskProvider.ts

Co-authored-by: Omotola <[email protected]>

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: Omotola <[email protected]>
Co-authored-by: Omotola <[email protected]>

Author: Copilot

CHANGELOG.md

@@ -27,6 +27,7 @@ Improvements:
 - Honor `debugger.workingDirectory` from the CMake File API when debugging a target, so that the `DEBUGGER_WORKING_DIRECTORY` target property is used as the debugger working directory. [#4595](https://github.com/microsoft/vscode-cmake-tools/issues/4595)
 
 Bug Fixes:
+- Fix `cmake.buildTask` build failures not aborting debug launches. When `${command:cmake.launchTargetPath}` is used in `launch.json`, a failed build now correctly prevents the stale executable from being launched. [#3389](https://github.com/microsoft/vscode-cmake-tools/issues/3389)
 - Fix `cmake.compileFile` command truncating long compile commands at ~1024 characters on macOS. The command is now sent to the terminal in chunks to avoid VS Code terminal buffer limitations. [#4470](https://github.com/microsoft/vscode-cmake-tools/issues/4470)
 - Fix configure/build sometimes using stale preset values when unsaved changes to included preset files are auto-saved before configure. The extension now explicitly refreshes presets from disk after saving, instead of relying solely on the asynchronous file watcher. [#4502](https://github.com/microsoft/vscode-cmake-tools/issues/4502)
 - Reduce overly verbose logging when CMake configure or build fails. The Output panel no longer floods with duplicated output, and the channel is only revealed on error rather than unconditionally. [#4749](https://github.com/microsoft/vscode-cmake-tools/issues/4749)

src/cmakeBuildRunner.ts

@@ -32,17 +32,25 @@ export class CMakeBuildRunner {
         this.setBuildInProgress(true);
     }
 
-    public async setBuildProcessForTask(taskExecutor: vscode.TaskExecution): Promise<void> {
+    public async setBuildProcessForTask(taskExecutor: vscode.TaskExecution, exitCodePromise?: Promise<number | null>): Promise<void> {
         this.taskExecutor = taskExecutor;
-        this.currentBuildProcess =  { child: undefined, result: new Promise<proc.ExecutionResult>(resolve => {
-            const disposable: vscode.Disposable = vscode.tasks.onDidEndTask((endEvent: vscode.TaskEndEvent) => {
-                if (endEvent.execution === this.taskExecutor) {
-                    this.taskExecutor = undefined;
-                    disposable.dispose();
-                    resolve({ retc: 0, stdout: '', stderr: '' });
-                }
-            });
-        })};
+        if (exitCodePromise) {
+            // Use the direct exit code promise from the CustomBuildTaskTerminal (most reliable).
+            this.currentBuildProcess = { child: undefined, result: exitCodePromise.then(exitCode => ({
+                retc: exitCode, stdout: '', stderr: ''
+            }))};
+        } else {
+            // Fallback: listen for task process end event.
+            this.currentBuildProcess =  { child: undefined, result: new Promise<proc.ExecutionResult>(resolve => {
+                const disposable: vscode.Disposable = vscode.tasks.onDidEndTaskProcess((endEvent: vscode.TaskProcessEndEvent) => {
+                    if (endEvent.execution === this.taskExecutor) {
+                        this.taskExecutor = undefined;
+                        disposable.dispose();
+                        resolve({ retc: endEvent.exitCode ?? null, stdout: '', stderr: '' });
+                    }
+                });
+            })};
+        }
         this.setBuildInProgress(true);
     }
 

src/cmakeTaskProvider.ts

@@ -240,20 +240,29 @@ export class CMakeTaskProvider implements vscode.TaskProvider {
         return undefined;
     }
 
-    public static async resolveInternalTask(task: CMakeTask): Promise<CMakeTask | undefined> {
+    public static async resolveInternalTask(task: CMakeTask): Promise<{ task: CMakeTask; exitCodePromise?: Promise<number | null> } | undefined> {
         const execution: any = task.execution;
         if (!execution) {
             const definition: CMakeTaskDefinition = <any>task.definition;
             // task.scope can be a WorkspaceFolder, TaskScope.Global, or TaskScope.Workspace.
             // Only use it as a WorkspaceFolder if it's an object (not a number or null).
             const workspaceFolder: vscode.WorkspaceFolder | undefined = (task.scope && typeof task.scope === 'object') ? task.scope as vscode.WorkspaceFolder : undefined;
+            let exitCodeResolve!: (exitCode: number | null) => void;
+            const exitCodePromise = new Promise<number | null>(resolve => {
+                exitCodeResolve = resolve;
+            });
             const resolvedTask: CMakeTask = new vscode.Task(definition, workspaceFolder ?? vscode.TaskScope.Workspace, definition.label, CMakeTaskProvider.CMakeSourceStr,
-                new vscode.CustomExecution(async (resolvedDefinition: vscode.TaskDefinition): Promise<vscode.Pseudoterminal> =>
-                    new CustomBuildTaskTerminal(resolvedDefinition.command, resolvedDefinition.targets, workspaceFolder, resolvedDefinition.preset, resolvedDefinition.options)
-                ), []);
-            return resolvedTask;
-        }
-        return task;
+                new vscode.CustomExecution(async (resolvedDefinition: vscode.TaskDefinition): Promise<vscode.Pseudoterminal> => {
+                    const terminal = new CustomBuildTaskTerminal(resolvedDefinition.command, resolvedDefinition.targets, workspaceFolder, resolvedDefinition.preset, resolvedDefinition.options);
+                    const listener = terminal.onDidClose((exitCode) => {
+                        listener.dispose();
+                        exitCodeResolve(exitCode);
+                    });
+                    return terminal;
+                }), []);
+            return { task: resolvedTask, exitCodePromise };
+        }
+        return { task };
     }
 
     public static async findBuildTask(workspaceFolder: string, presetName?: string, targets?: string[], expansionOptions?: expand.ExpansionOptions): Promise<CMakeTask | undefined> {

src/drivers/cmakeDriver.ts

@@ -2082,9 +2082,9 @@ export abstract class CMakeDriver implements vscode.Disposable {
             if (useBuildTask) {
                 const task: CMakeTask | undefined = await CMakeTaskProvider.findBuildTask(this.workspaceFolder, this._buildPreset?.name, targets, this.expansionOptions);
                 if (task) {
-                    const resolvedTask: CMakeTask | undefined = await CMakeTaskProvider.resolveInternalTask(task);
-                    if (resolvedTask) {
-                        await this.cmakeBuildRunner.setBuildProcessForTask(await vscode.tasks.executeTask(resolvedTask));
+                    const resolved = await CMakeTaskProvider.resolveInternalTask(task);
+                    if (resolved) {
+                        await this.cmakeBuildRunner.setBuildProcessForTask(await vscode.tasks.executeTask(resolved.task), resolved.exitCodePromise);
                     }
                 }
             } else {