Only activate interpreter and language server component when in a virtual workspace

Author: Kartik Raj

src/client/activation/activationManager.ts

@@ -16,10 +16,10 @@ import { IInterpreterAutoSelectionService } from '../interpreter/autoSelection/t
 import { traceDecoratorError } from '../logging';
 import { sendActivationTelemetry } from '../telemetry/envFileTelemetry';
 import {
+    ComponentId,
     IExtensionActivationManager,
     IExtensionActivationService,
     IExtensionSingleActivationService,
-    ILanguageServerActivation,
 } from './types';
 
 @injectable()
@@ -44,7 +44,6 @@ export class ExtensionActivationManager implements IExtensionActivationManager {
         @inject(IActiveResourceService) private readonly activeResourceService: IActiveResourceService,
         @inject(IExperimentService) private readonly experiments: IExperimentService,
         @inject(IInterpreterPathService) private readonly interpreterPathService: IInterpreterPathService,
-        @inject(ILanguageServerActivation) private readonly languageServerActivation: ILanguageServerActivation,
     ) {}
 
     public dispose(): void {
@@ -63,14 +62,14 @@ export class ExtensionActivationManager implements IExtensionActivationManager {
 
         // Activate all activation services together.
 
-        if (this.workspaceService.isVirtualWorkspace) {
-            await this.activateWorkspace(this.activeResourceService.getActiveResource());
-        } else {
-            await Promise.all([
-                ...this.singleActivationServices.map((item) => item.activate()),
-                this.activateWorkspace(this.activeResourceService.getActiveResource()),
-            ]);
-        }
+        const singleActivationServices = this.workspaceService.isVirtualWorkspace
+            ? this.singleActivationServices.filter((s) => s.componentId === ComponentId.interpreter)
+            : this.singleActivationServices;
+
+        await Promise.all([
+            ...singleActivationServices.map((item) => item.activate()),
+            this.activateWorkspace(this.activeResourceService.getActiveResource()),
+        ]);
     }
 
     @traceDecoratorError('Failed to activate a workspace')
@@ -81,18 +80,20 @@ export class ExtensionActivationManager implements IExtensionActivationManager {
         }
         this.activatedWorkspaces.add(key);
 
+        if (this.experiments.inExperimentSync(DeprecatePythonPath.experiment)) {
+            await this.interpreterPathService.copyOldInterpreterStorageValuesToNew(resource);
+        }
+
         await sendActivationTelemetry(this.fileSystem, this.workspaceService, resource);
 
-        if (this.workspaceService.isVirtualWorkspace) {
-            await this.languageServerActivation.activate(resource);
-        } else {
-            if (this.experiments.inExperimentSync(DeprecatePythonPath.experiment)) {
-                await this.interpreterPathService.copyOldInterpreterStorageValuesToNew(resource);
-            }
-            await this.autoSelection.autoSelectInterpreter(resource);
-            await Promise.all(this.activationServices.map((item) => item.activate(resource)));
-            await this.appDiagnostics.performPreStartupHealthCheck(resource);
-        }
+        await this.autoSelection.autoSelectInterpreter(resource);
+        const activationServices = this.workspaceService.isVirtualWorkspace
+            ? this.activationServices.filter(
+                  (s) => s.componentId === ComponentId.interpreter || s.componentId === ComponentId.languageServer,
+              )
+            : this.activationServices;
+        await Promise.all(activationServices.map((item) => item.activate(resource)));
+        await this.appDiagnostics.performPreStartupHealthCheck(resource);
     }
 
     public async initialize(): Promise<void> {

src/client/activation/activationService.ts

@@ -25,6 +25,7 @@ import { EventName } from '../telemetry/constants';
 import { LanguageServerChangeHandler } from './common/languageServerChangeHandler';
 import { RefCountedLanguageServer } from './refCountedLanguageServer';
 import {
+    ComponentId,
     IExtensionActivationService,
     ILanguageServerActivator,
     ILanguageServerCache,
@@ -49,13 +50,15 @@ export class LanguageServerExtensionActivationService
 
     private activatedServer?: IActivatedServer;
 
+    public readonly componentId? = ComponentId.languageServer;
+
     private readonly workspaceService: IWorkspaceService;
 
     private readonly configurationService: IConfigurationService;
 
     private readonly output: OutputChannel;
 
-    private readonly interpreterService?: IInterpreterService;
+    private readonly interpreterService: IInterpreterService;
 
     private readonly languageServerChangeHandler: LanguageServerChangeHandler;
 
@@ -67,18 +70,14 @@ export class LanguageServerExtensionActivationService
     ) {
         this.workspaceService = this.serviceContainer.get<IWorkspaceService>(IWorkspaceService);
         this.configurationService = this.serviceContainer.get<IConfigurationService>(IConfigurationService);
-        if (!this.workspaceService.isVirtualWorkspace) {
-            this.interpreterService = this.serviceContainer.get<IInterpreterService>(IInterpreterService);
-        }
+        this.interpreterService = this.serviceContainer.get<IInterpreterService>(IInterpreterService);
         this.output = this.serviceContainer.get<OutputChannel>(IOutputChannel, STANDARD_OUTPUT_CHANNEL);
 
         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));
-        if (this.interpreterService) {
-            disposables.push(this.interpreterService.onDidChangeInterpreter(this.onDidChangeInterpreter.bind(this)));
-        }
+        disposables.push(this.interpreterService.onDidChangeInterpreter(this.onDidChangeInterpreter.bind(this)));
 
         this.languageServerChangeHandler = new LanguageServerChangeHandler(
             this.getCurrentLanguageServerType(),
@@ -95,7 +94,7 @@ export class LanguageServerExtensionActivationService
         const stopWatch = new StopWatch();
         // Get a new server and dispose of the old one (might be the same one)
         this.resource = resource;
-        const interpreter = await this.interpreterService?.getActiveInterpreter(resource);
+        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
@@ -307,7 +306,7 @@ export class LanguageServerExtensionActivationService
             resource,
             workspacePathNameForGlobalWorkspaces,
         );
-        interpreter = interpreter || (await this.interpreterService?.getActiveInterpreter(resource));
+        interpreter = interpreter || (await this.interpreterService.getActiveInterpreter(resource));
         const interperterPortion = interpreter ? `${interpreter.path}-${interpreter.envName}` : '';
         return `${resourcePortion}-${interperterPortion}`;
     }

src/client/activation/serviceRegistry.ts

@@ -22,7 +22,6 @@ import {
     IExtensionActivationService,
     IExtensionSingleActivationService,
     ILanguageClientFactory,
-    ILanguageServerActivation,
     ILanguageServerActivator,
     ILanguageServerAnalysisOptions,
     ILanguageServerCache,
@@ -38,7 +37,6 @@ import { LoadLanguageServerExtension } from './common/loadLanguageServerExtensio
 export function registerTypes(serviceManager: IServiceManager, languageServerType: LanguageServerType): void {
     serviceManager.addSingleton<ILanguageServerCache>(ILanguageServerCache, LanguageServerExtensionActivationService);
     serviceManager.addBinding(ILanguageServerCache, IExtensionActivationService);
-    serviceManager.addBinding(ILanguageServerCache, ILanguageServerActivation);
     serviceManager.add<IExtensionActivationManager>(IExtensionActivationManager, ExtensionActivationManager);
     serviceManager.add<ILanguageServerActivator>(
         ILanguageServerActivator,

src/client/activation/types.ts

@@ -58,6 +58,7 @@ export const IExtensionActivationService = Symbol('IExtensionActivationService')
  * @interface IExtensionActivationService
  */
 export interface IExtensionActivationService {
+    componentId?: ComponentId;
     activate(resource: Resource): Promise<void>;
 }
 
@@ -104,9 +105,6 @@ export interface ILanguageServerCache {
     get(resource: Resource, interpreter?: PythonEnvironment): Promise<ILanguageServer>;
 }
 
-export const ILanguageServerActivation = Symbol('ILanguageServerActivation');
-export interface ILanguageServerActivation extends IExtensionActivationService {}
-
 export type FolderVersionPair = { path: string; version: SemVer };
 export const ILanguageServerFolderService = Symbol('ILanguageServerFolderService');
 
@@ -171,6 +169,12 @@ export interface ILanguageServerOutputChannel {
     readonly channel: IOutputChannel;
 }
 
+export enum ComponentId {
+    other = 0,
+    interpreter = 1,
+    languageServer = 2,
+}
+
 export const IExtensionSingleActivationService = Symbol('IExtensionSingleActivationService');
 /**
  * Classes implementing this interface will have their `activate` methods
@@ -181,5 +185,6 @@ export const IExtensionSingleActivationService = Symbol('IExtensionSingleActivat
  * @interface IExtensionSingleActivationService
  */
 export interface IExtensionSingleActivationService {
+    componentId?: ComponentId;
     activate(): Promise<void>;
 }

src/client/extension.ts

@@ -42,7 +42,6 @@ import { sendErrorTelemetry, sendStartupTelemetry } from './startupTelemetry';
 import { IStartupDurations } from './types';
 import { runAfterActivation } from './common/utils/runAfterActivation';
 import { IInterpreterService } from './interpreter/contracts';
-import { WorkspaceService } from './common/application/workspace';
 
 durations.codeLoadingTime = stopWatch.elapsedTime;
 
@@ -70,12 +69,9 @@ export async function activate(context: IExtensionContext): Promise<IExtensionAp
     // Send the "success" telemetry only if activation did not fail.
     // Otherwise Telemetry is send via the error handler.
 
-    const workspace = new WorkspaceService();
-    if (!workspace.isVirtualWorkspace) {
-        sendStartupTelemetry(ready, durations, stopWatch, serviceContainer)
-            // Run in the background.
-            .ignoreErrors();
-    }
+    sendStartupTelemetry(ready, durations, stopWatch, serviceContainer)
+        // Run in the background.
+        .ignoreErrors();
     return api;
 }
 
@@ -137,13 +133,11 @@ async function activateUnsafe(
     setTimeout(async () => {
         if (activatedServiceContainer) {
             const workspaceService = activatedServiceContainer.get<IWorkspaceService>(IWorkspaceService);
-            if (!workspaceService.isVirtualWorkspace) {
-                const interpreterManager = activatedServiceContainer.get<IInterpreterService>(IInterpreterService);
-                const workspaces = workspaceService.workspaceFolders ?? [];
-                await interpreterManager
-                    .refresh(workspaces.length > 0 ? workspaces[0].uri : undefined)
-                    .catch((ex) => traceError('Python Extension: interpreterManager.refresh', ex));
-            }
+            const interpreterManager = activatedServiceContainer.get<IInterpreterService>(IInterpreterService);
+            const workspaces = workspaceService.workspaceFolders ?? [];
+            await interpreterManager
+                .refresh(workspaces.length > 0 ? workspaces[0].uri : undefined)
+                .catch((ex) => traceError('Python Extension: interpreterManager.refresh', ex));
         }
 
         runAfterActivation();
@@ -167,10 +161,7 @@ async function handleError(ex: Error, startupDurations: IStartupDurations) {
     );
     traceError('extension activation failed', ex);
 
-    const workspace = new WorkspaceService();
-    if (!workspace.isVirtualWorkspace) {
-        await sendErrorTelemetry(ex, startupDurations, activatedServiceContainer);
-    }
+    await sendErrorTelemetry(ex, startupDurations, activatedServiceContainer);
 }
 
 interface IAppShell {

src/client/extensionActivation.ts

@@ -70,11 +70,6 @@ export async function activateComponents(
     // https://github.com/microsoft/vscode-python/issues/15380
     // These will go away eventually once everything is refactored into components.
     const legacyActivationResult = await activateLegacy(ext);
-    const workspaceService = ext.legacyIOC.serviceContainer.get<IWorkspaceService>(IWorkspaceService);
-    if (workspaceService.isVirtualWorkspace) {
-        // Nothing other than Pylance is activated when using virtual workspaces.
-        return [legacyActivationResult];
-    }
     const promises: Promise<ActivationResult>[] = [
         // More component activations will go here
         pythonEnvironments.activate(components.pythonEnvs, ext),
@@ -122,8 +117,9 @@ async function activateLegacy(ext: ExtensionState): Promise<ActivationResult> {
     // directly queries VSCode API.
     setLoggingLevel(getLoggingLevel());
 
-    // `IConfigurationService` may depend any of the registered types, so doing it after all registrations are finished.
     const configuration = serviceManager.get<IConfigurationService>(IConfigurationService);
+    // Settings are dependent on Experiment service, so we need to initialize it after experiments are activated.
+    serviceContainer.get<IConfigurationService>(IConfigurationService).getSettings().initialize();
     const languageServerType = configuration.getSettings().languageServer;
 
     // Language feature registrations.
@@ -137,12 +133,12 @@ async function activateLegacy(ext: ExtensionState): Promise<ActivationResult> {
     const workspaceService = serviceContainer.get<IWorkspaceService>(IWorkspaceService);
     const cmdManager = serviceContainer.get<ICommandManager>(ICommandManager);
     languages.setLanguageConfiguration(PYTHON_LANGUAGE, getLanguageConfiguration());
+    const interpreterManager = serviceContainer.get<IInterpreterService>(IInterpreterService);
+    interpreterManager.initialize();
     if (!workspaceService.isVirtualWorkspace) {
         const handlers = serviceManager.getAll<IDebugSessionEventHandlers>(IDebugSessionEventHandlers);
         const dispatcher = new DebugSessionEventDispatcher(handlers, DebugService.instance, disposables);
         dispatcher.registerEventHandlers();
-        const interpreterManager = serviceContainer.get<IInterpreterService>(IInterpreterService);
-        interpreterManager.initialize();
 
         const outputChannel = serviceManager.get<OutputChannel>(IOutputChannel, STANDARD_OUTPUT_CHANNEL);
         disposables.push(cmdManager.registerCommand(Commands.ViewOutput, () => outputChannel.show()));
@@ -194,9 +190,6 @@ async function activateLegacy(ext: ExtensionState): Promise<ActivationResult> {
     const manager = serviceContainer.get<IExtensionActivationManager>(IExtensionActivationManager);
     context.subscriptions.push(manager);
 
-    // Settings are dependent on Experiment service, so we need to initialize it after experiments are activated.
-    serviceContainer.get<IConfigurationService>(IConfigurationService).getSettings().initialize();
-
     const activationPromise = manager.activate();
 
     return { fullyReady: activationPromise };

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

@@ -6,14 +6,15 @@
 import { injectable, unmanaged } from 'inversify';
 import * as path from 'path';
 import { ConfigurationTarget, Disposable, QuickPickItem, Uri } from 'vscode';
-import { IExtensionSingleActivationService } from '../../../../activation/types';
+import { ComponentId, IExtensionSingleActivationService } from '../../../../activation/types';
 import { IApplicationShell, ICommandManager, IWorkspaceService } from '../../../../common/application/types';
 import { IDisposable, Resource } from '../../../../common/types';
 import { Interpreters } from '../../../../common/utils/localize';
 import { IPythonPathUpdaterServiceManager } from '../../types';
 
 @injectable()
 export abstract class BaseInterpreterSelectorCommand implements IExtensionSingleActivationService, IDisposable {
+    public readonly componentId = ComponentId.interpreter;
     protected disposables: Disposable[] = [];
     constructor(
         @unmanaged() protected readonly pythonPathUpdaterService: IPythonPathUpdaterServiceManager,

src/client/interpreter/virtualEnvs/condaInheritEnvPrompt.ts

@@ -3,7 +3,7 @@
 
 import { inject, injectable, optional } from 'inversify';
 import { ConfigurationTarget, Uri } from 'vscode';
-import { IExtensionActivationService } from '../../activation/types';
+import { ComponentId, IExtensionActivationService } from '../../activation/types';
 import { IApplicationShell, IWorkspaceService } from '../../common/application/types';
 import { IPlatformService } from '../../common/platform/types';
 import { IBrowserService, IPersistentStateFactory } from '../../common/types';
@@ -18,6 +18,7 @@ export const condaInheritEnvPromptKey = 'CONDA_INHERIT_ENV_PROMPT_KEY';
 
 @injectable()
 export class CondaInheritEnvPrompt implements IExtensionActivationService {
+    public readonly componentId = ComponentId.interpreter;
     constructor(
         @inject(IInterpreterService) private readonly interpreterService: IInterpreterService,
         @inject(IWorkspaceService) private readonly workspaceService: IWorkspaceService,

src/client/interpreter/virtualEnvs/virtualEnvPrompt.ts

@@ -3,7 +3,7 @@
 
 import { inject, injectable } from 'inversify';
 import { ConfigurationTarget, Disposable, Uri } from 'vscode';
-import { IExtensionActivationService } from '../../activation/types';
+import { ComponentId, IExtensionActivationService } from '../../activation/types';
 import { IApplicationShell } from '../../common/application/types';
 import { IDisposableRegistry, IPersistentStateFactory } from '../../common/types';
 import { sleep } from '../../common/utils/async';
@@ -18,6 +18,8 @@ import { IComponentAdapter, IInterpreterHelper } from '../contracts';
 const doNotDisplayPromptStateKey = 'MESSAGE_KEY_FOR_VIRTUAL_ENV';
 @injectable()
 export class VirtualEnvironmentPrompt implements IExtensionActivationService {
+    public readonly componentId = ComponentId.interpreter;
+
     constructor(
         @inject(IPersistentStateFactory) private readonly persistentStateFactory: IPersistentStateFactory,
         @inject(IInterpreterHelper) private readonly helper: IInterpreterHelper,

src/client/jupyter/jupyterIntegration.ts

@@ -9,7 +9,6 @@ import { dirname } from 'path';
 import { CancellationToken, Disposable, Event, Extension, Memento, Uri } from 'vscode';
 import * as lsp from 'vscode-languageserver-protocol';
 import { ILanguageServerCache, ILanguageServerConnection } from '../activation/types';
-import { IWorkspaceService } from '../common/application/types';
 import { JUPYTER_EXTENSION_ID } from '../common/constants';
 import { InterpreterUri, ModuleInstallFlags } from '../common/installer/types';
 import {
@@ -177,14 +176,10 @@ export class JupyterExtensionIntegration {
         @inject(IMemento) @named(GLOBAL_MEMENTO) private globalState: Memento,
         @inject(IInterpreterDisplay) private interpreterDisplay: IInterpreterDisplay,
         @inject(IComponentAdapter) private pyenvs: IComponentAdapter,
-        @inject(IWorkspaceService) private workspace: IWorkspaceService,
     ) {}
 
     public registerApi(jupyterExtensionApi: JupyterExtensionApi): JupyterExtensionApi | undefined {
         // Forward python parts
-        if (this.workspace.isVirtualWorkspace) {
-            return undefined;
-        }
         jupyterExtensionApi.registerPythonApi({
             onDidChangeInterpreter: this.interpreterService.onDidChangeInterpreter,
             getActiveInterpreter: async (resource?: Uri) => this.interpreterService.getActiveInterpreter(resource),