Use cmake.environment and cmake.configureEnvironment for $penv{} expansion in preset includes (#4713)

Copilot · hanniavalera · web-flow · commit 2ef56fd7c45f · 2026-02-12T12:24:09.000-05:00
* feat: use cmake.environment and cmake.configureEnvironment for $penv{} expansion in preset includes Fixes #3578 When loading CMakePresets.json (v7+), $penv{} macros in the `include` field now resolve environment variables defined in `cmake.environment` and `cmake.configureEnvironment` VS Code settings, not just process.env. Changes: - PresetsParser: Add settingsEnvironment setter and merge with process.env as penvOverride in getExpandedInclude() for v7+ and v9+ presets - PresetsController: Pass merged cmake.environment + cmake.configureEnvironment to PresetsParser, and subscribe to setting changes to reapply presets - Add integration test validating $penv{} resolves settings environment vars - Add CHANGELOG entry under 1.23 Improvements Co-authored-by: hanniavalera <90047725+hanniavalera@users.noreply.github.com> * docs: clarify penvOverride conditional comment per code review Co-authored-by: hanniavalera <90047725+hanniavalera@users.noreply.github.com> --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: hanniavalera <90047725+hanniavalera@users.noreply.github.com>
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -8,6 +8,7 @@ Features:
 
 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)
+- Use environment variables from `cmake.environment` and `cmake.configureEnvironment` when expanding `$penv{}` macros in CMake Presets `include` paths. [#3578](https://github.com/microsoft/vscode-cmake-tools/issues/3578)
 
 Bug Fixes:
 - Fix extension not switching to preset mode after "CMake: Quick Start" generates a CMakePresets.json, causing variant selection to have no effect. [#4569](https://github.com/microsoft/vscode-cmake-tools/issues/4569)
diff --git a/src/presets/presetsController.ts b/src/presets/presetsController.ts
@@ -13,6 +13,7 @@ import rollbar from '@cmt/rollbar';
 import { ExpansionErrorHandler, ExpansionOptions } from '@cmt/expand';
 import paths from '@cmt/paths';
 import { KitsController } from '@cmt/kits/kitsController';
+import { EnvironmentUtils } from '@cmt/environmentVariables';
 import { descriptionForKit, Kit, SpecialKits } from '@cmt/kits/kit';
 import { getHostTargetArchString } from '@cmt/installs/visualStudio';
 import { Diagnostic, DiagnosticSeverity, Position, Range } from 'vscode';
@@ -65,6 +66,10 @@ export class PresetsController implements vscode.Disposable {
             );
         }, presetsController._presetsChangedEmitter.fire, presetsController._userPresetsChangedEmitter.fire);
 
+        // Pass cmake.environment and cmake.configureEnvironment settings so that $penv{} in preset
+        // include paths can resolve variables defined in VS Code settings.
+        presetsController.updateSettingsEnvironment();
+
         // We explicitly read presets file here, instead of on the initialization of the file watcher. Otherwise
         // there might be timing issues, since listeners are invoked async.
         await presetsController.reapplyPresets();
@@ -92,11 +97,33 @@ export class PresetsController implements vscode.Disposable {
             await presetsController.reapplyPresets();
         });
 
+        // We need to reapply presets when environment settings change so that $penv{} expansions
+        // in include paths are re-evaluated with the updated environment variables.
+        project.workspaceContext.config.onChange('environment', async () => {
+            presetsController.updateSettingsEnvironment();
+            await presetsController.reapplyPresets();
+        });
+        project.workspaceContext.config.onChange('configureEnvironment', async () => {
+            presetsController.updateSettingsEnvironment();
+            await presetsController.reapplyPresets();
+        });
+
         return presetsController;
     }
 
     private constructor(private readonly project: CMakeProject, private readonly _kitsController: KitsController, private isMultiProject: boolean) {}
 
+    /**
+     * Merges cmake.environment and cmake.configureEnvironment settings into a single
+     * environment object and passes it to the PresetsParser for $penv{} expansion.
+     * cmake.configureEnvironment takes precedence over cmake.environment.
+     */
+    private updateSettingsEnvironment(): void {
+        const env = this.project.workspaceContext.config.environment;
+        const configureEnv = this.project.workspaceContext.config.configureEnvironment;
+        this._presetsParser.settingsEnvironment = EnvironmentUtils.merge([env, configureEnv]);
+    }
+
     get presetsPath() {
         return this._presetsParser.presetsPath;
     }
diff --git a/src/presets/presetsParser.ts b/src/presets/presetsParser.ts
@@ -8,6 +8,7 @@ import { fs } from "@cmt/pr";
 import * as lodash from "lodash";
 import { expandString, ExpansionErrorHandler, MinimalPresetContextVars } from "@cmt/expand";
 import { loadSchema } from "@cmt/schema";
+import { Environment, EnvironmentUtils } from "@cmt/environmentVariables";
 
 nls.config({ messageFormat: nls.MessageFormat.bundle, bundleFormat: nls.BundleFormat.standalone })();
 const localize: nls.LocalizeFunc = nls.loadMessageBundle();
@@ -36,6 +37,7 @@ export class PresetsParser {
     private collectionsModifier: (filePath: string) => void;
     private presetsChangedHandler: (presets: preset.PresetsFile | undefined) => void;
     private userPresetsChangedHandler: (presets: preset.PresetsFile | undefined) => void;
+    private _settingsEnvironment: Environment = {};
 
     /**
      * Constructs the PresetsParser object
@@ -75,6 +77,14 @@ export class PresetsParser {
         this._sourceDir = sourceDir;
     }
 
+    /**
+     * Sets additional environment variables from VS Code settings (cmake.environment, cmake.configureEnvironment)
+     * that should be available for $penv{} macro expansion in preset include paths.
+     */
+    set settingsEnvironment(env: Environment) {
+        this._settingsEnvironment = env;
+    }
+
     get presetsFileExists(): boolean {
         return this._presetsFileExists || this._userPresetsFileExists;
     }
@@ -324,6 +334,14 @@ export class PresetsParser {
         hostSystemName: string,
         expansionErrors: ExpansionErrorHandler
     ): Promise<string> {
+        // Merge process.env with settings environment (cmake.environment, cmake.configureEnvironment)
+        // so that $penv{} can resolve variables from VS Code settings.
+        // When penvOverride is set, it fully replaces process.env in getParentEnvSubstitutions(),
+        // so we only set it when there are settings to merge — otherwise leave undefined to preserve
+        // the default process.env fallback behavior.
+        const penvOverride = Object.keys(this._settingsEnvironment).length > 0
+            ? EnvironmentUtils.merge([process.env, this._settingsEnvironment])
+            : undefined;
         return presetsFile.version >= 9
             ? expandString(
                 include,
@@ -336,7 +354,8 @@ export class PresetsParser {
                         fileDir: path.dirname(file),
                         pathListSep: path.delimiter
                     },
-                    envOverride: {} // $env{} expansions are not supported in `include` v9
+                    envOverride: {}, // $env{} expansions are not supported in `include` v9
+                    penvOverride
                 },
                 expansionErrors
             )
@@ -347,7 +366,8 @@ export class PresetsParser {
                     {
                         // No vars are supported in Version 7 for include paths.
                         vars: {} as MinimalPresetContextVars,
-                        envOverride: {} // $env{} expansions are not supported in `include` v9
+                        envOverride: {}, // $env{} expansions are not supported in `include` v9
+                        penvOverride
                     },
                     expansionErrors
                 )
diff --git a/test/integration-tests/presets/validation.test.ts b/test/integration-tests/presets/validation.test.ts
@@ -721,6 +721,66 @@ suite('Presets validation, inclusion, and expansion tests', () => {
             fs.rmSync(path.join(presetsParser.presetsPath, "..", "test.json"));
         }).timeout(100000);
 
+        /**
+         * Confirm that $penv{} in include paths resolves environment variables
+         * set via settingsEnvironment (cmake.environment / cmake.configureEnvironment).
+         * Also verify that settingsEnvironment takes precedence over process.env for $penv{}.
+         */
+        test('Validate `include` field supporting penv macro expansion with settings environment in v7', async () => {
+            // Remove any process.env.SETTINGS_TEST that might exist.
+            const origSettingsTest = process.env.SETTINGS_TEST;
+            delete process.env.SETTINGS_TEST;
+
+            // Set the settings environment to provide SETTINGS_TEST variable.
+            presetsParser.settingsEnvironment = { SETTINGS_TEST: sourceDirectory };
+
+            const v7WithInclude: any = lodash.cloneDeep(version7SupportedPresets);
+            v7WithInclude.include = ["$penv{SETTINGS_TEST}/test.json"];
+            v7WithInclude.configurePresets[0].name = "testSettingsName";
+
+            fs.writeFileSync(presetsParser.presetsPath, JSON.stringify(v7WithInclude));
+
+            // Create the include file.
+            fs.writeFileSync(path.join(presetsParser.presetsPath, "..", "test.json"),
+                JSON.stringify(v3SupportedPresets));
+
+            await presetsParser.resetPresetsFiles(
+                new Map<string, PresetsFile>(),
+                false,
+                false
+            );
+
+            // Should succeed: SETTINGS_TEST is resolved from settingsEnvironment.
+            expect(presetsFileErrors).to.have.lengthOf(0);
+            expect(preset.configurePresets(sourceDirectory).length).to.be.equal(2);
+
+            // Verify settingsEnvironment takes precedence over process.env for the same variable.
+            presetsFileErrors = [];
+            process.env.SETTINGS_TEST = "/nonexistent/path";
+            presetsParser.settingsEnvironment = { SETTINGS_TEST: sourceDirectory };
+
+            fs.writeFileSync(presetsParser.presetsPath, JSON.stringify(v7WithInclude));
+
+            await presetsParser.resetPresetsFiles(
+                new Map<string, PresetsFile>(),
+                false,
+                false
+            );
+
+            // Should succeed: settingsEnvironment value (sourceDirectory) takes precedence.
+            expect(presetsFileErrors).to.have.lengthOf(0);
+            expect(preset.configurePresets(sourceDirectory).length).to.be.equal(2);
+
+            // Clean up.
+            fs.rmSync(path.join(presetsParser.presetsPath, "..", "test.json"));
+            presetsParser.settingsEnvironment = {};
+            if (origSettingsTest !== undefined) {
+                process.env.SETTINGS_TEST = origSettingsTest;
+            } else {
+                delete process.env.SETTINGS_TEST;
+            }
+        }).timeout(100000);
+
         /**
          * Validate the v8 supports `$schema` field.
          */
