Improvements to pythonTerminalEnvVarActivation experiment

src/client/interpreter/activation/service.ts

@@ -19,8 +19,8 @@ import { ICurrentProcess, IDisposable, Resource } from '../../common/types';
 import { sleep } from '../../common/utils/async';
 import { InMemoryCache } from '../../common/utils/cacheUtils';
 import { OSType } from '../../common/utils/platform';
-import { IEnvironmentVariablesProvider } from '../../common/variables/types';
-import { EnvironmentType, PythonEnvironment } from '../../pythonEnvironments/info';
+import { EnvironmentVariables, IEnvironmentVariablesProvider } from '../../common/variables/types';
+import { EnvironmentType, PythonEnvironment, virtualEnvTypes } from '../../pythonEnvironments/info';
 import { sendTelemetryEvent } from '../../telemetry';
 import { EventName } from '../../telemetry/constants';
 import { IInterpreterService } from '../contracts';
@@ -38,6 +38,7 @@ import { Conda } from '../../pythonEnvironments/common/environmentManagers/conda
 import { StopWatch } from '../../common/utils/stopWatch';
 import { identifyShellFromShellPath } from '../../common/terminal/shellDetectors/baseShellDetector';
 import { getSearchPathEnvVarNames } from '../../common/utils/exec';
+import { cache } from '../../common/utils/decorators';
 
 const ENVIRONMENT_PREFIX = 'e8b39361-0157-4923-80e1-22d70d46dee6';
 const CACHE_DURATION = 10 * 60 * 1000;
@@ -154,11 +155,11 @@ export class EnvironmentActivationService implements IEnvironmentActivationServi
         }
 
         // Cache only if successful, else keep trying & failing if necessary.
-        const cache = new InMemoryCache<NodeJS.ProcessEnv | undefined>(CACHE_DURATION);
+        const memCache = new InMemoryCache<NodeJS.ProcessEnv | undefined>(CACHE_DURATION);
         return this.getActivatedEnvironmentVariablesImpl(resource, interpreter, allowExceptions, shell)
             .then((vars) => {
-                cache.data = vars;
-                this.activatedEnvVariablesCache.set(cacheKey, cache);
+                memCache.data = vars;
+                this.activatedEnvVariablesCache.set(cacheKey, memCache);
                 sendTelemetryEvent(
                     EventName.PYTHON_INTERPRETER_ACTIVATION_ENVIRONMENT_VARIABLES,
                     stopWatch.elapsedTime,
@@ -176,6 +177,35 @@ export class EnvironmentActivationService implements IEnvironmentActivationServi
             });
     }
 
+    @cache(-1, true)
+    public async getProcessEnvironmentVariables(resource: Resource, shell?: string): Promise<EnvironmentVariables> {
+        // Try to get the process environment variables using Python by printing variables, that can be little different
+        // from `process.env` and is preferred when calculating diff.
+        const globalInterpreters = this.interpreterService
+            .getInterpreters()
+            .filter((i) => !virtualEnvTypes.includes(i.envType));
+        const interpreterPath =
+            globalInterpreters.length > 0 && globalInterpreters[0] ? globalInterpreters[0].path : 'python';
+        try {
+            const [args, parse] = internalScripts.printEnvVariables();
+            args.forEach((arg, i) => {
+                args[i] = arg.toCommandArgumentForPythonExt();
+            });
+            const command = `${interpreterPath} ${args.join(' ')}`;
+            const processService = await this.processServiceFactory.create(resource);
+            const result = await processService.shellExec(command, {
+                shell,
+                timeout: ENVIRONMENT_TIMEOUT,
+                maxBuffer: 1000 * 1000,
+                throwOnStdErr: false,
+            });
+            const returnedEnv = this.parseEnvironmentOutput(result.stdout, parse);
+            return returnedEnv ?? process.env;
+        } catch (ex) {
+            return process.env;
+        }
+    }
+
     public async getEnvironmentActivationShellCommands(
         resource: Resource,
         interpreter?: PythonEnvironment,
@@ -231,7 +261,7 @@ export class EnvironmentActivationService implements IEnvironmentActivationServi
                 );
                 traceVerbose(`Activation Commands received ${activationCommands} for shell ${shellInfo.shell}`);
                 if (!activationCommands || !Array.isArray(activationCommands) || activationCommands.length === 0) {
-                    if (interpreter?.envType === EnvironmentType.Venv) {
+                    if (interpreter && [EnvironmentType.Venv, EnvironmentType.Pyenv].includes(interpreter?.envType)) {
                         const key = getSearchPathEnvVarNames()[0];
                         if (env[key]) {
                             env[key] = `${path.dirname(interpreter.path)}${path.delimiter}${env[key]}`;
@@ -247,7 +277,14 @@ export class EnvironmentActivationService implements IEnvironmentActivationServi
                 const activationCommand = fixActivationCommands(activationCommands).join(' && ');
                 // In order to make sure we know where the environment output is,
                 // put in a dummy echo we can look for
-                command = `${activationCommand} && echo '${ENVIRONMENT_PREFIX}' && python ${args.join(' ')}`;
+                const commandSeparator = [TerminalShellType.powershell, TerminalShellType.powershellCore].includes(
+                    shellInfo.shellType,
+                )
+                    ? ';'
+                    : '&&';
+                command = `${activationCommand} ${commandSeparator} echo '${ENVIRONMENT_PREFIX}' ${commandSeparator} python ${args.join(
+                    ' ',
+                )}`;
             }
 
             // Make sure python warnings don't interfere with getting the environment. However

src/client/interpreter/activation/terminalEnvVarCollectionService.ts

@@ -33,6 +33,7 @@ import { defaultShells } from './service';
 import { IEnvironmentActivationService } from './types';
 import { EnvironmentType } from '../../pythonEnvironments/info';
 import { getSearchPathEnvVarNames } from '../../common/utils/exec';
+import { EnvironmentVariables } from '../../common/variables/types';
 
 @injectable()
 export class TerminalEnvVarCollectionService implements IExtensionActivationService {
@@ -45,7 +46,10 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
 
     private registeredOnce = false;
 
-    private previousEnvVars = _normCaseKeys(process.env);
+    /**
+     * Carries default environment variables for the currently selected shell.
+     */
+    private processEnvVars: EnvironmentVariables | undefined;
 
     constructor(
         @inject(IPlatformService) private readonly platform: IPlatformService,
@@ -90,6 +94,7 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
             this.applicationEnvironment.onDidChangeShell(
                 async (shell: string) => {
                     this.showProgress();
+                    this.processEnvVars = undefined;
                     // Pass in the shell where known instead of relying on the application environment, because of bug
                     // on VSCode: https://github.com/microsoft/vscode/issues/160694
                     await this._applyCollection(undefined, shell).ignoreErrors();
@@ -106,6 +111,9 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
     public async _applyCollection(resource: Resource, shell = this.applicationEnvironment.shell): Promise<void> {
         const workspaceFolder = this.getWorkspaceFolder(resource);
         const settings = this.configurationService.getSettings(resource);
+        const envVarCollection = this.getEnvironmentVariableCollection(workspaceFolder);
+        // Clear any previously set env vars from collection.
+        envVarCollection.clear();
         if (!settings.terminal.activateEnvironment) {
             traceVerbose('Activating environments in terminal is disabled for', resource?.fsPath);
             return;
@@ -116,7 +124,6 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
             undefined,
             shell,
         );
-        const envVarCollection = this.getEnvironmentVariableCollection(workspaceFolder);
         if (!env) {
             const shellType = identifyShellFromShellPath(shell);
             const defaultShell = defaultShells[this.platform.osType];
@@ -126,32 +133,38 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
                 await this._applyCollection(resource, defaultShell?.shell);
                 return;
             }
-            envVarCollection.clear();
-            this.previousEnvVars = _normCaseKeys(process.env);
+            this.processEnvVars = undefined;
             return;
         }
-        const previousEnv = this.previousEnvVars;
-        this.previousEnvVars = env;
+        if (!this.processEnvVars) {
+            this.processEnvVars = await this.environmentActivationService.getProcessEnvironmentVariables(
+                resource,
+                shell,
+            );
+        }
+        const processEnv = this.processEnvVars;
         Object.keys(env).forEach((key) => {
+            if (shouldSkip(key)) {
+                return;
+            }
             const value = env[key];
-            const prevValue = previousEnv[key];
+            const prevValue = processEnv[key];
             if (prevValue !== value) {
                 if (value !== undefined) {
+                    if (key === 'PS1') {
+                        traceVerbose(`Prepending environment variable ${key} in collection with ${value}`);
+                        envVarCollection.prepend(key, value, {
+                            applyAtShellIntegration: true,
+                            applyAtProcessCreation: false,
+                        });
+                        return;
+                    }
                     traceVerbose(`Setting environment variable ${key} in collection to ${value}`);
                     envVarCollection.replace(key, value, { applyAtShellIntegration: true });
-                } else {
-                    traceVerbose(`Clearing environment variable ${key} from collection`);
-                    envVarCollection.delete(key);
                 }
             }
         });
-        Object.keys(previousEnv).forEach((key) => {
-            // If the previous env var is not in the current env, clear it from collection.
-            if (!(key in env)) {
-                traceVerbose(`Clearing environment variable ${key} from collection`);
-                envVarCollection.delete(key);
-            }
-        });
+
         const displayPath = this.pathUtils.getDisplayName(settings.pythonPath, workspaceFolder?.uri.fsPath);
         const description = new MarkdownString(`${Interpreters.activateTerminalDescription} \`${displayPath}\``);
         envVarCollection.description = description;
@@ -224,13 +237,6 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
     }
 }
 
-export function _normCaseKeys(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
-    const result: NodeJS.ProcessEnv = {};
-    Object.keys(env).forEach((key) => {
-        // `os.environ` script used to get env vars normalizes keys to upper case:
-        // https://github.com/python/cpython/issues/101754
-        // So convert `process.env` keys to upper case to match.
-        result[key.toUpperCase()] = env[key];
-    });
-    return result;
+function shouldSkip(env: string) {
+    return ['_', 'SHLVL'].includes(env);
 }

src/client/interpreter/activation/types.ts

@@ -4,10 +4,12 @@
 'use strict';
 
 import { Resource } from '../../common/types';
+import { EnvironmentVariables } from '../../common/variables/types';
 import { PythonEnvironment } from '../../pythonEnvironments/info';
 
 export const IEnvironmentActivationService = Symbol('IEnvironmentActivationService');
 export interface IEnvironmentActivationService {
+    getProcessEnvironmentVariables(resource: Resource, shell?: string): Promise<EnvironmentVariables>;
     getActivatedEnvironmentVariables(
         resource: Resource,
         interpreter?: PythonEnvironment,