Tie 'Python extension loading...' text with the new discovery component (#14925)

Kartik Raj · web-flow · commit e5c8fbba5147 · 2020-12-10T11:01:45.000-08:00
* Tie 'Python extension loading...' text with the new discovery component

* Register via IExtensionSingleActivationService

* Use addBinding instead
diff --git a/src/client/interpreter/display/progressDisplay.ts b/src/client/interpreter/display/progressDisplay.ts
@@ -4,14 +4,23 @@
 'use strict';
 
 import { inject, injectable } from 'inversify';
-import { Disposable, ProgressLocation, ProgressOptions } from 'vscode';
+import { Disposable, Event, ProgressLocation, ProgressOptions } from 'vscode';
 import { IApplicationShell } from '../../common/application/types';
 import { traceDecorators } from '../../common/logger';
 import { IDisposableRegistry } from '../../common/types';
 import { createDeferred, Deferred } from '../../common/utils/async';
 import { Common, Interpreters } from '../../common/utils/localize';
-import { IInterpreterLocatorProgressHandler, IInterpreterLocatorProgressService } from '../contracts';
+import {
+    IComponentAdapter,
+    IInterpreterLocatorProgressHandler,
+    IInterpreterLocatorProgressService
+} from '../contracts';
 
+// The parts of IComponentAdapter used here.
+export interface IComponent {
+    readonly onRefreshing: Event<void> | undefined;
+    readonly onRefreshed: Event<void> | undefined;
+}
 @injectable()
 export class InterpreterLocatorProgressStatubarHandler implements IInterpreterLocatorProgressHandler {
     private deferred: Deferred<void> | undefined;
@@ -20,11 +29,14 @@ export class InterpreterLocatorProgressStatubarHandler implements IInterpreterLo
         @inject(IApplicationShell) private readonly shell: IApplicationShell,
         @inject(IInterpreterLocatorProgressService)
         private readonly progressService: IInterpreterLocatorProgressService,
-        @inject(IDisposableRegistry) private readonly disposables: Disposable[]
+        @inject(IDisposableRegistry) private readonly disposables: Disposable[],
+        @inject(IComponentAdapter) private readonly pyenvs: IComponent
     ) {}
     public register() {
-        this.progressService.onRefreshing(() => this.showProgress(), this, this.disposables);
-        this.progressService.onRefreshed(() => this.hideProgress(), this, this.disposables);
+        const onRefreshing = this.pyenvs.onRefreshing ?? this.progressService.onRefreshing;
+        const onRefreshed = this.pyenvs.onRefreshed ?? this.progressService.onRefreshed;
+        onRefreshing(() => this.showProgress(), this, this.disposables);
+        onRefreshed(() => this.hideProgress(), this, this.disposables);
     }
     @traceDecorators.verbose('Display locator refreshing progress')
     private showProgress(): void {
diff --git a/src/client/pythonEnvironments/legacyIOC.ts b/src/client/pythonEnvironments/legacyIOC.ts
@@ -3,6 +3,7 @@
 
 import { injectable } from 'inversify';
 import * as vscode from 'vscode';
+import { IExtensionSingleActivationService } from '../activation/types';
 import { DiscoveryVariants } from '../common/experiments/groups';
 import { getVersionString, parseVersion } from '../common/utils/version';
 import {
@@ -135,21 +136,45 @@ function convertEnvInfo(info: PythonEnvInfo): PythonEnvironment {
 export interface IPythonEnvironments extends ILocator {}
 
 @injectable()
-class ComponentAdapter implements IComponentAdapter {
+class ComponentAdapter implements IComponentAdapter, IExtensionSingleActivationService {
     // this will be set based on experiment
-    private _enabled?: boolean;
+    private enabled?: boolean;
+
+    private readonly refreshing = new vscode.EventEmitter<void>();
+
+    private readonly refreshed = new vscode.EventEmitter<void>();
 
     constructor(
         // The adapter only wraps one thing: the component API.
         private readonly api: IPythonEnvironments,
         private readonly environmentsSecurity: IEnvironmentsSecurity,
     ) {}
 
+    public async activate(): Promise<void> {
+        this.enabled = (await Promise.all(
+            [
+                inExperiment(DiscoveryVariants.discoverWithFileWatching),
+                inExperiment(DiscoveryVariants.discoveryWithoutFileWatching),
+            ],
+        )).includes(true);
+    }
+
+    // IInterpreterLocatorProgressHandler
+
+    // A result of `undefined` means "Fall back to the old code!"
+    public get onRefreshing(): vscode.Event<void> | undefined {
+        return this.enabled ? this.refreshing.event : undefined;
+    }
+
+    public get onRefreshed(): vscode.Event<void> | undefined {
+        return this.enabled ? this.refreshing.event : undefined;
+    }
+
     // IInterpreterHelper
 
     // A result of `undefined` means "Fall back to the old code!"
     public async getInterpreterInformation(pythonPath: string): Promise<undefined | Partial<PythonEnvironment>> {
-        if (!(await this.isEnabled())) {
+        if (!this.enabled) {
             return undefined;
         }
         const env = await this.api.resolveEnv(pythonPath);
@@ -161,7 +186,7 @@ class ComponentAdapter implements IComponentAdapter {
 
     // A result of `undefined` means "Fall back to the old code!"
     public async isMacDefaultPythonPath(pythonPath: string): Promise<boolean | undefined> {
-        if (!(await this.isEnabled())) {
+        if (!this.enabled) {
             return undefined;
         }
         const env = await this.api.resolveEnv(pythonPath);
@@ -180,7 +205,7 @@ class ComponentAdapter implements IComponentAdapter {
         pythonPath: string,
         resource?: vscode.Uri,
     ): Promise<undefined | PythonEnvironment> {
-        if (!(await this.isEnabled())) {
+        if (!this.enabled) {
             return undefined;
         }
         const info = buildEnvInfo({ executable: pythonPath });
@@ -201,7 +226,7 @@ class ComponentAdapter implements IComponentAdapter {
 
     // A result of `undefined` means "Fall back to the old code!"
     public async isCondaEnvironment(interpreterPath: string): Promise<boolean | undefined> {
-        if (!(await this.isEnabled())) {
+        if (!this.enabled) {
             return undefined;
         }
         const env = await this.api.resolveEnv(interpreterPath);
@@ -213,7 +238,7 @@ class ComponentAdapter implements IComponentAdapter {
 
     // A result of `undefined` means "Fall back to the old code!"
     public async getCondaEnvironment(interpreterPath: string): Promise<CondaEnvironmentInfo | undefined> {
-        if (!(await this.isEnabled())) {
+        if (!this.enabled) {
             return undefined;
         }
         const env = await this.api.resolveEnv(interpreterPath);
@@ -234,7 +259,7 @@ class ComponentAdapter implements IComponentAdapter {
 
     // A result of `undefined` means "Fall back to the old code!"
     public async isWindowsStoreInterpreter(pythonPath: string): Promise<boolean | undefined> {
-        if (!(await this.isEnabled())) {
+        if (!this.enabled) {
             return undefined;
         }
         const env = await this.api.resolveEnv(pythonPath);
@@ -248,13 +273,11 @@ class ComponentAdapter implements IComponentAdapter {
 
     // A result of `undefined` means "Fall back to the old code!"
     public get hasInterpreters(): Promise<boolean | undefined> {
-        return this.isEnabled().then((enabled) => {
-            if (enabled) {
-                const iterator = this.api.iterEnvs();
-                return iterator.next().then((res) => !res.done);
-            }
-            return undefined;
-        });
+        if (!this.enabled) {
+            return Promise.resolve(undefined);
+        }
+        const iterator = this.api.iterEnvs();
+        return iterator.next().then((res) => !res.done);
     }
 
     // A result of `undefined` means "Fall back to the old code!"
@@ -267,9 +290,10 @@ class ComponentAdapter implements IComponentAdapter {
         //     onSuggestion?: boolean;
         // }
     ): Promise<PythonEnvironment[] | undefined> {
-        if (!(await this.isEnabled())) {
+        if (!this.enabled) {
             return undefined;
         }
+        this.refreshing.fire(); // Notify locators are locating.
         if (options?.onSuggestion) {
             // For now, until we have the concept of trusted workspaces, we assume all interpreters as safe
             // to run once user has triggered discovery, i.e interacted with the extension.
@@ -288,20 +312,9 @@ class ComponentAdapter implements IComponentAdapter {
 
         const iterator = this.api.iterEnvs(query);
         const envs = await getEnvs(iterator);
-        return envs.map(convertEnvInfo);
-    }
-
-    private async isEnabled(): Promise<boolean> {
-        if (this._enabled === undefined) {
-            this._enabled = (await Promise.all(
-                [
-                    inExperiment(DiscoveryVariants.discoverWithFileWatching),
-                    inExperiment(DiscoveryVariants.discoveryWithoutFileWatching),
-                ],
-            )).includes(true);
-        }
-
-        return this._enabled;
+        const legacyEnvs = envs.map(convertEnvInfo);
+        this.refreshed.fire(); // Notify all locators have completed locating.
+        return legacyEnvs;
     }
 }
 
@@ -399,4 +412,5 @@ export function registerNewDiscoveryForIOC(
         IComponentAdapter,
         new ComponentAdapter(api, environmentsSecurity),
     );
+    serviceManager.addBinding(IComponentAdapter, IExtensionSingleActivationService);
 }
diff --git a/src/test/interpreters/display/progressDisplay.unit.test.ts b/src/test/interpreters/display/progressDisplay.unit.test.ts
@@ -11,7 +11,7 @@ import { CancellationToken, Disposable, Progress, ProgressOptions } from 'vscode
 import { ApplicationShell } from '../../../client/common/application/applicationShell';
 import { Common, Interpreters } from '../../../client/common/utils/localize';
 import { noop } from '../../../client/common/utils/misc';
-import { IInterpreterLocatorProgressService } from '../../../client/interpreter/contracts';
+import { IComponentAdapter, IInterpreterLocatorProgressService } from '../../../client/interpreter/contracts';
 import { InterpreterLocatorProgressStatubarHandler } from '../../../client/interpreter/display/progressDisplay';
 
 type ProgressTask<R> = (
@@ -38,7 +38,12 @@ suite('Interpreters - Display Progress', () => {
 
     test('Display loading message when refreshing interpreters for the first time', async () => {
         const shell = mock(ApplicationShell);
-        const statusBar = new InterpreterLocatorProgressStatubarHandler(instance(shell), progressService, []);
+        const statusBar = new InterpreterLocatorProgressStatubarHandler(
+            instance(shell),
+            progressService,
+            [],
+            instance(mock(IComponentAdapter))
+        );
         when(shell.withProgress(anything(), anything())).thenResolve();
 
         statusBar.register();
@@ -50,7 +55,12 @@ suite('Interpreters - Display Progress', () => {
 
     test('Display refreshing message when refreshing interpreters for the second time', async () => {
         const shell = mock(ApplicationShell);
-        const statusBar = new InterpreterLocatorProgressStatubarHandler(instance(shell), progressService, []);
+        const statusBar = new InterpreterLocatorProgressStatubarHandler(
+            instance(shell),
+            progressService,
+            [],
+            instance(mock(IComponentAdapter))
+        );
         when(shell.withProgress(anything(), anything())).thenResolve();
 
         statusBar.register();
@@ -67,7 +77,12 @@ suite('Interpreters - Display Progress', () => {
 
     test('Progress message is hidden when loading has completed', async () => {
         const shell = mock(ApplicationShell);
-        const statusBar = new InterpreterLocatorProgressStatubarHandler(instance(shell), progressService, []);
+        const statusBar = new InterpreterLocatorProgressStatubarHandler(
+            instance(shell),
+            progressService,
+            [],
+            instance(mock(IComponentAdapter))
+        );
         when(shell.withProgress(anything(), anything())).thenResolve();
 
         statusBar.register();
