Remove uses of getAll where it's not needed

Author: Kartik Raj

src/client/activation/activationManager.ts

@@ -78,7 +78,7 @@ export class ExtensionActivationManager implements IExtensionActivationManager {
 
         // Get latest interpreter list in the background.
         addItemsToRunAfterActivation(() => {
-            this.interpreterService.getAllInterpreters(resource).ignoreErrors();
+            this.interpreterService.getInterpreters(resource).ignoreErrors();
         });
 
         await sendActivationTelemetry(this.fileSystem, this.workspaceService, resource);

src/client/application/diagnostics/checks/macPythonInterpreter.ts

@@ -87,7 +87,7 @@ export class InvalidMacPythonInterpreterService extends BaseDiagnosticsService {
             return [];
         }
 
-        const hasInterpreters = await this.interpreterService.hasInterpreters;
+        const hasInterpreters = await this.interpreterService.hasInterpreters();
         if (!hasInterpreters) {
             return [];
         }
@@ -104,17 +104,20 @@ export class InvalidMacPythonInterpreterService extends BaseDiagnosticsService {
             return [];
         }
 
-        const interpreters = await this.interpreterService.getAllInterpreters(resource);
-        for (const info of interpreters) {
-            if (!(await this.helper.isMacDefaultPythonPath(info.path))) {
-                return [
-                    new InvalidMacPythonInterpreterDiagnostic(
-                        DiagnosticCodes.MacInterpreterSelectedAndHaveOtherInterpretersDiagnostic,
-                        resource,
-                    ),
-                ];
-            }
+        if (
+            await this.interpreterService.hasInterpreters((e) =>
+                this.helper.isMacDefaultPythonPath(e.path).then((x) => !x),
+            )
+        ) {
+            // If non-mac default interpreters exist.
+            return [
+                new InvalidMacPythonInterpreterDiagnostic(
+                    DiagnosticCodes.MacInterpreterSelectedAndHaveOtherInterpretersDiagnostic,
+                    resource,
+                ),
+            ];
         }
+
         return [
             new InvalidMacPythonInterpreterDiagnostic(
                 DiagnosticCodes.MacInterpreterSelectedAndNoOtherInterpretersDiagnostic,

src/client/application/diagnostics/checks/pythonInterpreter.ts

@@ -67,12 +67,7 @@ export class InvalidPythonInterpreterService extends BaseDiagnosticsService {
         }
 
         const interpreterService = this.serviceContainer.get<IInterpreterService>(IInterpreterService);
-        // hasInterpreters being false can mean one of 2 things:
-        // 1. getInterpreters hasn't returned any interpreters;
-        // 2. getInterpreters hasn't run yet.
-        // We want to make sure that false comes from 1, so we're adding this fix until we refactor interpreter discovery.
-        // Also see https://github.com/microsoft/vscode-python/issues/3023.
-        const hasInterpreters = await interpreterService.hasInterpreters;
+        const hasInterpreters = await interpreterService.hasInterpreters();
 
         if (!hasInterpreters) {
             return [new InvalidPythonInterpreterDiagnostic(DiagnosticCodes.NoPythonInterpretersDiagnostic, resource)];

src/client/debugger/extension/adapter/factory.ts

@@ -114,7 +114,7 @@ export class DebugAdapterDescriptorFactory implements IDebugAdapterDescriptorFac
             return interpreter.path;
         }
 
-        await this.interpreterService.hasInterpreters; // Wait until we know whether we have an interpreter
+        await this.interpreterService.hasInterpreters(); // Wait until we know whether we have an interpreter
         const interpreters = await this.interpreterService.getInterpreters(resourceUri);
         if (interpreters.length === 0) {
             this.notifySelectInterpreter().ignoreErrors();

src/client/interpreter/contracts.ts

@@ -43,7 +43,7 @@ export interface IComponentAdapter {
     // VirtualEnvPrompt
     onDidCreate(resource: Resource, callback: () => void): Disposable;
     // IInterpreterLocatorService
-    hasInterpreters: Promise<boolean>;
+    hasInterpreters(filter?: (e: PythonEnvironment) => Promise<boolean>): Promise<boolean>;
     getInterpreters(resource?: Uri, source?: PythonEnvSource[]): PythonEnvironment[];
 
     // WorkspaceVirtualEnvInterpretersAutoSelectionRule
@@ -111,7 +111,7 @@ export interface IInterpreterService {
     onDidChangeInterpreterConfiguration: Event<Uri | undefined>;
     onDidChangeInterpreter: Event<void>;
     onDidChangeInterpreterInformation: Event<PythonEnvironment>;
-    hasInterpreters: Promise<boolean>;
+    hasInterpreters(filter?: (e: PythonEnvironment) => Promise<boolean>): Promise<boolean>;
     getInterpreters(resource?: Uri, options?: GetInterpreterOptions): Promise<PythonEnvironment[]>;
     getAllInterpreters(resource?: Uri, options?: GetInterpreterOptions): Promise<PythonEnvironment[]>;
     getActiveInterpreter(resource?: Uri): Promise<PythonEnvironment | undefined>;

src/client/interpreter/interpreterService.ts

@@ -42,10 +42,12 @@ type StoredPythonEnvironment = PythonEnvironment & { store?: boolean };
 
 @injectable()
 export class InterpreterService implements Disposable, IInterpreterService {
-    public get hasInterpreters(): Promise<boolean> {
+    public async hasInterpreters(
+        filter: (e: PythonEnvironment) => Promise<boolean> = async () => true,
+    ): Promise<boolean> {
         return inDiscoveryExperiment(this.experimentService).then((inExp) => {
             if (inExp) {
-                return this.pyenvs.hasInterpreters;
+                return this.pyenvs.hasInterpreters(filter);
             }
             const locator = this.serviceContainer.get<IInterpreterLocatorService>(
                 IInterpreterLocatorService,

src/client/pythonEnvironments/legacyIOC.ts

@@ -68,6 +68,7 @@ import { IExtensionSingleActivationService } from '../activation/types';
 import { EnvironmentInfoServiceQueuePriority, getEnvironmentInfoService } from './base/info/environmentInfoService';
 import { createDeferred } from '../common/utils/async';
 import { PythonEnvCollectionChangedEvent } from './base/watcher';
+import { asyncFilter } from '../common/utils/arrayUtils';
 
 const convertedKinds = new Map(
     Object.entries({
@@ -138,18 +139,10 @@ class ComponentAdapter implements IComponentAdapter {
 
     private readonly refreshed = new vscode.EventEmitter<void>();
 
-    private readonly onAddedToCollection = createDeferred();
-
     constructor(
         // The adapter only wraps one thing: the component API.
         private readonly api: IDiscoveryAPI,
-    ) {
-        this.api.onChanged((e: PythonEnvCollectionChangedEvent) => {
-            if (e.update) {
-                this.onAddedToCollection.resolve();
-            }
-        });
-    }
+    ) {}
 
     public triggerRefresh(query?: PythonLocatorQuery): Promise<void> {
         return this.api.triggerRefresh(query);
@@ -260,17 +253,27 @@ class ComponentAdapter implements IComponentAdapter {
     }
 
     // Implements IInterpreterLocatorService
-    public get hasInterpreters(): Promise<boolean> {
+    public async hasInterpreters(
+        filter: (e: PythonEnvironment) => Promise<boolean> = async () => true,
+    ): Promise<boolean> {
+        const onAddedToCollection = createDeferred();
+        // Watch for collection changed events.
+        this.api.onChanged(async (e: PythonEnvCollectionChangedEvent) => {
+            if (e.update) {
+                if (await filter(convertEnvInfo(e.update))) {
+                    onAddedToCollection.resolve();
+                }
+            }
+        });
         const initialEnvs = this.api.getEnvs();
         if (initialEnvs.length > 0) {
-            return Promise.resolve(true);
+            return true;
         }
         // We should already have initiated discovery. Wait for an env to be added
         // to the collection until the refresh has finished.
-        return Promise.race([this.onAddedToCollection.promise, this.api.refreshPromise]).then(() => {
-            const envs = this.api.getEnvs();
-            return envs.length > 0;
-        });
+        await Promise.race([onAddedToCollection.promise, this.api.refreshPromise]);
+        const envs = await asyncFilter(this.api.getEnvs(), (e) => filter(convertEnvInfo(e)));
+        return envs.length > 0;
     }
 
     public getInterpreters(resource?: vscode.Uri, source?: PythonEnvSource[]): PythonEnvironment[] {

src/client/startupTelemetry.ts

@@ -105,21 +105,19 @@ async function getActivationTelemetryProps(serviceContainer: IServiceContainer):
         ? workspaceService.workspaceFolders![0].uri
         : undefined;
     const settings = configurationService.getSettings(mainWorkspaceUri);
-    const [condaVersion, interpreter, interpreters] = await Promise.all([
+    const [condaVersion, interpreter, hasPython3] = await Promise.all([
         condaLocator
             .getCondaVersion()
             .then((ver) => (ver ? ver.raw : ''))
             .catch<string>(() => ''),
         interpreterService.getActiveInterpreter().catch<PythonEnvironment | undefined>(() => undefined),
-        interpreterService.getAllInterpreters(mainWorkspaceUri).catch<PythonEnvironment[]>(() => []),
+        interpreterService.hasInterpreters(async (item) => item.version?.major === 3),
     ]);
     const workspaceFolderCount = workspaceService.hasWorkspaceFolders ? workspaceService.workspaceFolders!.length : 0;
     const pythonVersion = interpreter && interpreter.version ? interpreter.version.raw : undefined;
     const interpreterType = interpreter ? interpreter.envType : undefined;
     const usingUserDefinedInterpreter = hasUserDefinedPythonPath(mainWorkspaceUri, serviceContainer);
     const usingGlobalInterpreter = isUsingGlobalInterpreterInWorkspace(settings.pythonPath, serviceContainer);
-    const hasPython3 =
-        interpreters!.filter((item) => (item && item.version ? item.version.major === 3 : false)).length > 0;
 
     return {
         condaVersion,