Implement a per interpreter language server cache

.vscode/launch.json

@@ -94,6 +94,30 @@
             },
             "skipFiles": ["<node_internals>/**"]
         },
+        {
+            // Note, for the smoke test you want to debug, you may need to copy the file,
+            // rename it and remove a check for only smoke tests.
+            "name": "Tests (Smoke, VS Code, *.test.ts)",
+            "type": "extensionHost",
+            "request": "launch",
+            "runtimeExecutable": "${execPath}",
+            "args": [
+                "${workspaceFolder}/src/testMultiRootWkspc/smokeTests",
+                "--disable-extensions",
+                "--extensionDevelopmentPath=${workspaceFolder}",
+                "--extensionTestsPath=${workspaceFolder}/out/test"
+            ],
+            "env": {
+                "VSC_PYTHON_CI_TEST_GREP": "Smoke Test"
+            },
+            "stopOnEntry": false,
+            "sourceMaps": true,
+            "outFiles": [
+                "${workspaceFolder}/out/**/*.js"
+            ],
+            "preLaunchTask": "Compile",
+            "skipFiles": ["<node_internals>/**"]
+        },
         {
             "name": "Tests (Single Workspace, VS Code, *.test.ts)",
             "type": "extensionHost",

news/1 Enhancements/8206.md

@@ -0,0 +1 @@
+Support a per interpreter language server so that notebooks that aren't using the currently selected python can still have intellisense.

src/client/activation/activationService.ts

@@ -1,106 +1,131 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
-
-'use strict';
+import '../common/extensions';
 
 import { inject, injectable } from 'inversify';
 import { ConfigurationChangeEvent, Disposable, OutputChannel, Uri } from 'vscode';
+
 import { LSNotSupportedDiagnosticServiceId } from '../application/diagnostics/checks/lsNotSupported';
 import { IDiagnosticsService } from '../application/diagnostics/types';
 import { IApplicationShell, ICommandManager, IWorkspaceService } from '../common/application/types';
 import { STANDARD_OUTPUT_CHANNEL } from '../common/constants';
 import { LSControl, LSEnabled } from '../common/experimentGroups';
-import '../common/extensions';
 import { traceError } from '../common/logger';
-import { IConfigurationService, IDisposableRegistry, IExperimentsManager, IOutputChannel, IPersistentStateFactory, IPythonSettings, Resource } from '../common/types';
+import {
+    IConfigurationService,
+    IDisposableRegistry,
+    IExperimentsManager,
+    IOutputChannel,
+    IPersistentStateFactory,
+    IPythonSettings,
+    Resource
+} from '../common/types';
 import { swallowExceptions } from '../common/utils/decorators';
+import { noop } from '../common/utils/misc';
+import { IInterpreterService, PythonInterpreter } from '../interpreter/contracts';
 import { IServiceContainer } from '../ioc/types';
 import { sendTelemetryEvent } from '../telemetry';
 import { EventName } from '../telemetry/constants';
-import { IExtensionActivationService, ILanguageServerActivator, LanguageServerActivator } from './types';
+import { Commands } from './languageServer/constants';
+import { RefCountedLanguageServer } from './refCountedLanguageServer';
+import {
+    IExtensionActivationService,
+    ILanguageServerActivator,
+    ILanguageServerCache,
+    LanguageServerActivator
+} from './types';
 
 const jediEnabledSetting: keyof IPythonSettings = 'jediEnabled';
 const workspacePathNameForGlobalWorkspaces = '';
-type ActivatorInfo = { jedi: boolean; activator: ILanguageServerActivator };
+
+interface IActivatedServer {
+    key: string;
+    server: ILanguageServerActivator;
+    jedi: boolean;
+}
 
 @injectable()
-export class LanguageServerExtensionActivationService implements IExtensionActivationService, Disposable {
-    private lsActivatedWorkspaces = new Map<string, ILanguageServerActivator>();
-    private currentActivator?: ActivatorInfo;
-    private jediActivatedOnce: boolean = false;
+export class LanguageServerExtensionActivationService implements IExtensionActivationService, ILanguageServerCache, Disposable {
+    private cache = new Map<string, Promise<RefCountedLanguageServer>>();
+    private activatedServer?: IActivatedServer;
     private readonly workspaceService: IWorkspaceService;
     private readonly output: OutputChannel;
     private readonly appShell: IApplicationShell;
     private readonly lsNotSupportedDiagnosticService: IDiagnosticsService;
+    private readonly interpreterService: IInterpreterService;
     private resource!: Resource;
 
     constructor(@inject(IServiceContainer) private serviceContainer: IServiceContainer,
         @inject(IPersistentStateFactory) private stateFactory: IPersistentStateFactory,
         @inject(IExperimentsManager) private readonly abExperiments: IExperimentsManager) {
         this.workspaceService = this.serviceContainer.get<IWorkspaceService>(IWorkspaceService);
+        this.interpreterService = this.serviceContainer.get<IInterpreterService>(IInterpreterService);
         this.output = this.serviceContainer.get<OutputChannel>(IOutputChannel, STANDARD_OUTPUT_CHANNEL);
         this.appShell = this.serviceContainer.get<IApplicationShell>(IApplicationShell);
         this.lsNotSupportedDiagnosticService = this.serviceContainer.get<IDiagnosticsService>(
             IDiagnosticsService,
             LSNotSupportedDiagnosticServiceId
         );
+        const commandManager = this.serviceContainer.get<ICommandManager>(ICommandManager);
         const disposables = serviceContainer.get<IDisposableRegistry>(IDisposableRegistry);
         disposables.push(this);
         disposables.push(this.workspaceService.onDidChangeConfiguration(this.onDidChangeConfiguration.bind(this)));
         disposables.push(this.workspaceService.onDidChangeWorkspaceFolders(this.onWorkspaceFoldersChanged, this));
+        disposables.push(this.interpreterService.onDidChangeInterpreter(this.onDidChangeInterpreter.bind(this)));
+        disposables.push(commandManager.registerCommand(Commands.ClearAnalyisCache, this.onClearAnalysisCaches.bind(this)));
     }
 
     public async activate(resource: Resource): Promise<void> {
+        // Get a new server and dispose of the old one (might be the same one)
         this.resource = resource;
-        let jedi = this.useJedi();
-        if (!jedi) {
-            if (this.lsActivatedWorkspaces.has(this.getWorkspacePathKey(resource))) {
-                return;
-            }
-            const diagnostic = await this.lsNotSupportedDiagnosticService.diagnose(undefined);
-            this.lsNotSupportedDiagnosticService.handle(diagnostic).ignoreErrors();
-            if (diagnostic.length) {
-                sendTelemetryEvent(EventName.PYTHON_LANGUAGE_SERVER_PLATFORM_SUPPORTED, undefined, { supported: false });
-                jedi = true;
-            }
-        } else {
-            if (this.jediActivatedOnce) {
-                return;
-            }
-            this.jediActivatedOnce = true;
+        const interpreter = await this.interpreterService.getActiveInterpreter(resource);
+        const key = await this.getKey(resource, interpreter);
+
+        // If we have an old server with a different key, then deactivate it as the
+        // creation of the new server may fail if this server is still connected
+        if (this.activatedServer && this.activatedServer.key !== key) {
+            this.activatedServer.server.deactivate();
         }
 
-        await this.logStartup(jedi);
-        let activatorName = jedi ? LanguageServerActivator.Jedi : LanguageServerActivator.DotNet;
-        let activator = this.serviceContainer.get<ILanguageServerActivator>(ILanguageServerActivator, activatorName);
-        this.currentActivator = { jedi, activator };
+        // Get the new item
+        const result = await this.get(resource, interpreter);
 
-        try {
-            await activator.activate(resource);
-            if (!jedi) {
-                this.lsActivatedWorkspaces.set(this.getWorkspacePathKey(resource), activator);
-            }
-        } catch (ex) {
-            if (jedi) {
-                return;
-            }
-            //Language server fails, reverting to jedi
-            if (this.jediActivatedOnce) {
-                return;
-            }
-            this.jediActivatedOnce = true;
-            jedi = true;
-            await this.logStartup(jedi);
-            activatorName = LanguageServerActivator.Jedi;
-            activator = this.serviceContainer.get<ILanguageServerActivator>(ILanguageServerActivator, activatorName);
-            this.currentActivator = { jedi, activator };
-            await activator.activate(resource);
+        // Now we dispose. This ensures the object stays alive if it's the same object because
+        // we dispose after we increment the ref count.
+        if (this.activatedServer) {
+            this.activatedServer.server.dispose();
+        }
+
+        // Save our active server.
+        this.activatedServer = { key, server: result, jedi: result.type === LanguageServerActivator.Jedi };
+
+        // Force this server to reconnect (if disconnected) as it should be the active
+        // language server for all of VS code.
+        this.activatedServer.server.activate();
+    }
+
+    public async get(resource: Resource, interpreter?: PythonInterpreter): Promise<RefCountedLanguageServer> {
+        // See if we already have it or not
+        const key = await this.getKey(resource, interpreter);
+        let result: Promise<RefCountedLanguageServer> | undefined = this.cache.get(key);
+        if (!result) {
+            // Create a special ref counted result so we don't dispose of the
+            // server too soon.
+            result = this.createRefCountedServer(resource, interpreter, key);
+            this.cache.set(key, result);
+        } else {
+            // Increment ref count if already exists.
+            result = result.then(r => {
+                r.increment();
+                return r;
+            });
         }
+        return result;
     }
 
     public dispose() {
-        if (this.currentActivator) {
-            this.currentActivator.activator.dispose();
+        if (this.activatedServer) {
+            this.activatedServer.server.dispose();
         }
     }
     @swallowExceptions('Send telemetry for Language Server current selection')
@@ -149,19 +174,60 @@ export class LanguageServerExtensionActivationService implements IExtensionActiv
         return enabled;
     }
 
-    protected onWorkspaceFoldersChanged() {
+    protected async onWorkspaceFoldersChanged() {
         //If an activated workspace folder was removed, dispose its activator
-        const workspaceKeys = this.workspaceService.workspaceFolders!.map(workspaceFolder => this.getWorkspacePathKey(workspaceFolder.uri));
-        const activatedWkspcKeys = Array.from(this.lsActivatedWorkspaces.keys());
+        const workspaceKeys = await Promise.all(this.workspaceService.workspaceFolders!.map(workspaceFolder => this.getKey(workspaceFolder.uri)));
+        const activatedWkspcKeys = Array.from(this.cache.keys());
         const activatedWkspcFoldersRemoved = activatedWkspcKeys.filter(item => workspaceKeys.indexOf(item) < 0);
         if (activatedWkspcFoldersRemoved.length > 0) {
             for (const folder of activatedWkspcFoldersRemoved) {
-                this.lsActivatedWorkspaces.get(folder)!.dispose();
-                this.lsActivatedWorkspaces!.delete(folder);
+                const server = await this.cache.get(folder);
+                server?.dispose(); // This should remove it from the cache if this is the last instance.
             }
         }
     }
 
+    private async onDidChangeInterpreter() {
+        // Reactivate the resource. It should destroy the old one if it's different.
+        return this.activate(this.resource);
+    }
+
+    private async createRefCountedServer(resource: Resource, interpreter: PythonInterpreter | undefined, key: string): Promise<RefCountedLanguageServer> {
+        let jedi = this.useJedi();
+        if (!jedi) {
+            const diagnostic = await this.lsNotSupportedDiagnosticService.diagnose(undefined);
+            this.lsNotSupportedDiagnosticService.handle(diagnostic).ignoreErrors();
+            if (diagnostic.length) {
+                sendTelemetryEvent(EventName.PYTHON_LANGUAGE_SERVER_PLATFORM_SUPPORTED, undefined, { supported: false });
+                jedi = true;
+            }
+        }
+
+        await this.logStartup(jedi);
+        let serverName = jedi ? LanguageServerActivator.Jedi : LanguageServerActivator.DotNet;
+        let server = this.serviceContainer.get<ILanguageServerActivator>(ILanguageServerActivator, serverName);
+        try {
+            await server.start(resource, interpreter);
+        } catch (ex) {
+            if (jedi) {
+                throw ex;
+            }
+            await this.logStartup(jedi);
+            serverName = LanguageServerActivator.Jedi;
+            server = this.serviceContainer.get<ILanguageServerActivator>(ILanguageServerActivator, serverName);
+            await server.start(resource, interpreter);
+        }
+
+        // Wrap the returned server in something that ref counts it.
+        return new RefCountedLanguageServer(server, serverName, () => {
+            // When we finally remove the last ref count, remove from the cache
+            this.cache.delete(key);
+
+            // Dispose of the actual server.
+            server.dispose();
+        });
+    }
+
     private async logStartup(isJedi: boolean): Promise<void> {
         const outputLine = isJedi
             ? 'Starting Jedi Python language engine.'
@@ -177,10 +243,9 @@ export class LanguageServerExtensionActivationService implements IExtensionActiv
             return;
         }
         const jedi = this.useJedi();
-        if (this.currentActivator && this.currentActivator.jedi === jedi) {
+        if (this.activatedServer && this.activatedServer.jedi === jedi) {
             return;
         }
-
         const item = await this.appShell.showInformationMessage(
             'Please reload the window switching between language engines.',
             'Reload'
@@ -189,7 +254,15 @@ export class LanguageServerExtensionActivationService implements IExtensionActiv
             this.serviceContainer.get<ICommandManager>(ICommandManager).executeCommand('workbench.action.reloadWindow');
         }
     }
-    private getWorkspacePathKey(resource: Resource): string {
-        return this.workspaceService.getWorkspaceFolderIdentifier(resource, workspacePathNameForGlobalWorkspaces);
+    private async getKey(resource: Resource, interpreter?: PythonInterpreter): Promise<string> {
+        const resourcePortion = this.workspaceService.getWorkspaceFolderIdentifier(resource, workspacePathNameForGlobalWorkspaces);
+        interpreter = interpreter ? interpreter : await this.interpreterService.getActiveInterpreter(resource);
+        const interperterPortion = interpreter ? `${interpreter.path}-${interpreter.envName}` : '';
+        return `${resourcePortion}-${interperterPortion}`;
+    }
+
+    private async onClearAnalysisCaches() {
+        const values = await Promise.all([...this.cache.values()]);
+        values.forEach(v => v.clearAnalysisCache ? v.clearAnalysisCache() : noop());
     }
 }