Honor environmentSetupScript output when expanding non-VS kit environmentVariables (#4091) (#4869)

* ensure kit env variables use script updated values

* normalize path in test

* use script path instead of process path

* fix for PATH resolution error to use absolute paths instead

Author: Omotola

CHANGELOG.md

@@ -40,6 +40,7 @@ Improvements:
 - 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)
 - Set the `VSCODE_CMAKE_TOOLS` environment variable for all spawned subprocesses so that `CMakeLists.txt` can detect when CMake is run from VS Code. [#4233](https://github.com/microsoft/vscode-cmake-tools/issues/4233)
+- Ensure kit `environmentVariables` expansions (for example, `${env:PATH}` or `${env.PATH}`) use the environment produced by `environmentSetupScript`, so script-updated values are preserved during expansion. [#4091](https://github.com/microsoft/vscode-cmake-tools/issues/4091)
 - 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)
 - Add `cmake.removeStaleKitsOnScan` setting to optionally remove stale compiler kits from the kit picker after a "Scan for Kits" when they are no longer rediscovered. This is useful after compiler upgrades that leave older versions outside `PATH`. Set `"keep": true` in a kit entry to prevent automatic removal. [#3852](https://github.com/microsoft/vscode-cmake-tools/issues/3852)
 - Add `pr-readiness` Copilot skill to verify PRs have a descriptive title, meaningful description, and a properly formatted CHANGELOG entry. [#4862](https://github.com/microsoft/vscode-cmake-tools/pull/4862)

src/kits/kit.ts

@@ -735,9 +735,12 @@ export async function getShellScriptEnvironment(kit: Kit, opts?: expand.Expansio
         // Quote the script file path before running it, in case there are spaces.
         run_command = `call "${script_path}"`;
     } else { // non-windows
+        // Ensure a failing setup script aborts so we don't silently capture an unmodified environment.
+        script += 'set -e\n';
         script += `source ${environmentSetupScript}\n`; // run the user shell script
-        script += `printenv >> ${environment_path}`; // write env vars to temp file
-        run_command = `/bin/bash -c "source ${script_path}"`; // run script in bash to enable bash-builtin commands like 'source'
+        // Use an absolute path so PATH modifications in the setup script don't break env capture.
+        script += `/usr/bin/printenv > "${environment_path}"`; // write env vars to temp file
+        run_command = `/bin/bash "${script_path}"`;
     }
     try {
         await fs.unlink(environment_path); // delete the temp file if it exists
@@ -1089,12 +1092,13 @@ export async function effectiveKitEnvironment(kit: Kit, opts?: expand.ExpansionO
     const kit_env = EnvironmentUtils.create(kit.environmentVariables);
     const getVSKitEnv = process.platform === 'win32' && kit.visualStudio && kit.visualStudioArchitecture;
     if (!getVSKitEnv) {
-        const expandOptions: expand.ExpansionOptions = {
+        const expandOptions: expand.ExpansionOptions = opts ? { ...opts, envOverride: host_env, penvOverride: host_env } : {
             vars: {} as expand.KitContextVars,
-            envOverride: host_env
+            envOverride: host_env,
+            penvOverride: host_env
         };
         for (const env_var of Object.keys(kit_env)) {
-            env[env_var] = await expand.expandString(kit_env[env_var], opts ?? expandOptions);
+            env[env_var] = await expand.expandString(kit_env[env_var], expandOptions);
         }
 
         if (process.platform === 'win32') {

test/unit-tests/kitmanager.test.ts

@@ -1,5 +1,5 @@
 /* eslint-disable no-unused-expressions */
-import { readKitsFile, getShellScriptEnvironment } from '@cmt/kits/kit';
+import { readKitsFile, getShellScriptEnvironment, effectiveKitEnvironment } from '@cmt/kits/kit';
 import { expect } from '@test/util';
 import * as path from 'path';
 import paths from '@cmt/paths';
@@ -93,4 +93,57 @@ suite('Kits test', () => {
             expect(env_vars_arr).to.deep.include(['TESTVAR13', 'cde']);
         }
     });
+
+    test('Test environmentVariables expand using environmentSetupScript output', async () => {
+        const fname_extension = process.platform === 'win32' ? 'bat' : 'sh';
+        const fname = `cmake-kit-test-${Math.random().toString()}.${fname_extension}`;
+        const script_path = path.join(paths.tmpDir, fname);
+        const pathSeparator = process.platform === 'win32' ? ';' : ':';
+        const basePath = process.platform === 'win32' ? 'C:\\base-path' : '/base-path';
+        const scriptPath = process.platform === 'win32' ? 'C:\\script-path' : '/script-path';
+        const appendedPath = process.platform === 'win32' ? 'C:\\env-var-path' : '/env-var-path';
+
+        process.env.PATH = basePath;
+
+        if (process.platform === 'win32') {
+            await fs.writeFile(script_path, `set "PATH=${scriptPath};%PATH%"`);
+        } else {
+            await fs.writeFile(script_path, `export PATH="${scriptPath}:$PATH"`);
+        }
+
+        const kit = {
+            name: 'Test Kit 3',
+            environmentSetupScript: script_path,
+            environmentVariables: {
+                PATH: `\${env:PATH}${pathSeparator}${appendedPath}`
+            },
+            isTrusted: true
+        };
+
+        const setupOnlyKit = {
+            name: 'Test Kit 3 setup-only',
+            environmentSetupScript: script_path,
+            isTrusted: true
+        };
+
+        const setup_env_vars = await getShellScriptEnvironment(setupOnlyKit);
+        expect(setup_env_vars).to.not.be.undefined;
+
+        const env_vars = await effectiveKitEnvironment(kit);
+        await fs.unlink(script_path);
+
+        const normalizePathList = (value: string | undefined): string[] => {
+            expect(value).to.not.eq(undefined);
+            const parts = (value ?? '').split(pathSeparator);
+            if (process.platform !== 'win32') {
+                return parts;
+            }
+
+            // cmd/set can emit PATH entries with different slash and drive-letter casing.
+            return parts.map(part => path.win32.normalize(part).toLowerCase());
+        };
+
+        expect(normalizePathList(setup_env_vars?.PATH)).to.deep.eq(normalizePathList(`${scriptPath}${pathSeparator}${basePath}`));
+        expect(normalizePathList(env_vars.PATH)).to.deep.eq(normalizePathList(`${scriptPath}${pathSeparator}${basePath}${pathSeparator}${appendedPath}`));
+    });
 });