Remove sort imports from command palette and context menu

package.json

@@ -430,11 +430,6 @@
                 "command": "python.setInterpreter",
                 "title": "%python.command.python.setInterpreter.title%"
             },
-            {
-                "category": "Python Refactor",
-                "command": "python.sortImports",
-                "title": "%python.command.python.sortImports.title%"
-            },
             {
                 "category": "Python",
                 "command": "python.startREPL",
@@ -1870,12 +1865,6 @@
                     "title": "%python.command.python.setInterpreter.title%",
                     "when": "!virtualWorkspace && shellExecutionSupported"
                 },
-                {
-                    "category": "Python Refactor",
-                    "command": "python.sortImports",
-                    "title": "%python.command.python.sortImports.title%",
-                    "when": "!virtualWorkspace && shellExecutionSupported && editorLangId == python"
-                },
                 {
                     "category": "Python",
                     "command": "python.startREPL",
@@ -1914,12 +1903,6 @@
                     "group": "Python",
                     "when": "editorLangId == python && !virtualWorkspace && shellExecutionSupported && isWorkspaceTrusted"
                 },
-                {
-                    "command": "python.sortImports",
-                    "group": "Refactor",
-                    "title": "%python.command.python.sortImports.title%",
-                    "when": "editorLangId == python && !notebookEditorFocused && !virtualWorkspace && shellExecutionSupported"
-                },
                 {
                     "submenu": "python.runFileInteractive",
                     "group": "Jupyter2",

src/client/common/utils/multiStepInput.ts

@@ -47,7 +47,7 @@ export interface IQuickPickParameters<T extends QuickPickItem, E = any> {
     totalSteps?: number;
     canGoBack?: boolean;
     items: T[];
-    activeItem?: T | Promise<T>;
+    activeItem?: T | ((quickPick: QuickPick<T>) => Promise<T>);
     placeholder: string | undefined;
     customButtonSetups?: QuickInputButtonSetup[];
     matchOnDescription?: boolean;
@@ -156,7 +156,13 @@ export class MultiStepInput<S> implements IMultiStepInput<S> {
             initialize(input);
         }
         if (activeItem) {
-            input.activeItems = [await activeItem];
+            if (typeof activeItem === 'function') {
+                activeItem(input).then((item) => {
+                    if (input.activeItems.length === 0) {
+                        input.activeItems = [item];
+                    }
+                });
+            }
         } else {
             input.activeItems = [];
         }

src/client/interpreter/activation/terminalEnvVarCollectionService.ts

@@ -37,6 +37,7 @@ import { EnvironmentVariables } from '../../common/variables/types';
 import { TerminalShellType } from '../../common/terminal/types';
 import { OSType } from '../../common/utils/platform';
 import { normCase } from '../../common/platform/fs-paths';
+import { PythonEnvType } from '../../pythonEnvironments/base/info';
 
 @injectable()
 export class TerminalEnvVarCollectionService implements IExtensionActivationService, ITerminalEnvVarCollectionService {
@@ -63,6 +64,8 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
      */
     private processEnvVars: EnvironmentVariables | undefined;
 
+    private separator: string;
+
     constructor(
         @inject(IPlatformService) private readonly platform: IPlatformService,
         @inject(IInterpreterService) private interpreterService: IInterpreterService,
@@ -75,7 +78,9 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
         @inject(IWorkspaceService) private workspaceService: IWorkspaceService,
         @inject(IConfigurationService) private readonly configurationService: IConfigurationService,
         @inject(IPathUtils) private readonly pathUtils: IPathUtils,
-    ) {}
+    ) {
+        this.separator = platform.osType === OSType.Windows ? ';' : ':';
+    }
 
     public async activate(resource: Resource): Promise<void> {
         try {
@@ -196,6 +201,9 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
                                 applyAtProcessCreation: true,
                             });
                         } else {
+                            if (!value.endsWith(this.separator)) {
+                                value = value.concat(this.separator);
+                            }
                             traceVerbose(`Prepending environment variable ${key} in collection to ${value}`);
                             envVarCollection.prepend(key, value, {
                                 applyAtShellIntegration: true,
@@ -257,8 +265,8 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
         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) {
+            const shouldSetPS1 = shouldPS1BeSet(interpreter?.type, env);
+            if (shouldSetPS1 && !env.PS1) {
                 // PS1 should be set but no PS1 was set.
                 return;
             }
@@ -284,8 +292,8 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
         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) {
+            const shouldSetPS1 = shouldPS1BeSet(interpreter?.type, env);
+            if (shouldSetPS1 && !env.PS1) {
                 // PS1 should be set but no PS1 was set.
                 return getPromptForEnv(interpreter);
             }
@@ -360,6 +368,22 @@ export class TerminalEnvVarCollectionService implements IExtensionActivationServ
     }
 }
 
+function shouldPS1BeSet(type: PythonEnvType | undefined, env: EnvironmentVariables): boolean {
+    if (type === PythonEnvType.Virtual) {
+        const promptDisabledVar = env.VIRTUAL_ENV_DISABLE_PROMPT;
+        const isPromptDisabled = promptDisabledVar && promptDisabledVar !== undefined;
+        return !isPromptDisabled;
+    }
+    if (type === PythonEnvType.Conda) {
+        // Instead of checking config value using `conda config --get changeps1`, simply check
+        // `CONDA_PROMPT_MODIFER` to avoid the cost of launching the conda binary.
+        const promptEnabledVar = env.CONDA_PROMPT_MODIFIER;
+        const isPromptEnabled = promptEnabledVar && promptEnabledVar !== '';
+        return !!isPromptEnabled;
+    }
+    return type !== undefined;
+}
+
 function shouldSkip(env: string) {
     return ['_', 'SHLVL'].includes(env);
 }

src/client/interpreter/autoSelection/index.ts

@@ -181,6 +181,11 @@ export class InterpreterAutoSelectionService implements IInterpreterAutoSelectio
         return this.stateFactory.createWorkspacePersistentState(key, undefined);
     }
 
+    private getAutoSelectionQueriedOnceState(): IPersistentState<boolean | undefined> {
+        const key = `autoSelectionInterpretersQueriedOnce`;
+        return this.stateFactory.createWorkspacePersistentState(key, undefined);
+    }
+
     /**
      * Auto-selection logic:
      * 1. If there are cached interpreters (not the first session in this workspace)
@@ -200,7 +205,12 @@ export class InterpreterAutoSelectionService implements IInterpreterAutoSelectio
             });
         }
 
-        await this.interpreterService.refreshPromise;
+        const globalQueriedState = this.getAutoSelectionQueriedOnceState();
+        if (!globalQueriedState.value) {
+            // Global interpreters are loaded the first time an extension loads, after which we don't need to
+            // wait on global interpreter promise refresh.
+            await this.interpreterService.refreshPromise;
+        }
         const interpreters = this.interpreterService.getInterpreters(resource);
         const workspaceUri = this.interpreterHelper.getActiveWorkspaceUri(resource);
 
@@ -215,6 +225,7 @@ export class InterpreterAutoSelectionService implements IInterpreterAutoSelectio
         }
 
         queriedState.updateValue(true);
+        globalQueriedState.updateValue(true);
 
         this.didAutoSelectedInterpreterEmitter.fire();
     }

src/client/interpreter/configuration/interpreterSelector/commands/setInterpreter.ts

@@ -50,7 +50,7 @@ import { BaseInterpreterSelectorCommand } from './base';
 const untildify = require('untildify');
 
 export type InterpreterStateArgs = { path?: string; workspace: Resource };
-type QuickPickType = IInterpreterQuickPickItem | ISpecialQuickPickItem | QuickPickItem;
+export type QuickPickType = IInterpreterQuickPickItem | ISpecialQuickPickItem | QuickPickItem;
 
 function isInterpreterQuickPickItem(item: QuickPickType): item is IInterpreterQuickPickItem {
     return 'interpreter' in item;
@@ -177,7 +177,7 @@ export class SetInterpreterCommand extends BaseInterpreterSelectorCommand implem
             items: suggestions,
             sortByLabel: !preserveOrderWhenFiltering,
             keepScrollPosition: true,
-            activeItem: this.getActiveItem(state.workspace, suggestions), // Use a promise here to ensure quickpick is initialized synchronously.
+            activeItem: (quickPick) => this.getActiveItem(state.workspace, quickPick), // Use a promise here to ensure quickpick is initialized synchronously.
             matchOnDetail: true,
             matchOnDescription: true,
             title,
@@ -277,8 +277,9 @@ export class SetInterpreterCommand extends BaseInterpreterSelectorCommand implem
         return getGroupedQuickPickItems(items, recommended, workspaceFolder?.uri.fsPath);
     }
 
-    private async getActiveItem(resource: Resource, suggestions: QuickPickType[]) {
+    private async getActiveItem(resource: Resource, quickPick: QuickPick<QuickPickType>) {
         const interpreter = await this.interpreterService.getActiveInterpreter(resource);
+        const suggestions = quickPick.items;
         const activeInterpreterItem = suggestions.find(
             (i) => isInterpreterQuickPickItem(i) && i.interpreter.id === interpreter?.id,
         );
@@ -339,7 +340,9 @@ export class SetInterpreterCommand extends BaseInterpreterSelectorCommand implem
                   return false;
               })
             : undefined;
-        quickPick.activeItems = activeItem ? [activeItem] : [];
+        if (activeItem) {
+            quickPick.activeItems = [activeItem];
+        }
     }
 
     /**

src/client/pythonEnvironments/base/locators/composite/envsCollectionService.ts

@@ -115,9 +115,9 @@ export class EnvsCollectionService extends PythonEnvsWatcher<PythonEnvCollection
                 // Do not trigger another refresh if a refresh has previously finished.
                 return Promise.resolve();
             }
-            refreshPromise = this.startRefresh(query);
+            refreshPromise = this.startRefresh(query).then(() => this.sendTelemetry(query, stopWatch));
         }
-        return refreshPromise.then(() => this.sendTelemetry(query, stopWatch));
+        return refreshPromise;
     }
 
     private startRefresh(query: PythonLocatorQuery | undefined): Promise<void> {

src/client/pythonEnvironments/base/locators/lowLevel/globalVirtualEnvronmentLocator.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import { uniq } from 'lodash';
+import { toLower, uniq, uniqBy } from 'lodash';
 import * as path from 'path';
 import { chain, iterable } from '../../../../common/utils/async';
 import { getEnvironmentVariable, getOSType, getUserHomeDir, OSType } from '../../../../common/utils/platform';
@@ -39,19 +39,22 @@ async function getGlobalVirtualEnvDirs(): Promise<string[]> {
 
     const homeDir = getUserHomeDir();
     if (homeDir && (await pathExists(homeDir))) {
-        const subDirs = ['Envs', '.direnv', '.venvs', '.virtualenvs', path.join('.local', 'share', 'virtualenvs')];
-        if (![OSType.Windows, OSType.OSX].includes(getOSType())) {
-            // Not a case insensitive platform, push both upper and lower cases.
-            subDirs.push('envs');
-        }
+        const subDirs = [
+            'envs',
+            'Envs',
+            '.direnv',
+            '.venvs',
+            '.virtualenvs',
+            path.join('.local', 'share', 'virtualenvs'),
+        ];
         const filtered = await asyncFilter(
             subDirs.map((d) => path.join(homeDir, d)),
             pathExists,
         );
         filtered.forEach((d) => venvDirs.push(d));
     }
 
-    return uniq(venvDirs);
+    return [OSType.Windows, OSType.OSX].includes(getOSType()) ? uniqBy(venvDirs, toLower) : uniq(venvDirs);
 }
 
 /**

src/test/configuration/interpreterSelector/commands/setInterpreter.unit.test.ts

@@ -31,6 +31,7 @@ import {
 import {
     EnvGroups,
     InterpreterStateArgs,
+    QuickPickType,
     SetInterpreterCommand,
 } from '../../../../client/interpreter/configuration/interpreterSelector/commands/setInterpreter';
 import {
@@ -265,8 +266,14 @@ suite('Set Interpreter Command', () => {
             delete actualParameters!.initialize;
             delete actualParameters!.customButtonSetups;
             delete actualParameters!.onChangeItem;
-            const activeItem = await actualParameters!.activeItem;
-            assert.deepStrictEqual(activeItem, recommended);
+            if (typeof actualParameters!.activeItem === 'function') {
+                const activeItem = await actualParameters!.activeItem(({ items: suggestions } as unknown) as QuickPick<
+                    QuickPickType
+                >);
+                assert.deepStrictEqual(activeItem, recommended);
+            } else {
+                assert(false, 'Not a function');
+            }
             delete actualParameters!.activeItem;
             assert.deepStrictEqual(actualParameters, expectedParameters, 'Params not equal');
         });
@@ -308,8 +315,14 @@ suite('Set Interpreter Command', () => {
             delete actualParameters!.initialize;
             delete actualParameters!.customButtonSetups;
             delete actualParameters!.onChangeItem;
-            const activeItem = await actualParameters!.activeItem;
-            assert.deepStrictEqual(activeItem, noPythonInstalled);
+            if (typeof actualParameters!.activeItem === 'function') {
+                const activeItem = await actualParameters!.activeItem(({ items: suggestions } as unknown) as QuickPick<
+                    QuickPickType
+                >);
+                assert.deepStrictEqual(activeItem, noPythonInstalled);
+            } else {
+                assert(false, 'Not a function');
+            }
             delete actualParameters!.activeItem;
             assert.deepStrictEqual(actualParameters, expectedParameters, 'Params not equal');
         });
@@ -666,8 +679,14 @@ suite('Set Interpreter Command', () => {
             delete actualParameters!.initialize;
             delete actualParameters!.customButtonSetups;
             delete actualParameters!.onChangeItem;
-            const activeItem = await actualParameters!.activeItem;
-            assert.deepStrictEqual(activeItem, recommended);
+            if (typeof actualParameters!.activeItem === 'function') {
+                const activeItem = await actualParameters!.activeItem(({ items: suggestions } as unknown) as QuickPick<
+                    QuickPickType
+                >);
+                assert.deepStrictEqual(activeItem, recommended);
+            } else {
+                assert(false, 'Not a function');
+            }
             delete actualParameters!.activeItem;
 
             assert.deepStrictEqual(actualParameters, expectedParameters, 'Params not equal');