Ensure interpreter is auto selected before updating status bar

src/client/activation/activationManager.ts

@@ -7,7 +7,7 @@ import { inject, injectable, multiInject } from 'inversify';
 import { TextDocument, workspace } from 'vscode';
 import { IApplicationDiagnostics } from '../application/types';
 import { IDocumentManager, IWorkspaceService } from '../common/application/types';
-import { isTestExecution } from '../common/constants';
+import { PYTHON_LANGUAGE } from '../common/constants';
 import { traceDecorators } from '../common/logger';
 import { IDisposable, Resource } from '../common/types';
 import { IInterpreterAutoSelectionService } from '../interpreter/autoSelection/types';
@@ -26,27 +26,40 @@ export class ExtensionActivationManager implements IExtensionActivationManager {
         @inject(IInterpreterAutoSelectionService) private readonly autoSelection: IInterpreterAutoSelectionService,
         @inject(IApplicationDiagnostics) private readonly appDiagnostics: IApplicationDiagnostics,
         @inject(IWorkspaceService) private readonly workspaceService: IWorkspaceService
-    ) { }
+    ) {}
 
     public dispose() {
         while (this.disposables.length > 0) {
-            const disposable = this.disposables.shift();
+            const disposable = this.disposables.shift()!;
             disposable.dispose();
         }
-        if (this. docOpenedHandler){
+        if (this.docOpenedHandler) {
             this.docOpenedHandler.dispose();
             this.docOpenedHandler = undefined;
         }
     }
     public async activate(): Promise<void> {
         await this.initialize();
         await this.activateWorkspace(this.getActiveResource());
+        await this.autoSelection.autoSelectInterpreter(undefined);
+    }
+    @traceDecorators.error('Failed to activate a workspace')
+    public async activateWorkspace(resource: Resource) {
+        const key = this.getWorkspaceKey(resource);
+        if (this.activatedWorkspaces.has(key)) {
+            return;
+        }
+        this.activatedWorkspaces.add(key);
+        // Get latest interpreter list in the background.
+        this.interpreterService.getInterpreters(resource).ignoreErrors();
+
+        await this.autoSelection.autoSelectInterpreter(resource);
+        await Promise.all(this.activationServices.map(item => item.activate(resource)));
+        await this.appDiagnostics.performPreStartupHealthCheck(resource);
     }
     protected async initialize() {
-        // Get latest interpreter list.
-        const mainWorkspaceUri = this.getActiveResource();
-        this.interpreterService.getInterpreters(mainWorkspaceUri).ignoreErrors();
         this.addHandlers();
+        this.addRemoveDocOpenedHandlers();
     }
     protected addHandlers() {
         this.disposables.push(this.workspaceService.onDidChangeWorkspaceFolders(this.onWorkspaceFoldersChanged, this));
@@ -67,45 +80,32 @@ export class ExtensionActivationManager implements IExtensionActivationManager {
         this.addRemoveDocOpenedHandlers();
     }
     protected hasMultipleWorkspaces() {
-        return this.workspaceService.hasWorkspaceFolders && this.workspaceService.workspaceFolders.length > 1;
+        return this.workspaceService.hasWorkspaceFolders && this.workspaceService.workspaceFolders!.length > 1;
     }
     protected onDocOpened(doc: TextDocument) {
+        if (doc.languageId !== PYTHON_LANGUAGE) {
+            return;
+        }
         const key = this.getWorkspaceKey(doc.uri);
+        // If we have opened a doc that does not belong to workspace, then do nothing.
+        if (key === '' && this.workspaceService.hasWorkspaceFolders) {
+            return;
+        }
         if (this.activatedWorkspaces.has(key)) {
             return;
         }
         const folder = this.workspaceService.getWorkspaceFolder(doc.uri);
         this.activateWorkspace(folder ? folder.uri : undefined).ignoreErrors();
     }
-    @traceDecorators.error('Failed to activate a worksapce')
-    protected async activateWorkspace(resource: Resource) {
-        const key = this.getWorkspaceKey(resource);
-        this.activatedWorkspaces.add(key);
-
-        await Promise.all(this.activationServices.map(item => item.activate(resource)));
-
-        // When testing, do not perform health checks, as modal dialogs can be displayed.
-        if (!isTestExecution()) {
-            await this.appDiagnostics.performPreStartupHealthCheck(resource);
-        }
-        await this.autoSelection.autoSelectInterpreter(resource);
-    }
     protected getWorkspaceKey(resource: Resource) {
-        if (!resource) {
-            return '';
-        }
-        const workspaceFolder = this.workspaceService.getWorkspaceFolder(resource);
-        if (!workspaceFolder) {
-            return '';
-        }
-        return workspaceFolder.uri.fsPath;
+        return this.workspaceService.getWorkspaceFolderIdentifier(resource, '');
     }
     private getActiveResource(): Resource {
         if (this.documentManager.activeTextEditor && !this.documentManager.activeTextEditor.document.isUntitled) {
             return this.documentManager.activeTextEditor.document.uri;
         }
-        return Array.isArray(this.workspaceService.workspaceFolders) && workspace.workspaceFolders.length > 0
-            ? workspace.workspaceFolders[0].uri
+        return Array.isArray(this.workspaceService.workspaceFolders) && workspace.workspaceFolders!.length > 0
+            ? workspace.workspaceFolders![0].uri
             : undefined;
     }
 }

src/client/activation/activationService.ts

@@ -22,11 +22,12 @@ type ActivatorInfo = { jedi: boolean; activator: ILanguageServerActivator };
 @injectable()
 export class LanguageServerExtensionActivationService implements IExtensionActivationService, Disposable {
     private currentActivator?: ActivatorInfo;
-    private activatedOnce: boolean;
+    private activatedOnce: boolean = false;
     private readonly workspaceService: IWorkspaceService;
     private readonly output: OutputChannel;
     private readonly appShell: IApplicationShell;
     private readonly lsNotSupportedDiagnosticService: IDiagnosticsService;
+    private resource!: Resource;
 
     constructor(@inject(IServiceContainer) private serviceContainer: IServiceContainer) {
         this.workspaceService = this.serviceContainer.get<IWorkspaceService>(IWorkspaceService);
@@ -41,10 +42,11 @@ export class LanguageServerExtensionActivationService implements IExtensionActiv
         disposables.push(this.workspaceService.onDidChangeConfiguration(this.onDidChangeConfiguration.bind(this)));
     }
 
-    public async activate(_resource: Resource): Promise<void> {
+    public async activate(resource: Resource): Promise<void> {
         if (this.currentActivator || this.activatedOnce) {
             return;
         }
+        this.resource = resource;
         this.activatedOnce = true;
 
         let jedi = this.useJedi();
@@ -114,10 +116,7 @@ export class LanguageServerExtensionActivationService implements IExtensionActiv
         }
     }
     private useJedi(): boolean {
-        const workspacesUris: (Uri | undefined)[] = this.workspaceService.hasWorkspaceFolders
-            ? this.workspaceService.workspaceFolders!.map(item => item.uri)
-            : [undefined];
-        const configuraionService = this.serviceContainer.get<IConfigurationService>(IConfigurationService);
-        return workspacesUris.filter(uri => configuraionService.getSettings(uri).jediEnabled).length > 0;
+        const configurationService = this.serviceContainer.get<IConfigurationService>(IConfigurationService);
+        return configurationService.getSettings(this.resource).jediEnabled;
     }
 }

src/client/activation/types.ts

@@ -13,6 +13,7 @@ import { IDisposable, LanguageServerDownloadChannels, Resource } from '../common
 export const IExtensionActivationManager = Symbol('IExtensionActivationManager');
 export interface IExtensionActivationManager extends IDisposable {
     activate(): Promise<void>;
+    activateWorkspace(resource: Resource): Promise<void>;
 }
 
 export const IExtensionActivationService = Symbol('IExtensionActivationService');

src/client/application/diagnostics/applicationDiagnostics.ts

@@ -5,7 +5,7 @@
 
 import { inject, injectable, named } from 'inversify';
 import { DiagnosticSeverity } from 'vscode';
-import { STANDARD_OUTPUT_CHANNEL } from '../../common/constants';
+import { isTestExecution, STANDARD_OUTPUT_CHANNEL } from '../../common/constants';
 import { ILogger, IOutputChannel, Resource } from '../../common/types';
 import { IServiceContainer } from '../../ioc/types';
 import { IApplicationDiagnostics } from '../types';
@@ -21,6 +21,10 @@ export class ApplicationDiagnostics implements IApplicationDiagnostics {
         this.serviceContainer.get<ISourceMapSupportService>(ISourceMapSupportService).register();
     }
     public async performPreStartupHealthCheck(resource: Resource): Promise<void> {
+        // When testing, do not perform health checks, as modal dialogs can be displayed.
+        if (!isTestExecution()) {
+            return;
+        }
         const services = this.serviceContainer.getAll<IDiagnosticsService>(IDiagnosticsService);
         // Perform these validation checks in the foreground.
         await this.runDiagnostics(services.filter(item => !item.runInBackground), resource);

src/client/common/application/types.ts

@@ -586,7 +586,7 @@ export interface IWorkspaceService {
      * @returns {string}
      * @memberof IWorkspaceService
      */
-    getWorkspaceFolderIdentifier(resource: Uri | undefined): string;
+    getWorkspaceFolderIdentifier(resource: Uri | undefined, defaultValue?: string): string;
     /**
      * Returns a path that is relative to the workspace folder or folders.
      *

src/client/common/application/workspace.ts

@@ -3,6 +3,7 @@
 
 import { injectable } from 'inversify';
 import { CancellationToken, ConfigurationChangeEvent, Event, FileSystemWatcher, GlobPattern, Uri, workspace, WorkspaceConfiguration, WorkspaceFolder, WorkspaceFoldersChangeEvent } from 'vscode';
+import { Resource } from '../types';
 import { IWorkspaceService } from './types';
 
 @injectable()
@@ -37,8 +38,8 @@ export class WorkspaceService implements IWorkspaceService {
     public findFiles(include: GlobPattern, exclude?: GlobPattern, maxResults?: number, token?: CancellationToken): Thenable<Uri[]> {
         return workspace.findFiles(include, exclude, maxResults, token);
     }
-    public getWorkspaceFolderIdentifier(resource: Uri): string {
+    public getWorkspaceFolderIdentifier(resource: Resource, defaultValue: string = ''): string {
         const workspaceFolder = resource ? workspace.getWorkspaceFolder(resource) : undefined;
-        return workspaceFolder ? workspaceFolder.uri.fsPath : '';
+        return workspaceFolder ? workspaceFolder.uri.fsPath : defaultValue;
     }
 }

src/client/common/configSettings.ts

@@ -65,7 +65,7 @@ export class PythonSettings implements IPythonSettings {
         return this.changed.event;
     }
 
-    constructor(workspaceFolder: Uri | undefined, private readonly InterpreterAutoSelectionService: IInterpreterAutoSeletionProxyService,
+    constructor(workspaceFolder: Uri | undefined, private readonly interpreterAutoSelectionService: IInterpreterAutoSeletionProxyService,
         workspace?: IWorkspaceService) {
         this.workspace = workspace || new WorkspaceService();
         this.workspaceRoot = workspaceFolder ? workspaceFolder : Uri.file(__dirname);
@@ -129,9 +129,9 @@ export class PythonSettings implements IPythonSettings {
         this.pythonPath = systemVariables.resolveAny(pythonSettings.get<string>('pythonPath'))!;
         // If user has defined a custom value, use it else try to get the best interpreter ourselves.
         if (this.pythonPath.length === 0 || this.pythonPath === 'python') {
-            const autoSelectedPythonInterpreter = this.InterpreterAutoSelectionService.getAutoSelectedInterpreter(this.workspaceRoot);
+            const autoSelectedPythonInterpreter = this.interpreterAutoSelectionService.getAutoSelectedInterpreter(this.workspaceRoot);
             if (autoSelectedPythonInterpreter) {
-                this.InterpreterAutoSelectionService.setWorkspaceInterpreter(this.workspaceRoot, autoSelectedPythonInterpreter).ignoreErrors();
+                this.interpreterAutoSelectionService.setWorkspaceInterpreter(this.workspaceRoot, autoSelectedPythonInterpreter).ignoreErrors();
             }
             this.pythonPath = autoSelectedPythonInterpreter ? autoSelectedPythonInterpreter.path : this.pythonPath;
         }
@@ -382,7 +382,7 @@ export class PythonSettings implements IPythonSettings {
             // Let's defer the change notification.
             this.debounceChangeNotification();
         };
-        this.disposables.push(this.InterpreterAutoSelectionService.onDidChangeAutoSelectedInterpreter(onDidChange.bind(this)));
+        this.disposables.push(this.interpreterAutoSelectionService.onDidChangeAutoSelectedInterpreter(onDidChange.bind(this)));
         this.disposables.push(this.workspace.onDidChangeConfiguration((event: ConfigurationChangeEvent) => {
             if (event.affectsConfiguration('python')) {
                 onDidChange();

src/client/common/process/types.ts

@@ -73,6 +73,7 @@ export type InterpreterInfomation = {
     sysVersion: string;
     architecture: Architecture;
     sysPrefix: string;
+    pipEnvWorkspaceFolder?: string;
 };
 export const IPythonExecutionService = Symbol('IPythonExecutionService');
 

src/client/common/terminal/environmentActivationProviders/pipEnvActivationProvider.ts

@@ -6,13 +6,17 @@
 import { inject, injectable } from 'inversify';
 import { Uri } from 'vscode';
 import { IInterpreterService, InterpreterType, IPipEnvService } from '../../../interpreter/contracts';
+import { IWorkspaceService } from '../../application/types';
+import { IFileSystem } from '../../platform/types';
 import { ITerminalActivationCommandProvider, TerminalShellType } from '../types';
 
 @injectable()
 export class PipEnvActivationCommandProvider implements ITerminalActivationCommandProvider {
     constructor(
         @inject(IInterpreterService) private readonly interpreterService: IInterpreterService,
-        @inject(IPipEnvService) private readonly pipenvService: IPipEnvService
+        @inject(IPipEnvService) private readonly pipenvService: IPipEnvService,
+        @inject(IWorkspaceService) private readonly workspaceService: IWorkspaceService,
+        @inject(IFileSystem) private readonly fs: IFileSystem
     ) { }
 
     public isShellSupported(_targetShell: TerminalShellType): boolean {
@@ -24,7 +28,12 @@ export class PipEnvActivationCommandProvider implements ITerminalActivationComma
         if (!interpreter || interpreter.type !== InterpreterType.Pipenv) {
             return;
         }
-
+        // Activate using `pipenv shell` only if the current folder relates pipenv environment.
+        const workspaceFolder = resource ? this.workspaceService.getWorkspaceFolder(resource) : undefined;
+        if (workspaceFolder && interpreter.pipEnvWorkspaceFolder &&
+            !this.fs.arePathsSame(workspaceFolder.uri.fsPath, interpreter.pipEnvWorkspaceFolder)) {
+            return;
+        }
         const execName = this.pipenvService.executable;
         return [`${execName.fileToCommandArgument()} shell`];
     }