Initial commit

src/client/interpreter/activation/service.ts

@@ -11,7 +11,7 @@ import { IPlatformService } from '../../common/platform/types';
 import * as internalScripts from '../../common/process/internal/scripts';
 import { ExecutionResult, IProcessServiceFactory } from '../../common/process/types';
 import { ITerminalHelper, TerminalShellType } from '../../common/terminal/types';
-import { ICurrentProcess, IDisposable, Resource } from '../../common/types';
+import { ICurrentProcess, IDisposable, IExtensionContext, Resource } from '../../common/types';
 import { sleep } from '../../common/utils/async';
 import { InMemoryCache } from '../../common/utils/cacheUtils';
 import { OSType } from '../../common/utils/platform';
@@ -102,6 +102,7 @@ export class EnvironmentActivationServiceCache {
 @injectable()
 export class EnvironmentActivationService implements IEnvironmentActivationService, IDisposable {
     private readonly disposables: IDisposable[] = [];
+    private previousEnvVars = process.env;
     private readonly activatedEnvVariablesCache = new EnvironmentActivationServiceCache();
     constructor(
         @inject(ITerminalHelper) private readonly helper: ITerminalHelper,
@@ -111,6 +112,7 @@ export class EnvironmentActivationService implements IEnvironmentActivationServi
         @inject(IWorkspaceService) private workspace: IWorkspaceService,
         @inject(IInterpreterService) private interpreterService: IInterpreterService,
         @inject(IEnvironmentVariablesProvider) private readonly envVarsService: IEnvironmentVariablesProvider,
+        @inject(IExtensionContext) private context: IExtensionContext,
     ) {
         this.envVarsService.onDidEnvironmentVariablesChange(
             () => this.activatedEnvVariablesCache.clear(),
@@ -119,10 +121,15 @@ export class EnvironmentActivationService implements IEnvironmentActivationServi
         );
 
         this.interpreterService.onDidChangeInterpreter(
-            () => this.activatedEnvVariablesCache.clear(),
+            async (resource) => {
+                this.activatedEnvVariablesCache.clear();
+                await this.initializeEnvironmentCollection(resource);
+            },
             this,
             this.disposables,
         );
+
+        this.initializeEnvironmentCollection(undefined).ignoreErrors();
     }
 
     public dispose(): void {
@@ -322,4 +329,28 @@ export class EnvironmentActivationService implements IEnvironmentActivationServi
         const js = output.substring(output.indexOf('{')).trim();
         return parse(js);
     }
+
+    private async initializeEnvironmentCollection(resource: Resource) {
+        const env = await this.getActivatedEnvironmentVariables(resource);
+        if (!env) {
+            this.context.environmentVariableCollection.clear();
+            this.previousEnvVars = process.env;
+            return;
+        }
+        const previousEnv = this.previousEnvVars;
+        Object.keys(previousEnv).forEach((key) => {
+            // If the previous env var is not in the current env, then explicitly add it so it can cleared later.
+            if (!(key in env)) {
+                env[key] = '';
+            }
+        });
+        this.previousEnvVars = env;
+        for (const key in env) {
+            const value = env[key];
+            const prevValue = previousEnv[key];
+            if (value !== undefined && prevValue !== value) {
+                this.context.environmentVariableCollection.replace(key, value);
+            }
+        }
+    }
 }

src/client/interpreter/contracts.ts

@@ -76,7 +76,7 @@ export interface IInterpreterService {
     readonly refreshPromise: Promise<void> | undefined;
     readonly onDidChangeInterpreters: Event<PythonEnvironmentsChangedEvent>;
     onDidChangeInterpreterConfiguration: Event<Uri | undefined>;
-    onDidChangeInterpreter: Event<void>;
+    onDidChangeInterpreter: Event<Uri | undefined>;
     onDidChangeInterpreterInformation: Event<PythonEnvironment>;
     /**
      * Note this API does not trigger the refresh but only works with the current refresh if any. Information

src/client/interpreter/interpreterService.ts

@@ -57,7 +57,7 @@ export class InterpreterService implements Disposable, IInterpreterService {
         return this.pyenvs.getRefreshPromise();
     }
 
-    public get onDidChangeInterpreter(): Event<void> {
+    public get onDidChangeInterpreter(): Event<Uri | undefined> {
         return this.didChangeInterpreterEmitter.event;
     }
 
@@ -79,7 +79,7 @@ export class InterpreterService implements Disposable, IInterpreterService {
 
     private readonly interpreterPathService: IInterpreterPathService;
 
-    private readonly didChangeInterpreterEmitter = new EventEmitter<void>();
+    private readonly didChangeInterpreterEmitter = new EventEmitter<Uri | undefined>();
 
     private readonly didChangeInterpreterInformation = new EventEmitter<PythonEnvironment>();
 
@@ -219,7 +219,7 @@ export class InterpreterService implements Disposable, IInterpreterService {
         this.didChangeInterpreterConfigurationEmitter.fire(resource);
         if (this._pythonPathSetting === '' || this._pythonPathSetting !== pySettings.pythonPath) {
             this._pythonPathSetting = pySettings.pythonPath;
-            this.didChangeInterpreterEmitter.fire();
+            this.didChangeInterpreterEmitter.fire(resource);
             reportActiveInterpreterChanged({
                 path: pySettings.pythonPath,
                 resource: this.serviceContainer.get<IWorkspaceService>(IWorkspaceService).getWorkspaceFolder(resource),

src/client/jupyter/jupyterIntegration.ts

@@ -63,7 +63,7 @@ type PythonApiForJupyterExtension = {
     /**
      * IInterpreterService
      */
-    onDidChangeInterpreter: Event<void>;
+    onDidChangeInterpreter: Event<Uri | undefined>;
     /**
      * IInterpreterService
      */

src/test/linters/lint.provider.test.ts

@@ -24,6 +24,7 @@ import {
     IPersistentStateFactory,
     IPythonSettings,
     Product,
+    Resource,
     WORKSPACE_MEMENTO,
 } from '../../client/common/types';
 import { createDeferred } from '../../client/common/utils/async';
@@ -171,12 +172,12 @@ suite('Linting - Provider', () => {
     });
 
     test('Lint on change interpreters', async () => {
-        const e = new vscode.EventEmitter<void>();
+        const e = new vscode.EventEmitter<Resource>();
         interpreterService.setup((x) => x.onDidChangeInterpreter).returns(() => e.event);
 
         const linterProvider = new LinterProvider(serviceContainer);
         await linterProvider.activate();
-        e.fire();
+        e.fire(undefined);
         engine.verify((x) => x.lintOpenPythonFiles(), TypeMoq.Times.once());
     });