Add a regexp for problem matching on the msvc linker output (#4675)

* add msvc linker problem matchers

* Update diagnostics tests to use regex for message validation. Chai doesn't have endsWith

* vscode copilot get_errors will only process errors that point to a file. link errors need a dummy file to point to. This is a work around. Perhaps the copilot, vscode and cmake-tools-teams need to talk to ensure llm agent workflow is robust

* Add support for collecting and writing linker errors to a file

* Add linker diagnostics handling and unit test for unique line numbers in linkerrors.txt

* changed things so lint passes

* changelog entry

---------

Co-authored-by: Brad Phelan <[email protected]>
Co-authored-by: Hannia Valera <[email protected]>

Author: 3 people

CHANGELOG.md

@@ -6,6 +6,9 @@ Features:
 - triple: Add riscv32be riscv64be support. [#4648](https://github.com/microsoft/vscode-cmake-tools/pull/4648) [@lygstate](https://github.com/lygstate)
 - Add command to clear build diagnostics from the Problems pane. [#4691](https://github.com/microsoft/vscode-cmake-tools/pull/4691)
 
+Improvements:
+- Add MSVC linker error problem matching to the Problems pane. [#4675](https://github.com/microsoft/vscode-cmake-tools/pull/4675) [@bradphelan](https://github.com/bradphelan)
+
 Bug Fixes:
 - Clarify that semicolons in `cmake.configureSettings` string values are escaped, and array notation should be used for CMake lists. [#4585](https://github.com/microsoft/vscode-cmake-tools/issues/4585)
 - Fix "CMake: Quick Start" command failing silently when no folder is open. Now shows an error message with an option to open a folder. [#4504](https://github.com/microsoft/vscode-cmake-tools/issues/4504)

src/diagnostics/build.ts

@@ -15,8 +15,9 @@ import * as gnu_ld from '@cmt/diagnostics/gnu-ld';
 import * as mvsc from '@cmt/diagnostics/msvc';
 import * as iar from '@cmt/diagnostics/iar';
 import * as iwyu from '@cmt/diagnostics/iwyu';
-import { FileDiagnostic, RawDiagnosticParser } from '@cmt/diagnostics/util';
+import { FileDiagnostic, RawDiagnostic, RawDiagnosticParser } from '@cmt/diagnostics/util';
 import { ConfigurationReader } from '@cmt/config';
+import { fs } from '@cmt/pr';
 
 export class Compilers {
     [compiler: string]: RawDiagnosticParser;
@@ -60,6 +61,7 @@ export class CompileOutputConsumer implements OutputConsumer {
 
     async resolveDiagnostics(...basePaths: string[]): Promise<FileDiagnostic[]> {
         const diags_by_file = new Map<string, vscode.Diagnostic[]>();
+        const linkerHandler = this.createLinkerDiagnosticsHandler(basePaths);
 
         const severity_of = (p: string) => {
             switch (p) {
@@ -91,13 +93,17 @@ export class CompileOutputConsumer implements OutputConsumer {
         const parsers = util.objectPairs(by_source)
             .filter(([source, _]) => this.config.enableOutputParsers?.includes(source.toLowerCase()) ?? false);
         const arrs: FileDiagnostic[] = [];
+
+        await linkerHandler.maybeEnsureFileFromDiagnostics(this.compilers.msvc.diagnostics);
         for (const [ source, diags ] of parsers) {
             for (const raw_diag of diags) {
+                await linkerHandler.collect(raw_diag, source, arrs.length);
                 const filepath = await this.resolvePath(raw_diag.file, basePaths);
                 const severity = severity_of(raw_diag.severity);
                 if (severity === undefined) {
                     continue;
                 }
+
                 const diag = new vscode.Diagnostic(raw_diag.location, raw_diag.message, severity);
                 diag.source = source;
                 if (raw_diag.code) {
@@ -119,8 +125,132 @@ export class CompileOutputConsumer implements OutputConsumer {
                 });
             }
         }
+
+        await linkerHandler.finalize(arrs);
+
         return arrs;
     }
+
+    /**
+     * Creates a handler that centralizes linker-only diagnostics logic.
+     *
+     * Why this exists:
+     * - MSVC linker diagnostics are emitted without a real source file path.
+     * - Copilot `get_errors` drops diagnostics that do not map to a file on disk.
+     * - We synthesize a real file (`linkerrors.txt`) and map all linker diagnostics
+     *   to it so tooling can surface the errors consistently.
+     *
+     * Responsibilities:
+     * - Ensure `linkerrors.txt` exists when linker diagnostics are present.
+     * - Collect linker diagnostics and keep a stable index mapping to `FileDiagnostic` entries.
+     * - Write a deterministic, line-based report file and then update diagnostic ranges
+     *   to point at the correct lines in that file.
+     *
+     * Line mapping details:
+     * - The file starts with a fixed header (5 lines plus a blank line).
+     * - Each linker diagnostic then occupies three lines: header, message, blank.
+     * - We store 1-based line numbers while building content and convert to 0-based
+     *   `vscode.Range` indices when updating diagnostics.
+     *
+     * This is intentionally isolated to keep non-linker diagnostic flow readable.
+     */
+    private createLinkerDiagnosticsHandler(basePaths: string[]) {
+        const linkErrorsFilename = 'linkerrors.txt';
+        const linkerErrors: { code: string; message: string; source: string; lineNumber: number }[] = [];
+        const linkerDiagIndexMap = new Map<number, number>(); // Maps linkerErrors index to arrs index
+        let ensuredLinkErrorsFile = false;
+
+        const ensureLinkErrorsFile = async () => {
+            if (ensuredLinkErrorsFile) {
+                return;
+            }
+            const buildDir = basePaths[0];
+            if (!buildDir) {
+                return;
+            }
+            const linkErrorsPath = util.resolvePath(linkErrorsFilename, buildDir);
+            if (!await util.checkFileExists(linkErrorsPath)) {
+                try {
+                    await fs.writeFile(linkErrorsPath, '');
+                } catch {
+                    // Best-effort: if this fails, diagnostics will still resolve to the path.
+                }
+            }
+            ensuredLinkErrorsFile = true;
+        };
+
+        const maybeEnsureFileFromDiagnostics = async (diagnostics: readonly RawDiagnostic[]) => {
+            if (diagnostics.some(diag => diag.file === linkErrorsFilename)) {
+                await ensureLinkErrorsFile();
+            }
+        };
+
+        const collect = async (raw_diag: RawDiagnostic, source: string, arrsIndex: number) => {
+            if (raw_diag.file !== linkErrorsFilename) {
+                return;
+            }
+            await ensureLinkErrorsFile();
+            const linkerErrorIndex = linkerErrors.length;
+            linkerErrors.push({
+                code: raw_diag.code || 'LNK0000',
+                message: raw_diag.message,
+                source: source,
+                lineNumber: -1  // Will be set when building file content
+            });
+            linkerDiagIndexMap.set(linkerErrorIndex, arrsIndex);
+        };
+
+        const finalize = async (arrs: FileDiagnostic[]) => {
+            if (linkerErrors.length === 0) {
+                return;
+            }
+
+            const buildDir = basePaths[0];
+            if (!buildDir) {
+                return;
+            }
+
+            const linkErrorsPath = util.resolvePath(linkErrorsFilename, buildDir);
+            const timestamp = new Date().toISOString();
+            const lines: string[] = [
+                '================================================================================',
+                'Linker Errors',
+                `Generated: ${timestamp}`,
+                `Total Errors: ${linkerErrors.length}`,
+                '================================================================================',
+                ''
+            ];
+
+            // Hack: write a real file so Copilot get_errors does not drop diagnostics without a source file.
+            for (const err of linkerErrors) {
+                err.lineNumber = lines.length + 1;
+                lines.push(`[${err.code}] (${err.source})`);
+                lines.push(err.message);
+                lines.push('');
+            }
+
+            try {
+                await fs.writeFile(linkErrorsPath, lines.join('\n'));
+
+                // Now update the line numbers in the diagnostics using the index mapping
+                linkerDiagIndexMap.forEach((arrsIndex, linkerErrorIndex) => {
+                    const errorInfo = linkerErrors[linkerErrorIndex];
+                    if (errorInfo && errorInfo.lineNumber >= 0 && arrsIndex < arrs.length) {
+                        const line = errorInfo.lineNumber - 1; // VS Code uses 0-based line numbers
+                        arrs[arrsIndex].diag.range = new vscode.Range(line, 0, line, 999);
+                    }
+                });
+            } catch {
+                // Best-effort: if writing fails, diagnostics are still available in Problems panel
+            }
+        };
+
+        return {
+            maybeEnsureFileFromDiagnostics,
+            collect,
+            finalize
+        };
+    }
 }
 
 /**

src/diagnostics/msvc.ts

@@ -8,39 +8,69 @@ import { oneLess, RawDiagnosticParser, FeedLineResult } from '@cmt/diagnostics/u
 
 export const REGEX = /^\s*(\d+>)?\s*([^\s>].*)\((\d+|\d+,\d+|\d+,\d+,\d+,\d+)\)\s*:\s+((?:fatal )?error|warning|info)\s*(\w{1,2}\d+)?\s*:\s*(.*)$/;
 
+// Regex for MSVC linker errors with optional file prefix, e.g.
+// '[build] LINK : error LNK2001: message'
+// '[build] foo.obj : error LNK2019: message'
+// 'fatal error LNK1104: cannot open file'
+// Matches MSVC linker errors in multiple formats:
+// '[build] LINK : error LNK####: message'
+// '[build] foo.obj : error LNK####: message'
+// 'fatal error LNK####: message'
+// Handles flexible spacing: colons with or without spaces
+export const LINKER_REGEX =
+    /^\s*(?:\[[^\]]*\])?\s*(?:(.+?)\s*:\s*)?((?:fatal\s+)?error|warning|info)\s+(LNK\d+)\s*:\s*(.*)$/;
+
 export class Parser extends RawDiagnosticParser {
     doHandleLine(line: string) {
-        const res = REGEX.exec(line);
-        if (!res) {
-            return FeedLineResult.NotMine;
+        // Try the linker error regex first (handles LINK prefix, file prefix, or standalone)
+        // Must be checked before compiler regex since linker errors can look similar
+        let res = LINKER_REGEX.exec(line);
+        if (res) {
+            const [full, _file, severity, code, message] = res;
+            return {
+                full,
+                file: 'linkerrors.txt',
+                location: new vscode.Range(0, 0, 0, 999),
+                severity,
+                message,
+                code,
+                related: []
+            };
+        }
+
+        // Then try the standard compiler diagnostic regex
+        res = REGEX.exec(line);
+        if (res) {
+            const [full, /* proc*/, file, location, severity, code, message] = res;
+            const range = (() => {
+                const parts = location.split(',');
+                const n0 = oneLess(parts[0]);
+                if (parts.length === 1) {
+                    return new vscode.Range(n0, 0, n0, 999);
+                }
+                if (parts.length === 2) {
+                    const n1 = oneLess(parts[1]);
+                    return new vscode.Range(n0, n1, n0, n1);
+                }
+                if (parts.length === 4) {
+                    const n1 = oneLess(parts[1]);
+                    const n2 = oneLess(parts[2]);
+                    const n3 = oneLess(parts[3]);
+                    return new vscode.Range(n0, n1, n2, n3);
+                }
+                throw new Error('Unable to determine location of MSVC diagnostic');
+            })();
+            return {
+                full,
+                file,
+                location: range,
+                severity,
+                message,
+                code,
+                related: []
+            };
         }
-        const [full, /* proc*/, file, location, severity, code, message] = res;
-        const range = (() => {
-            const parts = location.split(',');
-            const n0 = oneLess(parts[0]);
-            if (parts.length === 1) {
-                return new vscode.Range(n0, 0, n0, 999);
-            }
-            if (parts.length === 2) {
-                const n1 = oneLess(parts[1]);
-                return new vscode.Range(n0, n1, n0, n1);
-            }
-            if (parts.length === 4) {
-                const n1 = oneLess(parts[1]);
-                const n2 = oneLess(parts[2]);
-                const n3 = oneLess(parts[3]);
-                return new vscode.Range(n0, n1, n2, n3);
-            }
-            throw new Error('Unable to determine location of MSVC diagnostic');
-        })();
-        return {
-            full,
-            file,
-            location: range,
-            severity,
-            message,
-            code,
-            related: []
-        };
+
+        return FeedLineResult.NotMine;
     }
 }