Register properly

Author: Kartik Raj

src/client/pythonEnvironments/base/locator.ts

@@ -57,9 +57,7 @@ type EnvironmentDetailsByProvider = Partial<EnvironmentDetails> &
     Pick<EnvironmentDetails, 'executable'> &
     Pick<EnvironmentDetails, 'environment'>;
 
-export type IInternalEnvironmentProvider =
-    | (ILocatorFactoryAPI & IInternalResolverAPI & IInternalIdentifierAPI)
-    | (ILocatorFactoryAPI & IInternalResolverAPI);
+export type IInternalEnvironmentProvider = ILocatorFactoryAPI & IInternalResolverAPI;
 
 interface ILocatorFactoryAPI {
     /**
@@ -72,11 +70,13 @@ export type ProposedDetailsAPI = (env: BaseEnvInfo) => Promise<EnvironmentDetail
 export type InternalDetailsAPI = (env: BasicEnvInfo) => Promise<PythonEnvInfo | undefined>;
 export interface IResolverAPI {
     /**
-     * Carries API to check if an environment can be recognized by the provider. Providers
-     * which returns details about an {@link EnvSource} are expected to
-     * provide this.
+     * Environment source the provider identifies/resolves.
      */
-    readonly sourceIdentifier: IIdentifierAPI | undefined;
+    readonly envSource: EnvSource | undefined;
+    /**
+     * Returns true if provided environment is recognized by the provider.
+     */
+    canIdentifyEnvironment: (path: UniquePathType) => Promise<boolean>;
     /**
      * Returns details or `undefined` if it was found if env is invalid.
      * This is only called if:
@@ -86,28 +86,10 @@ export interface IResolverAPI {
     getEnvironmentDetails: ProposedDetailsAPI;
 }
 
-interface IIdentifierAPI {
-    /**
-     * Environment source the provider identifies.
-     */
-    readonly envSource: EnvSource;
-    /**
-     * Returns true if provided environment is recognized by the provider.
-     */
-    canIdentifyEnvironment: (path: UniquePathType) => Promise<boolean>;
-}
-
 export interface IInternalResolverAPI {
-    readonly kindIdentifier: IInternalIdentifierAPI | undefined;
-    getEnvironmentDetails: InternalDetailsAPI;
-}
-
-interface IInternalIdentifierAPI {
-    readonly envKind: PythonEnvKind;
-    /**
-     * Returns true if provided environment is recognized by the provider.
-     */
+    readonly envKind: PythonEnvKind | undefined;
     canIdentifyEnvironment: (path: UniquePathType) => Promise<boolean>;
+    getEnvironmentDetails: InternalDetailsAPI;
 }
 
 export type ILocatorFactory = IWorkspaceLocatorFactory | INonWorkspaceLocatorFactory;

src/client/pythonEnvironments/base/locators/composite/envsResolver.ts

@@ -5,7 +5,7 @@ import { cloneDeep } from 'lodash';
 import { Event, EventEmitter } from 'vscode';
 import { identifyEnvironment, registerIdentifier } from '../../../common/environmentIdentifier';
 import { IEnvironmentInfoService } from '../../info/environmentInfoService';
-import { PythonEnvInfo } from '../../info';
+import { PythonEnvInfo, PythonEnvKind } from '../../info';
 import { getEnvPath, setEnvDisplayString } from '../../info/env';
 import { InterpreterInformation } from '../../info/interpreter';
 import {
@@ -40,14 +40,21 @@ export class PythonEnvsResolver implements IResolvingLocator {
         if (this.parentLocator.addNewLocator) {
             this.parentLocator.addNewLocator(provider.createLocator, metadata);
         }
-        if (provider.kindIdentifier) {
+        if (provider.envKind) {
+            registerIdentifier(provider.envKind, provider.canIdentifyEnvironment, metadata.extensionId);
+            registerResolver(provider.envKind, provider.getEnvironmentDetails, metadata.extensionId);
+        } else {
             registerIdentifier(
-                provider.kindIdentifier.envKind,
-                provider.kindIdentifier.canIdentifyEnvironment,
+                metadata.extensionId as PythonEnvKind,
+                provider.canIdentifyEnvironment,
+                metadata.extensionId,
+            );
+            registerResolver(
+                metadata.extensionId as PythonEnvKind,
+                provider.getEnvironmentDetails,
                 metadata.extensionId,
             );
         }
-        registerResolver(metadata.environments.envKinds[0], provider.getEnvironmentDetails);
     }
 
     constructor(

src/client/pythonEnvironments/converter.ts

@@ -47,12 +47,8 @@ export function convertProviderMetaData(proposed: EnvironmentProviderMetadata):
 
 function convertResolverAPI(proposed: IResolverAPI): IInternalResolverAPI {
     return {
-        kindIdentifier: proposed.sourceIdentifier
-            ? {
-                  envKind: convertKind(proposed.sourceIdentifier.envSource),
-                  canIdentifyEnvironment: proposed.sourceIdentifier.canIdentifyEnvironment,
-              }
-            : undefined,
+        envKind: proposed.envSource ? convertKind(proposed.envSource) : undefined,
+        canIdentifyEnvironment: proposed.canIdentifyEnvironment,
         getEnvironmentDetails: convertDetailsAPI(proposed.getEnvironmentDetails),
     };
 }