Show notification reaffirming Python extension still handles activati…

…on when in `pythonTerminalEnvVarActivation` experiment (microsoft#21802)

Closes microsoft#21793

Only show notification when terminal prompt does not already indicate
that env is activated.

src/client/activation/extensionSurvey.ts

@@ -83,10 +83,10 @@ export class ExtensionSurveyPrompt implements IExtensionSingleActivationService
     @traceDecoratorError('Failed to display prompt for extension survey')
     public async showSurvey() {
         const prompts = [ExtensionSurveyBanner.bannerLabelYes, ExtensionSurveyBanner.maybeLater, Common.doNotShowAgain];
-        const telemetrySelections: ['Yes', 'Maybe later', 'Do not show again'] = [
+        const telemetrySelections: ['Yes', 'Maybe later', "Don't show again"] = [
             'Yes',
             'Maybe later',
-            'Do not show again',
+            "Don't show again",
         ];
         const selection = await this.appShell.showInformationMessage(ExtensionSurveyBanner.bannerMessage, ...prompts);
         sendTelemetryEvent(EventName.EXTENSION_SURVEY_PROMPT, undefined, {

src/client/common/experiments/helpers.ts

@@ -3,10 +3,16 @@
 
 'use strict';
 
+import { env, workspace } from 'vscode';
 import { IExperimentService } from '../types';
 import { TerminalEnvVarActivation } from './groups';
+import { isTestExecution } from '../constants';
 
 export function inTerminalEnvVarExperiment(experimentService: IExperimentService): boolean {
+    if (!isTestExecution() && workspace.workspaceFile && env.remoteName) {
+        // TODO: Remove this if statement once https://github.com/microsoft/vscode/issues/180486 is fixed.
+        return false;
+    }
     if (!experimentService.inExperimentSync(TerminalEnvVarActivation.experiment)) {
         return false;
     }

src/client/common/utils/localize.ts

@@ -63,7 +63,7 @@ export namespace Common {
     export const openOutputPanel = l10n.t('Show output');
     export const noIWillDoItLater = l10n.t('No, I will do it later');
     export const notNow = l10n.t('Not now');
-    export const doNotShowAgain = l10n.t('Do not show again');
+    export const doNotShowAgain = l10n.t("Don't show again");
     export const reload = l10n.t('Reload');
     export const moreInfo = l10n.t('More Info');
     export const learnMore = l10n.t('Learn more');
@@ -198,6 +198,9 @@ export namespace Interpreters {
     );
     export const activatingTerminals = l10n.t('Reactivating terminals...');
     export const activateTerminalDescription = l10n.t('Activated environment for');
+    export const terminalEnvVarCollectionPrompt = l10n.t(
+        'The Python extension automatically activates all terminals using the selected environment. You can hover over the terminal tab to see more information about the activation. [Learn more](https://aka.ms/vscodePythonTerminalActivation).',
+    );
     export const activatedCondaEnvLaunch = l10n.t(
         'We noticed VS Code was launched from an activated conda environment, would you like to select it?',
     );

src/client/interpreter/activation/terminalEnvVarCollectionPrompt.ts

@@ -0,0 +1,80 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { inject, injectable } from 'inversify';
+import { Uri } from 'vscode';
+import { IActiveResourceService, IApplicationShell, ITerminalManager } from '../../common/application/types';
+import {
+    IConfigurationService,
+    IDisposableRegistry,
+    IExperimentService,
+    IPersistentStateFactory,
+} from '../../common/types';
+import { Common, Interpreters } from '../../common/utils/localize';
+import { IExtensionSingleActivationService } from '../../activation/types';
+import { ITerminalEnvVarCollectionService } from './types';
+import { inTerminalEnvVarExperiment } from '../../common/experiments/helpers';
+
+export const terminalEnvCollectionPromptKey = 'TERMINAL_ENV_COLLECTION_PROMPT_KEY';
+
+@injectable()
+export class TerminalEnvVarCollectionPrompt implements IExtensionSingleActivationService {
+    public readonly supportedWorkspaceTypes = { untrustedWorkspace: false, virtualWorkspace: false };
+
+    constructor(
+        @inject(IApplicationShell) private readonly appShell: IApplicationShell,
+        @inject(IPersistentStateFactory) private readonly persistentStateFactory: IPersistentStateFactory,
+        @inject(ITerminalManager) private readonly terminalManager: ITerminalManager,
+        @inject(IDisposableRegistry) private readonly disposableRegistry: IDisposableRegistry,
+        @inject(IActiveResourceService) private readonly activeResourceService: IActiveResourceService,
+        @inject(ITerminalEnvVarCollectionService)
+        private readonly terminalEnvVarCollectionService: ITerminalEnvVarCollectionService,
+        @inject(IConfigurationService) private readonly configurationService: IConfigurationService,
+        @inject(IExperimentService) private readonly experimentService: IExperimentService,
+    ) {}
+
+    public async activate(): Promise<void> {
+        if (!inTerminalEnvVarExperiment(this.experimentService)) {
+            return;
+        }
+        this.disposableRegistry.push(
+            this.terminalManager.onDidOpenTerminal(async (terminal) => {
+                const cwd =
+                    'cwd' in terminal.creationOptions && terminal.creationOptions.cwd
+                        ? terminal.creationOptions.cwd
+                        : this.activeResourceService.getActiveResource();
+                const resource = typeof cwd === 'string' ? Uri.file(cwd) : cwd;
+                const settings = this.configurationService.getSettings(resource);
+                if (!settings.terminal.activateEnvironment) {
+                    return;
+                }
+                if (this.terminalEnvVarCollectionService.isTerminalPromptSetCorrectly(resource)) {
+                    // No need to show notification if terminal prompt already indicates when env is activated.
+                    return;
+                }
+                await this.notifyUsers();
+            }),
+        );
+    }
+
+    private async notifyUsers(): Promise<void> {
+        const notificationPromptEnabled = this.persistentStateFactory.createGlobalPersistentState(
+            terminalEnvCollectionPromptKey,
+            true,
+        );
+        if (!notificationPromptEnabled.value) {
+            return;
+        }
+        const prompts = [Common.doNotShowAgain];
+        const selection = await this.appShell.showInformationMessage(
+            Interpreters.terminalEnvVarCollectionPrompt,
+            ...prompts,
+        );
+        if (!selection) {
+            return;
+        }
+        if (selection === prompts[0]) {
+            await notificationPromptEnabled.updateValue(false);
+        }
+    }
+}

src/client/interpreter/activation/terminalEnvVarCollectionService.ts

@@ -23,13 +23,15 @@ import { Interpreters } from '../../common/utils/localize';
 import { traceDecoratorVerbose, traceVerbose } from '../../logging';
 import { IInterpreterService } from '../contracts';
 import { defaultShells } from './service';
-import { IEnvironmentActivationService } from './types';
+import { IEnvironmentActivationService, ITerminalEnvVarCollectionService } from './types';
 import { EnvironmentType } from '../../pythonEnvironments/info';
 import { getSearchPathEnvVarNames } from '../../common/utils/exec';
 import { EnvironmentVariables } from '../../common/variables/types';
+import { TerminalShellType } from '../../common/terminal/types';
+import { OSType } from '../../common/utils/platform';
 
 @injectable()
-export class TerminalEnvVarCollectionService implements IExtensionActivationService {
+export class TerminalEnvVarCollectionService implements IExtensionActivationService, ITerminalEnvVarCollectionService {
     public readonly supportedWorkspaceTypes = {
         untrustedWorkspace: false,
         virtualWorkspace: false,
@@ -127,6 +129,7 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
                 await this._applyCollection(resource, defaultShell?.shell);
                 return;
             }
+            await this.trackTerminalPrompt(shell, resource, env);
             this.processEnvVars = undefined;
             return;
         }
@@ -146,6 +149,7 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
             if (prevValue !== value) {
                 if (value !== undefined) {
                     if (key === 'PS1') {
+                        // We cannot have the full PS1 without executing in terminal, which we do not. Hence prepend it.
                         traceVerbose(`Prepending environment variable ${key} in collection with ${value}`);
                         envVarCollection.prepend(key, value, {
                             applyAtShellIntegration: true,
@@ -165,6 +169,61 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
         const displayPath = this.pathUtils.getDisplayName(settings.pythonPath, workspaceFolder?.uri.fsPath);
         const description = new MarkdownString(`${Interpreters.activateTerminalDescription} \`${displayPath}\``);
         envVarCollection.description = description;
+
+        await this.trackTerminalPrompt(shell, resource, env);
+    }
+
+    private isPromptSet = new Map<number | undefined, boolean>();
+
+    // eslint-disable-next-line class-methods-use-this
+    public isTerminalPromptSetCorrectly(resource?: Resource): boolean {
+        const workspaceFolder = this.getWorkspaceFolder(resource);
+        return !!this.isPromptSet.get(workspaceFolder?.index);
+    }
+
+    /**
+     * Call this once we know terminal prompt is set correctly for terminal owned by this resource.
+     */
+    private terminalPromptIsCorrect(resource: Resource) {
+        const key = this.getWorkspaceFolder(resource)?.index;
+        this.isPromptSet.set(key, true);
+    }
+
+    private terminalPromptIsUnknown(resource: Resource) {
+        const key = this.getWorkspaceFolder(resource)?.index;
+        this.isPromptSet.delete(key);
+    }
+
+    /**
+     * Tracks whether prompt for terminal was correctly set.
+     */
+    private async trackTerminalPrompt(shell: string, resource: Resource, env: EnvironmentVariables | undefined) {
+        this.terminalPromptIsUnknown(resource);
+        if (!env) {
+            this.terminalPromptIsCorrect(resource);
+            return;
+        }
+        // Prompts for these shells cannot be set reliably using variables
+        const exceptionShells = [
+            TerminalShellType.powershell,
+            TerminalShellType.powershellCore,
+            TerminalShellType.fish,
+            TerminalShellType.zsh, // TODO: Remove this once https://github.com/microsoft/vscode/issues/188875 is fixed
+        ];
+        const customShellType = identifyShellFromShellPath(shell);
+        if (exceptionShells.includes(customShellType)) {
+            return;
+        }
+        if (this.platform.osType !== OSType.Windows) {
+            // These shells are expected to set PS1 variable for terminal prompt for virtual/conda environments.
+            const interpreter = await this.interpreterService.getActiveInterpreter(resource);
+            const shouldPS1BeSet = interpreter?.type !== undefined;
+            if (shouldPS1BeSet && !env.PS1) {
+                // PS1 should be set but no PS1 was set.
+                return;
+            }
+        }
+        this.terminalPromptIsCorrect(resource);
     }
 
     private async handleMicroVenv(resource: Resource) {
@@ -178,7 +237,7 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
                 envVarCollection.replace(
                     'PATH',
                     `${path.dirname(interpreter.path)}${path.delimiter}${process.env[pathVarName]}`,
-                    { applyAtShellIntegration: true },
+                    { applyAtShellIntegration: true, applyAtProcessCreation: true },
                 );
                 return;
             }

src/client/interpreter/activation/types.ts

@@ -21,3 +21,11 @@ export interface IEnvironmentActivationService {
         interpreter?: PythonEnvironment,
     ): Promise<string[] | undefined>;
 }
+
+export const ITerminalEnvVarCollectionService = Symbol('ITerminalEnvVarCollectionService');
+export interface ITerminalEnvVarCollectionService {
+    /**
+     * Returns true if we know with high certainity the terminal prompt is set correctly for a particular resource.
+     */
+    isTerminalPromptSetCorrectly(resource?: Resource): boolean;
+}

src/client/interpreter/serviceRegistry.ts

@@ -6,8 +6,9 @@
 import { IExtensionActivationService, IExtensionSingleActivationService } from '../activation/types';
 import { IServiceManager } from '../ioc/types';
 import { EnvironmentActivationService } from './activation/service';
+import { TerminalEnvVarCollectionPrompt } from './activation/terminalEnvVarCollectionPrompt';
 import { TerminalEnvVarCollectionService } from './activation/terminalEnvVarCollectionService';
-import { IEnvironmentActivationService } from './activation/types';
+import { IEnvironmentActivationService, ITerminalEnvVarCollectionService } from './activation/types';
 import { InterpreterAutoSelectionService } from './autoSelection/index';
 import { InterpreterAutoSelectionProxyService } from './autoSelection/proxy';
 import { IInterpreterAutoSelectionService, IInterpreterAutoSelectionProxyService } from './autoSelection/types';
@@ -109,8 +110,13 @@ export function registerTypes(serviceManager: IServiceManager): void {
         IEnvironmentActivationService,
         EnvironmentActivationService,
     );
-    serviceManager.addSingleton<IExtensionActivationService>(
-        IExtensionActivationService,
+    serviceManager.addSingleton<ITerminalEnvVarCollectionService>(
+        ITerminalEnvVarCollectionService,
         TerminalEnvVarCollectionService,
     );
+    serviceManager.addBinding(ITerminalEnvVarCollectionService, IExtensionActivationService);
+    serviceManager.addSingleton<IExtensionSingleActivationService>(
+        IExtensionSingleActivationService,
+        TerminalEnvVarCollectionPrompt,
+    );
 }

src/client/pythonEnvironments/info/index.ts

@@ -4,6 +4,7 @@
 'use strict';
 
 import { Architecture } from '../../common/utils/platform';
+import { PythonEnvType } from '../base/info';
 import { PythonVersion } from './pythonVersion';
 
 /**
@@ -85,7 +86,7 @@ export type PythonEnvironment = InterpreterInformation & {
     envName?: string;
     envPath?: string;
     cachedEntry?: boolean;
-    type?: string;
+    type?: PythonEnvType;
 };
 
 /**

src/client/telemetry/index.ts

@@ -950,7 +950,7 @@ export interface IEventNamePropertyMapping {
         tool?: LinterId;
         /**
          * `select` When 'Select linter' option is selected
-         * `disablePrompt` When 'Do not show again' option is selected
+         * `disablePrompt` When "Don't show again" option is selected
          * `install` When 'Install' option is selected
          *
          * @type {('select' | 'disablePrompt' | 'install')}
@@ -1374,7 +1374,7 @@ export interface IEventNamePropertyMapping {
         /**
          * `Yes` When 'Yes' option is selected
          * `No` When 'No' option is selected
-         * `Ignore` When 'Do not show again' option is clicked
+         * `Ignore` When "Don't show again" option is clicked
          *
          * @type {('Yes' | 'No' | 'Ignore' | undefined)}
          */
@@ -1571,7 +1571,7 @@ export interface IEventNamePropertyMapping {
         /**
          * Carries the selection of user when they are asked to take the extension survey
          */
-        selection: 'Yes' | 'Maybe later' | 'Do not show again' | undefined;
+        selection: 'Yes' | 'Maybe later' | "Don't show again" | undefined;
     };
     /**
      * Telemetry event sent when starting REPL

src/test/activation/extensionSurvey.unit.test.ts

@@ -355,7 +355,7 @@ suite('Extension survey prompt - showSurvey()', () => {
         platformService.verifyAll();
     });
 
-    test("Disable prompt if 'Do not show again' option is clicked", async () => {
+    test('Disable prompt if "Don\'t show again" option is clicked', async () => {
         const prompts = [ExtensionSurveyBanner.bannerLabelYes, ExtensionSurveyBanner.maybeLater, Common.doNotShowAgain];
         platformService.setup((p) => p.osType).verifiable(TypeMoq.Times.never());
         appShell

src/test/application/diagnostics/checks/macPythonInterpreter.unit.test.ts

@@ -220,7 +220,7 @@ suite('Application Diagnostics - Checks Mac Python Interpreter', () => {
             expect(messagePrompt).not.be.equal(undefined, 'Message prompt not set');
             expect(messagePrompt!.commandPrompts).to.be.deep.equal([
                 { prompt: 'Select Python Interpreter', command: cmd },
-                { prompt: 'Do not show again', command: cmdIgnore },
+                { prompt: "Don't show again", command: cmdIgnore },
             ]);
         });
         test('Should not display a message if No Interpreters diagnostic has been ignored', async () => {

src/test/common/installer/installer.unit.test.ts

@@ -307,10 +307,10 @@ suite('Module Installer only', () => {
                                         TypeMoq.It.isAnyString(),
                                         TypeMoq.It.isValue('Install'),
                                         TypeMoq.It.isValue('Select Linter'),
-                                        TypeMoq.It.isValue('Do not show again'),
+                                        TypeMoq.It.isValue("Don't show again"),
                                     ),
                                 )
-                                    .returns(async () => 'Do not show again')
+                                    .returns(async () => "Don't show again")
                                     .verifiable(TypeMoq.Times.once());
                                 const persistVal = TypeMoq.Mock.ofType<IPersistentState<boolean>>();
                                 let mockPersistVal = false;
@@ -367,7 +367,7 @@ suite('Module Installer only', () => {
                                         TypeMoq.It.isAnyString(),
                                         TypeMoq.It.isValue('Install'),
                                         TypeMoq.It.isValue('Select Linter'),
-                                        TypeMoq.It.isValue('Do not show again'),
+                                        TypeMoq.It.isValue("Don't show again"),
                                     ),
                                 )
                                     .returns(async () => undefined)
@@ -864,7 +864,7 @@ suite('Module Installer only', () => {
 
         test('Ensure 3 options for pylint', async () => {
             const product = Product.pylint;
-            const options = ['Select Linter', 'Do not show again'];
+            const options = ['Select Linter', "Don't show again"];
             const productName = ProductNames.get(product)!;
 
             await installer.promptToInstallImplementation(product, resource);
@@ -875,7 +875,7 @@ suite('Module Installer only', () => {
         });
         test('Ensure select linter command is invoked', async () => {
             const product = Product.pylint;
-            const options = ['Select Linter', 'Do not show again'];
+            const options = ['Select Linter', "Don't show again"];
             const productName = ProductNames.get(product)!;
             when(
                 appShell.showErrorMessage(`Linter ${productName} is not installed.`, 'Install', options[0], options[1]),
@@ -892,7 +892,7 @@ suite('Module Installer only', () => {
         });
         test('If install button is selected, install linter and return response', async () => {
             const product = Product.pylint;
-            const options = ['Select Linter', 'Do not show again'];
+            const options = ['Select Linter', "Don't show again"];
             const productName = ProductNames.get(product)!;
             when(
                 appShell.showErrorMessage(`Linter ${productName} is not installed.`, 'Install', options[0], options[1]),