Skip legacy capability inference for updated managers

src/legacyCapabilities.ts

@@ -21,6 +21,10 @@ export async function getLegacyPackageManagerCapability(
     packageManager: PackageManager,
     capability: PackageManagerCapability,
 ): Promise<Support> {
+    // Skip legacy method inspection when the package manager advertises capabilities.
+    if (packageManager.capabilities) {
+        return unsupportedCapability({});
+    }
     switch (capability) {
         case PackageCapability.List:
             return getMethodSupport(packageManager.getPackages, packageManager.refresh);
@@ -48,6 +52,10 @@ export async function getLegacyEnvironmentManagerCapability(
     environmentManager: EnvironmentManager,
     capability: EnvironmentManagerCapability,
 ): Promise<Support> {
+    // Skip legacy method inspection when the environment manager advertises capabilities.
+    if (environmentManager.capabilities) {
+        return unsupportedCapability({});
+    }
     switch (capability) {
         case EnvironmentCapability.List:
             return getMethodSupport(environmentManager.getEnvironments, environmentManager.refresh);

src/test/legacyCapabilities.unit.test.ts

@@ -7,6 +7,7 @@ import type { EnvironmentManagerCapability, PackageManagerCapability } from '../
 import { EnvironmentCapability, PackageCapability } from '../capabilities';
 import { getLegacyEnvironmentManagerCapability, getLegacyPackageManagerCapability } from '../legacyCapabilities';
 import type { EnvironmentManager, PackageManager } from '../types';
+import { allSupportedEnvironmentCapabilities, allSupportedPackageCapabilities } from './capabilityFixtures';
 
 function unexpectedOperation(): never {
     throw new Error('Legacy capability inference must not invoke operations');
@@ -16,6 +17,39 @@ const legacySupported = { supported: true, isLegacy: true };
 const legacyUnsupported = { supported: false, reason: l10n.t('Capability not implemented'), isLegacy: true };
 
 suite('Legacy manager capabilities', () => {
+    test('package capability advertisements disable legacy inference even when methods are present', async () => {
+        const manager: PackageManager = {
+            name: 'advertised',
+            manage: unexpectedOperation,
+            refresh: unexpectedOperation,
+            getPackages: unexpectedOperation,
+            capabilities: allSupportedPackageCapabilities,
+        };
+
+        assert.deepStrictEqual(await getLegacyPackageManagerCapability(manager, PackageCapability.Install), {
+            supported: false,
+            reason: l10n.t('Capability not implemented'),
+        });
+    });
+
+    test('environment capability advertisements disable legacy inference even when methods are present', async () => {
+        const manager: EnvironmentManager = {
+            name: 'advertised',
+            preferredPackageManagerId: 'advertised:packages',
+            refresh: unexpectedOperation,
+            getEnvironments: unexpectedOperation,
+            get: unexpectedOperation,
+            set: unexpectedOperation,
+            resolve: unexpectedOperation,
+            capabilities: allSupportedEnvironmentCapabilities,
+        };
+
+        assert.deepStrictEqual(await getLegacyEnvironmentManagerCapability(manager, EnvironmentCapability.List), {
+            supported: false,
+            reason: l10n.t('Capability not implemented'),
+        });
+    });
+
     test('package capabilities require their callable methods without executing them', async () => {
         const manager: PackageManager = {
             name: 'legacy',