Fix CMakePresets.json discovery after CMakeLists.txt selection in subdirectory (#4728)

* Initial plan

* Fix CMakePresets.json discovery in workspace when sourceDir changes via CMakeLists.txt dialog (#4727)

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

---------

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

Author: Copilot

CHANGELOG.md

@@ -14,6 +14,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)
 
 Bug Fixes:
+- Fix CMakePresets.json discovery failing in multi-folder workspaces when the presets file is in a subdirectory specified by `cmake.sourceDirectory`. [#4727](https://github.com/microsoft/vscode-cmake-tools/issues/4727)
 - Fix initial kit scan ignoring `cmake.enableAutomaticKitScan: false` on first workspace open, and prevent redundant concurrent scans in multi-project workspaces. [#4726](https://github.com/microsoft/vscode-cmake-tools/issues/4726)
 - Fix `cmake.installPrefix` not being passed to CMake as `CMAKE_INSTALL_PREFIX` when using presets. [#4358](https://github.com/microsoft/vscode-cmake-tools/issues/4358)
 - Fix CPack commands not appearing in the command palette when not using CMake Presets. Also fix CPack environment variables not being set up in non-preset mode. [#4453](https://github.com/microsoft/vscode-cmake-tools/issues/4453)

src/cmakeProject.ts

@@ -1014,6 +1014,9 @@ export class CMakeProject {
                     if (selectedFile) {
                         const newSourceDirectory = path.dirname(selectedFile);
                         await this.setSourceDir(await util.normalizeAndVerifySourceDir(newSourceDirectory, CMakeDriver.sourceDirExpansionOptions(this.workspaceContext.folder.uri.fsPath)));
+                        // Update the PresetsController so that CMakePresets.json is
+                        // looked up relative to the new source directory (fixes #4727).
+                        await this.presetsController.updateSourceDir(this._sourceDir);
                         void vscode.workspace.getConfiguration('cmake', this.workspaceFolder.uri).update("sourceDirectory", this._sourceDir);
                         if (config) {
                             // Updating sourceDirectory here, at the beginning of the configure process,

src/presets/presetsController.ts

@@ -148,6 +148,18 @@ export class PresetsController implements vscode.Disposable {
         return this._presetsParser.presetsFileExists;
     }
 
+    /**
+     * Updates the source directory used for locating CMakePresets.json and
+     * CMakeUserPresets.json, then reloads the presets from the new location.
+     * This is needed when the source directory changes after the PresetsController
+     * has already been initialized (e.g., when the user selects a CMakeLists.txt
+     * in a subdirectory via the missing-CMakeLists dialog).
+     */
+    async updateSourceDir(sourceDir: string) {
+        this._presetsParser.sourceDir = sourceDir;
+        await this.reapplyPresets();
+    }
+
     /**
      * Call configurePresets, buildPresets, testPresets, packagePresets or workflowPresets to get the latest presets when thie event is fired.
      */

test/unit-tests/presets/presetsController.test.ts

@@ -341,3 +341,98 @@ suite('PresetsController file watcher protection', () => {
         expect(path.basename(resolvedPath)).to.equal('CMakePresets.json');
     });
 });
+
+/**
+ * Tests for preset file discovery when sourceDir differs from folderPath.
+ * Validates the scenario from issue #4727 where CMakePresets.json lives in a
+ * subdirectory (e.g., engine/cmake/) rather than the workspace root.
+ */
+suite('Preset file path resolution with subdirectory sourceDir (#4727)', () => {
+    let tempDir: string;
+    let workspaceRoot: string;
+    let subDir: string;
+
+    setup(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cmake-presets-subdir-test-'));
+        workspaceRoot = tempDir;
+        subDir = path.join(tempDir, 'engine', 'cmake');
+        fs.mkdirSync(subDir, { recursive: true });
+    });
+
+    teardown(() => {
+        if (tempDir && fs.existsSync(tempDir)) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+
+    /**
+     * Test that CMakePresets.json is found when sourceDir is a subdirectory.
+     * This simulates the scenario where folderPath (workspace root) differs
+     * from sourceDir (subdirectory with CMakeLists.txt and CMakePresets.json).
+     */
+    test('presetsPath points to sourceDir, not folderPath', () => {
+        // The presetsPath should be constructed from sourceDir, not folderPath
+        const folderPath = workspaceRoot;
+        const sourceDir = subDir;
+
+        // This is how PresetsParser computes presetsPath
+        const presetsPath = path.join(sourceDir, 'CMakePresets.json');
+        const userPresetsPath = path.join(sourceDir, 'CMakeUserPresets.json');
+
+        // Verify paths point to subdirectory, not workspace root
+        expect(presetsPath).to.equal(path.join(subDir, 'CMakePresets.json'));
+        expect(userPresetsPath).to.equal(path.join(subDir, 'CMakeUserPresets.json'));
+        expect(presetsPath).to.not.equal(path.join(folderPath, 'CMakePresets.json'));
+    });
+
+    /**
+     * Test that preset files in subdirectory are found on disk.
+     * This validates the core issue: the extension must look for
+     * CMakePresets.json relative to sourceDir (where CMakeLists.txt is),
+     * not relative to the workspace root.
+     */
+    test('preset files are found in sourceDir subdirectory', () => {
+        // Create CMakePresets.json in the subdirectory
+        const presetsContent = JSON.stringify({
+            version: 3,
+            configurePresets: [{
+                name: "subdir-preset",
+                generator: "Ninja",
+                binaryDir: "${sourceDir}/build"
+            }]
+        }, null, 2);
+        const presetsFilePath = path.join(subDir, 'CMakePresets.json');
+        fs.writeFileSync(presetsFilePath, presetsContent);
+
+        // Verify the file exists at sourceDir, not at workspace root
+        expect(fs.existsSync(path.join(subDir, 'CMakePresets.json'))).to.be.true;
+        expect(fs.existsSync(path.join(workspaceRoot, 'CMakePresets.json'))).to.be.false;
+
+        // Verify content is correct
+        const content = JSON.parse(fs.readFileSync(presetsFilePath, 'utf8'));
+        expect(content.configurePresets[0].name).to.equal('subdir-preset');
+    });
+
+    /**
+     * Test that updating sourceDir changes where presets are looked up.
+     * This validates the fix for #4727: after the user selects a CMakeLists.txt
+     * in a subdirectory, the preset lookup path must be updated accordingly.
+     */
+    test('sourceDir update changes preset lookup path', () => {
+        // Initially, sourceDir is the workspace root
+        let sourceDir = workspaceRoot;
+        let presetsPath = path.join(sourceDir, 'CMakePresets.json');
+        expect(presetsPath).to.equal(path.join(workspaceRoot, 'CMakePresets.json'));
+
+        // User selects CMakeLists.txt in subdirectory, sourceDir is updated
+        sourceDir = subDir;
+        presetsPath = path.join(sourceDir, 'CMakePresets.json');
+        expect(presetsPath).to.equal(path.join(subDir, 'CMakePresets.json'));
+
+        // Create the file in the subdirectory
+        fs.writeFileSync(path.join(subDir, 'CMakePresets.json'), '{"version": 3}');
+
+        // After sourceDir update, the file should be found
+        expect(fs.existsSync(presetsPath)).to.be.true;
+    });
+});