refactor: deduplicate test source resolution between test explorer and project outline (#4780)

* Initial plan

* feat: navigate to test source file when clicking CTest in Project Outline (#4773)

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

* fix: navigate cursor to correct test line when clicking CTest in Project Outline (#4773)

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

* remove accidental .yarnrc file

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

* refactor: extract shared resolveTestSourceLocation() to deduplicate test explorer and project outline source resolution

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

* remove accidentally committed .npmrc.bak

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

---------

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

Author: Copilot

CHANGELOG.md

@@ -15,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)

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/extension.ts

@@ -862,7 +862,7 @@ export class ExtensionManager implements vscode.Disposable {
         if (!cmakeProject) {
             return;
         }
-        const tests = cmakeProject.cTestController.getTestsForOutline();
+        const tests = cmakeProject.cTestController.getTestsForOutline(cmakeProject.codeModelContent);
         this.projectOutline.updateTests(cmakeProject, tests);
     }
 

src/ui/projectOutline/projectOutline.ts

@@ -361,7 +361,9 @@ export class CTestTestNode extends BaseNode {
         readonly targetId: string,
         readonly testName: string,
         readonly folder: vscode.WorkspaceFolder,
-        readonly sourceDir: string
+        readonly sourceDir: string,
+        readonly sourceFilePath?: string,
+        readonly sourceFileLine?: number
     ) {
         super(`${targetId}::test::${testName}`);
     }
@@ -384,6 +386,16 @@ export class CTestTestNode extends BaseNode {
         item.iconPath = new vscode.ThemeIcon('beaker');
         item.contextValue = 'nodeType=test';
         item.tooltip = localize('test.tooltip', 'Test: {0}', this.testName);
+        if (this.sourceFilePath) {
+            const uri = vscode.Uri.file(this.sourceFilePath);
+            const line = this.sourceFileLine ? this.sourceFileLine - 1 : 0;
+            const position = new vscode.Position(line, 0);
+            item.command = {
+                title: localize('open.file', 'Open file'),
+                command: 'vscode.open',
+                arguments: [uri, { selection: new vscode.Range(position, position) }]
+            };
+        }
         return item;
     }
 }
@@ -551,9 +563,9 @@ export class TargetNode extends BaseNode {
         }
     }
 
-    updateTests(testNames: string[]) {
-        this._testNodes = testNames.map(name =>
-            new CTestTestNode(this.id, name, this.folder, this.sourceDir)
+    updateTests(tests: { name: string; sourceFilePath?: string; sourceFileLine?: number }[]) {
+        this._testNodes = tests.map(test =>
+            new CTestTestNode(this.id, test.name, this.folder, this.sourceDir, test.sourceFilePath, test.sourceFileLine)
         );
     }
 }
@@ -749,7 +761,7 @@ export class WorkspaceFolderNode extends BaseNode {
         return children.sort((a, b) => lexicographicalCompare(a.getOrderTuple(), b.getOrderTuple()));
     }
 
-    updateTests(cmakeProject: CMakeProject, tests: { name: string; executablePath: string }[]) {
+    updateTests(cmakeProject: CMakeProject, tests: { name: string; executablePath: string; sourceFilePath?: string; sourceFileLine?: number }[]) {
         const sub_map = this._projects.get(cmakeProject.folderPath);
         if (!sub_map) {
             return;
@@ -772,7 +784,7 @@ export class WorkspaceFolderNode extends BaseNode {
         }
 
         // Group tests by their executable path (matching to targets)
-        const testsByTarget = new Map<TargetNode, string[]>();
+        const testsByTarget = new Map<TargetNode, { name: string; sourceFilePath?: string; sourceFileLine?: number }[]>();
         for (const test of tests) {
             const normalizedExe = platformNormalizePath(test.executablePath);
             const target = targetsByPath.get(normalizedExe);
@@ -782,7 +794,7 @@ export class WorkspaceFolderNode extends BaseNode {
                     arr = [];
                     testsByTarget.set(target, arr);
                 }
-                arr.push(test.name);
+                arr.push({ name: test.name, sourceFilePath: test.sourceFilePath, sourceFileLine: test.sourceFileLine });
             }
         }
 
@@ -794,8 +806,8 @@ export class WorkspaceFolderNode extends BaseNode {
         }
 
         // Update each target with its tests
-        for (const [target, testNames] of testsByTarget) {
-            target.updateTests(testNames);
+        for (const [target, targetTests] of testsByTarget) {
+            target.updateTests(targetTests);
         }
     }
 }
@@ -928,7 +940,7 @@ export class ProjectOutline implements vscode.TreeDataProvider<BaseNode> {
         this._changeEvent.fire(null);
     }
 
-    updateTests(cmakeProject: CMakeProject, tests: { name: string; executablePath: string }[]) {
+    updateTests(cmakeProject: CMakeProject, tests: { name: string; executablePath: string; sourceFilePath?: string; sourceFileLine?: number }[]) {
         const folder = cmakeProject.workspaceContext.folder;
         const existing = this._folders.get(folder.uri.fsPath);
         if (!existing) {