fixes

Author: eleanorjboyd

src/features/interpreterSelection.ts

@@ -354,7 +354,7 @@ export async function applyInitialEnvironmentSelection(
     // Errors inside resolveGlobalScope are handled internally:
     //   - Setting resolution errors (bad paths, unknown managers) → notifyUserOfSettingErrors
     //   - Unexpected crashes → logged via traceError, never silently swallowed
-    const resolveGlobalScope = async () => {
+    const resolveGlobalScope = async (): Promise<SettingResolutionError[]> => {
         try {
             const globalStopWatch = new StopWatch();
             const { result, errors: globalErrors } = await resolvePriorityChainCore(
@@ -380,11 +380,10 @@ export async function applyInitialEnvironmentSelection(
 
             traceInfo(`[interpreterSelection] global: ${env?.displayName ?? 'none'} (source: ${result.source})`);
 
-            if (globalErrors.length > 0) {
-                await notifyUserOfSettingErrors(globalErrors);
-            }
+            return globalErrors;
         } catch (err) {
             traceError(`[interpreterSelection] Failed to set global environment: ${err}`);
+            return [];
         }
     };
 
@@ -395,21 +394,26 @@ export async function applyInitialEnvironmentSelection(
         // multi-root workspace is not affected by deferring the global scope.
         // Defer global scope to a background task so we don't block post-selection
         // startup work in extension.ts (clearHangWatchdog, terminal init, telemetry).
-        // The outer .catch is a safety net — resolveGlobalScope has its own try/catch,
-        // so this only fires if the inner handler itself throws unexpectedly.
+        // Global errors are notified separately since we can't aggregate with workspace errors.
         traceInfo('[interpreterSelection] Workspace env resolved, deferring global scope to background');
-        resolveGlobalScope().catch((err) =>
-            traceError(`[interpreterSelection] Background global scope resolution failed: ${err}`),
-        );
+        resolveGlobalScope()
+            .then(async (globalErrors) => {
+                if (globalErrors.length > 0) {
+                    await notifyUserOfSettingErrors(globalErrors);
+                }
+            })
+            .catch((err) => traceError(`[interpreterSelection] Background global scope resolution failed: ${err}`));
     } else {
         // Either: (a) no workspace folders are open, (b) every folder resolved with
         // env=undefined (no Python found), or (c) every folder threw an error.
         // In all cases the global environment is the user's primary fallback,
-        // so we must await it before returning.
-        await resolveGlobalScope();
+        // so we must await it before returning. Errors are aggregated with workspace
+        // errors so notifyUserOfSettingErrors can dedupe across both scopes.
+        const globalErrors = await resolveGlobalScope();
+        allErrors.push(...globalErrors);
     }
 
-    // Notify user if any workspace-scoped settings could not be applied
+    // Notify user if any settings could not be applied (workspace + global when awaited)
     if (allErrors.length > 0) {
         await notifyUserOfSettingErrors(allErrors);
     }

src/test/features/interpreterSelection.unit.test.ts

@@ -868,6 +868,16 @@ suite('Interpreter Selection - applyInitialEnvironmentSelection', () => {
 
         const showWarnStub = sandbox.stub(windowApis, 'showWarningMessage').resolves(undefined);
 
+        // Use a deferred promise to deterministically wait for the background global scope
+        let resolveGlobalDone!: () => void;
+        const globalDone = new Promise<void>((resolve) => {
+            resolveGlobalDone = resolve;
+        });
+        const origSetEnvironments = mockEnvManagers.setEnvironments;
+        origSetEnvironments.callsFake(async (...args: unknown[]) => {
+            resolveGlobalDone();
+        });
+
         await applyInitialEnvironmentSelection(
             mockEnvManagers as unknown as EnvironmentManagers,
             mockProjectManager as unknown as PythonProjectManager,
@@ -878,8 +888,10 @@ suite('Interpreter Selection - applyInitialEnvironmentSelection', () => {
         // Workspace folder should resolve (venv found)
         assert.ok(mockEnvManagers.setEnvironment.called, 'setEnvironment should be called for workspace folder');
 
-        // Wait a tick for the background global scope to complete
-        await new Promise((resolve) => setTimeout(resolve, 50));
+        // Wait for the background global scope to call setEnvironments
+        await globalDone;
+        // Flush microtasks so the .then() handler for notifyUserOfSettingErrors runs
+        await new Promise<void>((resolve) => process.nextTick(resolve));
 
         // Global scope should still resolve (falls to auto-discovery) and show warning
         assert.ok(mockEnvManagers.setEnvironments.called, 'setEnvironments should be called for global scope');
@@ -896,8 +908,17 @@ suite('Interpreter Selection - applyInitialEnvironmentSelection', () => {
         sandbox.stub(workspaceApis, 'getConfiguration').returns(createMockConfig([]) as WorkspaceConfiguration);
         sandbox.stub(helpers, 'getUserConfiguredSetting').returns(undefined);
 
+        // Use a deferred promise to deterministically wait for the background global scope
+        let resolveGlobalDone!: () => void;
+        const globalDone = new Promise<void>((resolve) => {
+            resolveGlobalDone = resolve;
+        });
+
         // Make setEnvironments throw — simulating a crash in global scope
-        mockEnvManagers.setEnvironments.rejects(new Error('Simulated global scope crash'));
+        mockEnvManagers.setEnvironments.callsFake(async () => {
+            resolveGlobalDone();
+            throw new Error('Simulated global scope crash');
+        });
 
         // Should NOT throw — errors are caught inside resolveGlobalScope
         await applyInitialEnvironmentSelection(
@@ -907,8 +928,10 @@ suite('Interpreter Selection - applyInitialEnvironmentSelection', () => {
             mockApi as unknown as PythonEnvironmentApi,
         );
 
-        // Wait a tick for the background global scope to complete
-        await new Promise((resolve) => setTimeout(resolve, 50));
+        // Wait for the background global scope to call setEnvironments
+        await globalDone;
+        // Flush microtasks so the catch handler runs
+        await new Promise<void>((resolve) => process.nextTick(resolve));
 
         // Workspace folder should still have resolved
         assert.ok(mockEnvManagers.setEnvironment.called, 'setEnvironment should be called for workspace folder');