Merge branch 'main' into copilot/fix-bookmarks-behavior

Author: Omotola

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## 1.23
 
 Features:
+- Add `cmake.shell` setting to route CMake/CTest/CPack subprocess invocations through a custom shell (e.g., Git Bash, MSYS2), enabling embedded toolchains that require POSIX path translation on Windows. [#1750](https://github.com/microsoft/vscode-cmake-tools/issues/1750)
 - 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)
 - Clear build diagnostics from the Problems pane when a new build starts and populate them incrementally during the build. [#4608](https://github.com/microsoft/vscode-cmake-tools/issues/4608)
@@ -14,6 +15,7 @@ Features:
 - Support `targetName` argument for launch-target command substitutions (`cmake.launchTargetPath`, etc.) via `${input:...}` variables, enabling build-before-run for non-active executable targets without changing the active launch target. [#4656](https://github.com/microsoft/vscode-cmake-tools/issues/4656)
 
 Improvements:
+- Clicking on a CTest in the Project Outline now navigates to the test source file, matching the existing Test Explorer behavior. [#4773](https://github.com/microsoft/vscode-cmake-tools/issues/4773)
 - Clicking on a CTest unit test in the Test Explorer now navigates to the test source file by matching the test executable to its CMake target's source files. [#4449](https://github.com/microsoft/vscode-cmake-tools/issues/4449)
 - Make "CMake: Add ... Preset" commands available in the command palette when `cmake.useCMakePresets` is set to `auto`, even before a CMakePresets.json file exists. [#4401](https://github.com/microsoft/vscode-cmake-tools/issues/4401)
 - Improve CMake syntax highlighting with command-scoped keyword rules, expanded variable recognition, and better generator-expression support. Remove obsolete deprecated-keyword entries that caused false positives on user-defined names. [#4709](https://github.com/microsoft/vscode-cmake-tools/issues/4709) [#4508](https://github.com/microsoft/vscode-cmake-tools/issues/4508) [#4613](https://github.com/microsoft/vscode-cmake-tools/issues/4613)
@@ -22,6 +24,7 @@ Improvements:
 - Allow preset modification commands to target CMakeUserPresets.json. The target file is determined by the focused editor, or by prompting the user when both files exist. [#4564](https://github.com/microsoft/vscode-cmake-tools/issues/4564)
 - Display info tooltip when hovering over CMake policy identifiers (e.g., `CMP0177`), showing the CMake version that introduced the policy, a short description, and a link to the official documentation. [#4544](https://github.com/microsoft/vscode-cmake-tools/issues/4544)
 - Append `cmake` to diagnostics that this extension contributes to the Problems Pane. [PR #4766](https://github.com/microsoft/vscode-cmake-tools/pull/4766)
+- 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 bookmarked targets running a full build instead of building only the specific target when triggered from the Bookmarks view. [#4771](https://github.com/microsoft/vscode-cmake-tools/issues/4771)

docs/cmake-settings.md

@@ -78,6 +78,7 @@ Options that support substitution, in the table below, allow variable references
 | `cmake.saveBeforeBuild` | If `true` (the default), saves open text documents when build or configure is invoked before running CMake. | `true` | no |
 | `cmake.setBuildTargetSameAsLaunchTarget` | If `true`, setting the launch/debug target automatically sets the build target to match. | `false` | no |
 | `cmake.setBuildTypeOnMultiConfig` | If `true`, set build type on multi-config generators. | `false` | no |
+| `cmake.shell` | Path to a shell executable to route all CMake/CTest/CPack subprocess invocations through (e.g., Git Bash or MSYS2). Useful for embedded toolchains that require POSIX path translation on Windows. When `null`, the default system shell behavior is used. | `null` | no |
 | `cmake.showConfigureWithDebuggerNotification` | If `true`, show notification when configure with debugger. | `true` | no |
 | `cmake.showNotAllDocumentsSavedQuestion` | If `true`, show not all documents saved question. | `true` | no |
 | `cmake.showSystemKits` | If `true`, show system kits in kit selection. | `true` | no |

package.json

@@ -2394,6 +2394,15 @@
           "description": "%cmake-tools.configuration.cmake.platform.description%",
           "scope": "resource"
         },
+        "cmake.shell": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "default": null,
+          "description": "%cmake-tools.configuration.cmake.shell.description%",
+          "scope": "resource"
+        },
         "cmake.configureArgs": {
           "type": "array",
           "description": "%cmake-tools.configuration.cmake.configureArgs.description%",

package.nls.json

@@ -121,6 +121,7 @@
     "cmake-tools.configuration.cmake.generator.description": "The CMake generator to use.",
     "cmake-tools.configuration.cmake.toolset.description": "The CMake toolset to use when configuring.",
     "cmake-tools.configuration.cmake.platform.description": "The CMake platform to use when configuring.",
+    "cmake-tools.configuration.cmake.shell.description": "Path to a shell executable to use when running CMake, CTest, and CPack commands (e.g., Git Bash or MSYS2). When set, all subprocess invocations are routed through this shell. Useful for embedded toolchains that require POSIX path translation. When null, the default system shell behavior is used.",
     "cmake-tools.configuration.cmake.configureArgs.description": "Additional arguments to pass to CMake when configuring. When using CMake Presets, these arguments are temporarily appended to the arguments provided by the active configure preset.",
     "cmake-tools.configuration.cmake.buildArgs.description": "Additional arguments to pass to CMake when building. When using CMake Presets, these arguments are temporarily appended to the arguments provided by the active build preset.",
     "cmake-tools.configuration.cmake.buildToolArgs.description": "Additional arguments to pass to the underlying build tool when building. When using CMake Presets, these arguments are temporarily appended to the arguments provided by the active build preset to invoke the build tool.",

src/cmakeProject.ts

@@ -847,6 +847,11 @@ export class CMakeProject {
         await this.reloadCMakeDriver();
     });
 
+    private readonly shellSub = this.workspaceContext.config.onChange('shell', async () => {
+        log.info(localize('shell.changed.restart.driver', "Restarting the CMake driver after a shell change."));
+        await this.reloadCMakeDriver();
+    });
+
     /**
      * The variant manager keeps track of build variants. Has two-phase init.
      */
@@ -890,7 +895,8 @@ export class CMakeProject {
             this.generatorSub,
             this.preferredGeneratorsSub,
             this.communicationModeSub,
-            this.cmakePathSub
+            this.cmakePathSub,
+            this.shellSub
         ]) {
             sub.dispose();
         }

src/cmakeTaskProvider.ts

@@ -587,7 +587,10 @@ export class CustomBuildTaskTerminal extends proc.CommandConsumer implements vsc
         this.writeEmitter.fire(localize("build.started", "{0} task started....", taskName) + endOfLine);
         this.writeEmitter.fire(proc.buildCmdStr(cmakePath, args) + endOfLine);
         try {
-            this._process = proc.execute(cmakePath, args, this, this.options);
+            // On Windows, command-type-specific detection takes precedence over config.shell
+            const commandShell = process.platform === 'win32' ? proc.determineShell(cmakePath) : false;
+            const shell = (commandShell || undefined) ?? cmakeDriver.config.shell ?? undefined;
+            this._process = proc.execute(cmakePath, args, this, { ...this.options, shell });
             const result: proc.ExecutionResult = await this._process.result;
             this._process = undefined;
             if (result.retc) {

src/config.ts

@@ -237,6 +237,7 @@ export interface ExtensionConfigurationSettings {
     useFolderPropertyInBuildTargetDropdown: boolean;
     setBuildTargetSameAsLaunchTarget: boolean;
     additionalBuildProblemMatchers: BuildProblemMatcherConfig[];
+    shell: string | null;
 }
 
 type EmittersOf<T> = {
@@ -628,6 +629,10 @@ export class ConfigurationReader implements vscode.Disposable {
         return this.configData.useFolderPropertyInBuildTargetDropdown;
     }
 
+    get shell(): string | null {
+        return this.configData.shell;
+    }
+
     get setBuildTargetSameAsLaunchTarget(): boolean {
         return this.configData.setBuildTargetSameAsLaunchTarget;
     }
@@ -703,8 +708,9 @@ export class ConfigurationReader implements vscode.Disposable {
         postRunCoverageTarget: new vscode.EventEmitter<string | null>(),
         coverageInfoFiles: new vscode.EventEmitter<string[]>(),
         useFolderPropertyInBuildTargetDropdown: new vscode.EventEmitter<boolean>(),
-        setBuildTargetSameAsLaunchTarget: new vscode.EventEmitter<boolean>(),
-        additionalBuildProblemMatchers: new vscode.EventEmitter<BuildProblemMatcherConfig[]>()
+        additionalBuildProblemMatchers: new vscode.EventEmitter<BuildProblemMatcherConfig[]>(),
+        shell: new vscode.EventEmitter<string | null>(),
+        setBuildTargetSameAsLaunchTarget: new vscode.EventEmitter<boolean>()
     };
 
     /**

src/ctest.ts

@@ -5,6 +5,7 @@ import * as xml2js from 'xml2js';
 import * as zlib from 'zlib';
 
 import { CMakeDriver } from '@cmt/drivers/drivers';
+import { CodeModelContent } from '@cmt/drivers/codeModel';
 import * as logging from '@cmt/logging';
 import { fs } from '@cmt/pr';
 import * as util from '@cmt/util';
@@ -782,9 +783,8 @@ export class CTestDriver implements vscode.Disposable {
      * Builds a map from normalized executable paths to source file information
      * by looking at the code model content from the CMake driver.
      */
-    private buildExecutableToSourcesMap(driver: CMakeDriver): Map<string, { sourceDir: string; sources: string[] }> {
+    private buildExecutableToSourcesMap(codeModelContent: CodeModelContent | null): Map<string, { sourceDir: string; sources: string[] }> {
         const map = new Map<string, { sourceDir: string; sources: string[] }>();
-        const codeModelContent = driver.codeModelContent;
         if (!codeModelContent) {
             return map;
         }
@@ -812,6 +812,61 @@ export class CTestDriver implements vscode.Disposable {
         return map;
     }
 
+    /**
+     * Resolves the source file and line number for a single CTest test entry.
+     * Uses a 3-step priority:
+     *  1) DEF_SOURCE_LINE test property
+     *  2) Code model executable-to-sources matching
+     *  3) Backtrace graph (falls back to CMakeLists.txt)
+     */
+    private resolveTestSourceLocation(
+        test: CTestInfo['tests'][0],
+        executableToSources: Map<string, { sourceDir: string; sources: string[] }> | undefined,
+        backtraceGraph: CTestInfo['backtraceGraph'] | undefined
+    ): { file?: string; line?: number } {
+        let file: string | undefined;
+        let line: number | undefined;
+
+        // 1. Use DEF_SOURCE_LINE CMake test property
+        const defSourceLineProperty = test.properties.filter(p => p.name === "DEF_SOURCE_LINE")[0];
+        if (defSourceLineProperty && defSourceLineProperty.value && typeof defSourceLineProperty.value === 'string') {
+            const match = defSourceLineProperty.value.match(/(.*):(\d+)/);
+            if (match && match[1] && match[2]) {
+                file = match[1];
+                line = parseInt(match[2]);
+                if (isNaN(line)) {
+                    line = undefined;
+                    file = undefined;
+                }
+            }
+        }
+
+        // 2. Match test executable to CMake target sources
+        if (!file && test.command && test.command.length > 0 && executableToSources) {
+            const testExe = util.platformNormalizePath(test.command[0]);
+            const targetInfo = executableToSources.get(testExe);
+            if (targetInfo && targetInfo.sources.length > 0) {
+                file = path.resolve(targetInfo.sourceDir, targetInfo.sources[0]);
+                line = 1;
+            }
+        }
+
+        // 3. Backtrace graph (falls back to CMakeLists.txt)
+        if (!file && backtraceGraph) {
+            const nodes = backtraceGraph.nodes;
+            if (test.backtrace !== undefined && nodes[test.backtrace] !== undefined) {
+                let node = nodes[test.backtrace];
+                while (node.parent !== undefined && nodes[node.parent].command !== undefined) {
+                    node = nodes[node.parent];
+                }
+                file = backtraceGraph.files[node.file];
+                line = node.line;
+            }
+        }
+
+        return { file, line };
+    }
+
     private createTestItemAndSuiteTree(testName: string, testExplorerRoot: vscode.TestItem, initializedTestExplorer: vscode.TestController, uri?: vscode.Uri): TestAndParentSuite {
         let parentSuiteItem = testExplorerRoot;
         let testLabel = testName;
@@ -883,49 +938,10 @@ export class CTestDriver implements vscode.Disposable {
         } else if (testType === "CTestInfo" && this.tests !== undefined) {
             if (this.tests && this.tests.kind === 'ctestInfo') {
                 // Build a map from executable paths to source files using the code model
-                const executableToSources = this.buildExecutableToSourcesMap(driver);
+                const executableToSources = this.buildExecutableToSourcesMap(driver.codeModelContent);
 
                 this.tests.tests.forEach(test => {
-                    let testDefFile: string | undefined;
-                    let testDefLine: number | undefined;
-
-                    // Use DEF_SOURCE_LINE CMake test property to find file and line number
-                    // Property must be set in the test's CMakeLists.txt file or its included modules for this to work
-                    const defSourceLineProperty = test.properties.filter(property => property.name === "DEF_SOURCE_LINE")[0];
-                    if (defSourceLineProperty && defSourceLineProperty.value && typeof defSourceLineProperty.value === 'string') {
-                        // Use RegEx to match the format "file_path:line" in value[0]
-                        const match = defSourceLineProperty.value.match(/(.*):(\d+)/);
-                        if (match && match[1] && match[2]) {
-                            testDefFile = match[1];
-                            testDefLine = parseInt(match[2]);
-                            if (isNaN(testDefLine)) {
-                                testDefLine = undefined;
-                                testDefFile = undefined;
-                            }
-                        }
-                    }
-
-                    // Try to find the test source file by matching the test executable to a CMake target
-                    if (!testDefFile && test.command && test.command.length > 0) {
-                        const testExe = util.platformNormalizePath(test.command[0]);
-                        const targetInfo = executableToSources.get(testExe);
-                        if (targetInfo && targetInfo.sources.length > 0) {
-                            testDefFile = path.resolve(targetInfo.sourceDir, targetInfo.sources[0]);
-                            testDefLine = 1;
-                        }
-                    }
-
-                    const nodes = this.tests!.backtraceGraph.nodes;
-                    if (!testDefFile && test.backtrace !== undefined && nodes[test.backtrace] !== undefined) {
-                        // Use the backtrace graph to find the file and line number
-                        // This finds the CMake module's file and line number and not the test file and line number
-                        let node = nodes[test.backtrace];
-                        while (node.parent !== undefined && nodes[node.parent].command !== undefined) {
-                            node = nodes[node.parent];
-                        }
-                        testDefFile = this.tests!.backtraceGraph.files[node.file];
-                        testDefLine = node.line;
-                    }
+                    const { file: testDefFile, line: testDefLine } = this.resolveTestSourceLocation(test, executableToSources, this.tests!.backtraceGraph);
 
                     const testAndParentSuite = this.createTestItemAndSuiteTree(test.name, testExplorerRoot, initializedTestExplorer, testDefFile ? vscode.Uri.file(testDefFile) : undefined);
                     const testItem = testAndParentSuite.test;
@@ -1048,14 +1064,23 @@ export class CTestDriver implements vscode.Disposable {
 
     /**
      * Returns test information suitable for the project outline view.
-     * Each entry maps a test name to its executable path.
+     * Each entry maps a test name to its executable path and optionally
+     * the resolved source file path for click-to-navigate.
      */
-    getTestsForOutline(): { name: string; executablePath: string }[] {
+    getTestsForOutline(codeModelContent?: CodeModelContent | null): { name: string; executablePath: string; sourceFilePath?: string; sourceFileLine?: number }[] {
         if (this.tests) {
-            return this.tests.tests.map(test => ({
-                name: test.name,
-                executablePath: test.command[0]
-            }));
+            const executableToSources = codeModelContent ? this.buildExecutableToSourcesMap(codeModelContent) : undefined;
+
+            return this.tests.tests.map(test => {
+                const { file: sourceFilePath, line: sourceFileLine } = this.resolveTestSourceLocation(test, executableToSources, this.tests!.backtraceGraph);
+
+                return {
+                    name: test.name,
+                    executablePath: test.command[0],
+                    sourceFilePath,
+                    sourceFileLine
+                };
+            });
         }
         return [];
     }

src/debug/cmakeDebugger/debuggerScriptDriver.ts

@@ -46,7 +46,10 @@ export async function executeScriptWithDebugger(scriptPath: string, scriptArgs:
             cmakeLogger.info(localize('run.script', "Executing CMake script: {0}", scriptPath));
 
             const env = EnvironmentUtils.merge([process.env, EnvironmentUtils.create(scriptEnv)]);
-            const child = proc.execute(cmakeExe.path, concreteArgs, outputConsumer, { environment: env});
+            const commandShell = process.platform === 'win32' ? proc.determineShell(cmakeExe.path) : false;
+            const configShell = cmakeProject.workspaceContext.config.shell;
+            const shell = (commandShell || undefined) ?? configShell ?? undefined;
+            const child = proc.execute(cmakeExe.path, concreteArgs, outputConsumer, { environment: env, shell });
 
             while (
                 !outputConsumer.stateMessages.includes(

src/debug/debugger.ts

@@ -95,7 +95,7 @@ async function createGDBDebugConfiguration(debuggerPath: string, target: Executa
         type: 'cppdbg',
         name: `Debug ${target.name}`,
         request: 'launch',
-        cwd: path.dirname(target.path),
+        cwd: target.debuggerWorkingDirectory || path.dirname(target.path),
         args: [],
         MIMode: MIModes.gdb,
         miDebuggerPath: debuggerPath,
@@ -127,7 +127,7 @@ async function createLLDBDebugConfiguration(debuggerPath: string, target: Execut
         type: 'cppdbg',
         name: `Debug ${target.name}`,
         request: 'launch',
-        cwd: path.dirname(target.path),
+        cwd: target.debuggerWorkingDirectory || path.dirname(target.path),
         args: [],
         MIMode: MIModes.lldb,
         miDebuggerPath: debuggerPath,
@@ -146,7 +146,7 @@ function createMsvcDebugConfiguration(target: ExecutableTarget): VSCodeDebugConf
         type: 'cppvsdbg',
         name: `Debug ${target.name}`,
         request: 'launch',
-        cwd: path.dirname(target.path),
+        cwd: target.debuggerWorkingDirectory || path.dirname(target.path),
         args: [],
         program: target.path
     };