Add problemMatcher override and finish the implementation

Author: bobbrow

Extension/package.json

@@ -619,6 +619,13 @@
                                         "description": "%c_cpp.taskDefinitions.options.cwd.description%"
                                     }
                                 }
+                            },
+                            "problemMatcher": {
+                                "type": "array",
+                                "description": "%c_cpp.taskDefinitions.problemMatcher.description%",
+                                "items": {
+                                    "type": "string"
+                                }
                             }
                         }
                     },
@@ -708,6 +715,13 @@
                                         "description": "%c_cpp.taskDefinitions.options.cwd.description%"
                                     }
                                 }
+                            },
+                            "problemMatcher": {
+                                "type": "array",
+                                "description": "%c_cpp.taskDefinitions.problemMatcher.description%",
+                                "items": {
+                                    "type": "string"
+                                }
                             }
                         }
                     },
@@ -797,6 +811,13 @@
                                         "description": "%c_cpp.taskDefinitions.options.cwd.description%"
                                     }
                                 }
+                            },
+                            "problemMatcher": {
+                                "type": "array",
+                                "description": "%c_cpp.taskDefinitions.problemMatcher.description%",
+                                "items": {
+                                    "type": "string"
+                                }
                             }
                         }
                     }

Extension/package.nls.json

@@ -1005,6 +1005,7 @@
     "c_cpp.taskDefinitions.args.quoting.weak.description": "Quotes the argument using the shell's weak quote character (e.g. \" under bash).",
     "c_cpp.taskDefinitions.options.description": "Additional command options.",
     "c_cpp.taskDefinitions.options.cwd.description": "The current working directory of the executed program or script. If omitted Code's current workspace root is used.",
+    "c_cpp.taskDefinitions.problemMatcher.description": "One or more problem matchers to use to detect compiler errors and warnings in task output.",
     "c_cpp.taskDefinitions.detail.description": "Additional details of the task.",
     "c_cpp.debuggers.sourceFileMap.sourceFileMapEntry.description": "Current and compile-time paths to the same source trees. Files found under the EditorPath are mapped to the CompileTimePath path for breakpoint matching and mapped from CompileTimePath to EditorPath when displaying stacktrace locations.",
     "c_cpp.debuggers.sourceFileMap.sourceFileMapEntry.editorPath.description": "The path to the source tree the editor will use.",

Extension/src/LanguageServer/cppBuildTaskProvider.ts

@@ -25,7 +25,17 @@ export interface CppBuildTaskDefinition extends TaskDefinition {
     label: string; // The label appears in tasks.json file.
     command: string | util.IQuotedString;
     args: (string | util.IQuotedString)[];
-    options: cp.ExecOptions | cp.SpawnOptions | undefined;
+    options: cp.ExecOptions | undefined;
+    windows?: CppBuildTaskPlatformOverride;
+    linux?: CppBuildTaskPlatformOverride;
+    osx?: CppBuildTaskPlatformOverride;
+}
+
+interface CppBuildTaskPlatformOverride {
+    command?: string | util.IQuotedString;
+    args?: (string | util.IQuotedString)[];
+    options?: cp.ExecOptions | undefined;
+    problemMatcher?: string | string[];
 }
 
 export class CppBuildTask extends Task {
@@ -50,7 +60,7 @@ export class CppBuildTaskProvider implements TaskProvider {
         const execution: ProcessExecution | ShellExecution | CustomExecution | undefined = _task.execution;
         if (!execution) {
             const definition: CppBuildTaskDefinition = <any>_task.definition;
-            _task = this.getTask(definition.command, false, definition.args ? definition.args : [], definition, _task.detail);
+            _task = this.getTask(definition, _task.detail);
             return _task;
         }
         return undefined;
@@ -59,7 +69,7 @@ export class CppBuildTaskProvider implements TaskProvider {
     public resolveInsiderTask(_task: CppBuildTask): CppBuildTask | undefined {
         const definition: CppBuildTaskDefinition = <any>_task.definition;
         definition.label = definition.label.replace(ext.configPrefix, "");
-        _task = this.getTask(definition.command, false, definition.args ? definition.args : [], definition, _task.detail);
+        _task = this.getTask(definition, _task.detail);
         return _task;
     }
 
@@ -152,83 +162,118 @@ export class CppBuildTaskProvider implements TaskProvider {
             return emptyTasks;
         }
 
-        // Create a build task per compiler path
+        // Create a build task per compiler path.
         const result: CppBuildTask[] = [];
 
-        // Task for valid user compiler path setting
+        // Task for valid user compiler path setting.
         if (isCompilerValid && userCompilerPath) {
-            result.push(this.getTask(userCompilerPath, appendSourceToName, userCompilerPathAndArgs?.allCompilerArgs));
+            result.push(this.generateTask(userCompilerPath, appendSourceToName, userCompilerPathAndArgs?.allCompilerArgs));
         }
 
-        // Tasks for known compiler paths
+        // Tasks for known compiler paths.
         if (knownCompilerPaths) {
-            result.push(...knownCompilerPaths.map<Task>(compilerPath => this.getTask(compilerPath, appendSourceToName, undefined)));
+            result.push(...knownCompilerPaths.map<CppBuildTask>(compilerPath => this.generateTask(compilerPath, appendSourceToName, undefined)));
         }
 
         return result;
     }
 
-    private getTask: (compilerPath: string | util.IQuotedString, appendSourceToName: boolean, compilerArgs?: (string | util.IQuotedString)[], definition?: CppBuildTaskDefinition, detail?: string) => Task = (compilerPath: string | util.IQuotedString, appendSourceToName: boolean, compilerArgs?: (string | util.IQuotedString)[], definition?: CppBuildTaskDefinition, detail?: string) => {
+    private generateTask(compilerPath: string | util.IQuotedString, appendSourceToName: boolean, compilerArgs?: (string | util.IQuotedString)[]): CppBuildTask {
         const compilerPathString: string = util.isString(compilerPath) ? compilerPath : compilerPath.value;
-        const compilerPathBase: string = path.basename(compilerPathString);
-        const isCl: boolean = compilerPathBase.toLowerCase() === "cl.exe";
-        const isClang: boolean = !isCl && compilerPathBase.toLowerCase().includes("clang");
-        // Double-quote the command if needed.
-        const resolvedCompilerPathString: string = isCl ? compilerPathBase : compilerPathString;
-        let resolvedCompilerPath: string | util.IQuotedString = compilerPath;
-        if (isCl) {
-            resolvedCompilerPath = compilerPathBase;
-        }
-
-        if (!definition) {
-            const isWindows: boolean = os.platform() === 'win32';
-            const taskLabel: string = ((appendSourceToName && !compilerPathBase.startsWith(ext.configPrefix)) ?
-                ext.configPrefix : "") + compilerPathBase + " " + localize("build.active.file", "build active file");
-            const programName: string = util.defaultExePath();
-            let args: (string | util.IQuotedString)[] = isCl ?
-                ['/Zi', '/EHsc', '/nologo', `/Fe${programName}`, '${file}'] :
-                isClang ?
-                    ['-fcolor-diagnostics', '-fansi-escape-codes', '-g', '${file}', '-o', programName] :
-                    ['-fdiagnostics-color=always', '-g', '${file}', '-o', programName];
-
-            if (compilerArgs && compilerArgs.length > 0) {
-                args = args.concat(compilerArgs);
-            }
-            const cwd: string = isWindows && !isCl && !process.env.PATH?.includes(path.dirname(compilerPathString)) ? path.dirname(compilerPathString) : "${fileDirname}";
-            const options: cp.ExecOptions | cp.SpawnOptions | undefined = { cwd: cwd };
-            definition = {
-                type: CppBuildTaskProvider.CppBuildScriptType,
-                label: taskLabel,
-                command: compilerPath,
-                args: args,
-                options: options
-            };
-            if (isCl) {
-                definition.command = compilerPathBase;
-            }
+        const compilerName: string = path.basename(compilerPathString);
+        const isCl: boolean = compilerName.toLowerCase() === "cl.exe";
+        const isClang: boolean = !isCl && compilerName.toLowerCase().includes("clang");
+
+        const isWindows: boolean = os.platform() === 'win32';
+        const taskLabel: string = ((appendSourceToName && !compilerName.startsWith(ext.configPrefix)) ?
+            ext.configPrefix : "") + compilerName + " " + localize("build.active.file", "build active file");
+        const programName: string = util.defaultExePath();
+        let args: (string | util.IQuotedString)[] = isCl ?
+            ['/Zi', '/EHsc', '/nologo', `/Fe${programName}`, '${file}'] :
+            isClang ?
+                ['-fcolor-diagnostics', '-fansi-escape-codes', '-g', '${file}', '-o', programName] :
+                ['-fdiagnostics-color=always', '-g', '${file}', '-o', programName];
+
+        if (compilerArgs && compilerArgs.length > 0) {
+            args = args.concat(compilerArgs);
         }
+        const cwd: string = isWindows && !isCl && !process.env.PATH?.includes(path.dirname(compilerPathString)) ? path.dirname(compilerPathString) : "${fileDirname}";
+        const options: cp.ExecOptions | undefined = { cwd: cwd };
+        const definition: CppBuildTaskDefinition = {
+            type: CppBuildTaskProvider.CppBuildScriptType,
+            label: taskLabel,
+            command: isCl ? compilerName : compilerPath,
+            args: args,
+            options: options
+        };
+
+        return this.getTask(definition);
+    }
+
+    private getTask(definition: CppBuildTaskDefinition, detail?: string): CppBuildTask {
+        const platformDefinition: CppBuildTaskDefinition = this.applyPlatformOverrides(definition);
+        const command: string = util.isString(platformDefinition.command) ? platformDefinition.command : platformDefinition.command.value;
+        const compilerName: string = path.basename(command);
+        const isCl: boolean = compilerName.toLowerCase() === "cl.exe";
+        const isClang: boolean = !isCl && compilerName.toLowerCase().includes("clang");
 
         const editor: TextEditor | undefined = window.activeTextEditor;
         const folder: WorkspaceFolder | undefined = editor ? workspace.getWorkspaceFolder(editor.document.uri) : undefined;
 
-        const taskUsesActiveFile: boolean = definition.args.some(arg => {
+        const taskUsesActiveFile: boolean = platformDefinition.args.some(arg => {
             if (util.isString(arg)) {
                 return arg.indexOf('${file}') >= 0;
             }
             return arg.value.indexOf('${file}') >= 0;
         }); // Need to check this before ${file} is resolved
         const scope: WorkspaceFolder | TaskScope = folder ? folder : TaskScope.Workspace;
-        const task: CppBuildTask = new Task(definition, scope, definition.label, ext.CppSourceStr,
-            new CustomExecution(async (resolvedDefinition: TaskDefinition): Promise<Pseudoterminal> =>
-                // When the task is executed, this callback will run. Here, we setup for running the task.
-                new CustomBuildTaskTerminal(resolvedCompilerPath, resolvedDefinition.args, resolvedDefinition.options, { taskUsesActiveFile, insertStd: isClang && os.platform() === 'darwin' })
-            ), isCl ? '$msCompile' : '$gcc');
+        const customExecution: CustomExecution = new CustomExecution(async (resolvedDefinition: TaskDefinition): Promise<Pseudoterminal> => {
+            // When the task is executed, this callback will run. Here, we setup for running the task.
+            // Apply platform-specific overrides (windows/linux/osx) at execution time so that VS Code
+            // can still match the task definition by its original shape during the resolve phase.
+            const effectiveDefinition: CppBuildTaskDefinition = this.applyPlatformOverrides(resolvedDefinition as CppBuildTaskDefinition);
+            const effectiveArgs: (string | util.IQuotedString)[] = effectiveDefinition.args ? effectiveDefinition.args : [];
+            return new CustomBuildTaskTerminal(
+                effectiveDefinition.command,
+                effectiveArgs,
+                effectiveDefinition.options,
+                { taskUsesActiveFile, insertStd: isClang && os.platform() === 'darwin' }
+            );
+        });
+        const task: CppBuildTask = new CppBuildTask(definition, scope, definition.label, ext.CppSourceStr, customExecution, isCl ? '$msCompile' : '$gcc');
 
         task.group = TaskGroup.Build;
-        task.detail = detail ? detail : localize("compiler.details", "compiler:") + " " + resolvedCompilerPathString;
+        task.detail = detail ? detail : localize("compiler.details", "compiler:") + " " + (isCl ? compilerName : command);
 
         return task;
-    };
+    }
+
+    private applyPlatformOverrides(definition: CppBuildTaskDefinition): CppBuildTaskDefinition {
+        const platform: NodeJS.Platform = os.platform();
+        let platformOverride: CppBuildTaskPlatformOverride | undefined;
+
+        if (platform === 'win32') {
+            platformOverride = definition.windows;
+        } else if (platform === 'linux') {
+            platformOverride = definition.linux;
+        } else if (platform === 'darwin') {
+            platformOverride = definition.osx;
+        }
+
+        if (!platformOverride) {
+            return definition;
+        }
+
+        const mergedDefinition: CppBuildTaskDefinition = {
+            ...definition,
+            command: platformOverride.command ?? definition.command,
+            args: platformOverride.args ?? definition.args,
+            options: platformOverride.options ?? definition.options,
+            problemMatcher: platformOverride.problemMatcher ?? definition.problemMatcher
+        };
+
+        return mergedDefinition;
+    }
 
     public async getJsonTasks(): Promise<CppBuildTask[]> {
         const rawJson: any = await this.getRawTasksJson();
@@ -244,7 +289,7 @@ export class CppBuildTaskProvider implements TaskProvider {
                 args: task.args,
                 options: task.options
             };
-            const cppBuildTask: CppBuildTask = new Task(definition, TaskScope.Workspace, task.label, ext.CppSourceStr);
+            const cppBuildTask: CppBuildTask = new CppBuildTask(definition, TaskScope.Workspace, task.label, ext.CppSourceStr);
             cppBuildTask.detail = task.detail;
             cppBuildTask.existing = true;
             if (util.isObject(task.group) && task.group.isDefault) {

Extension/tools/TaskDefinitionsSchema.json

@@ -67,6 +67,13 @@
                 },
                 "options": {
                     "$ref": "#/definitions/CppBuildTaskOptions"
+                },
+                "problemMatcher": {
+                    "type": "array",
+                    "description": "%c_cpp.taskDefinitions.problemMatcher.description%",
+                    "items": {
+                        "type": "string"
+                    }
                 }
             }
         },