Gate debug per-file interpreter resolution behind useEnvExtension()

The debug resolver now resolves \/\ to a program
URI and looks up the interpreter for that file. To avoid changing behavior
for users who are not using the environments extension (e.g. multi-root
debugging of a file that lives in a different folder than the launch
config), only take the program-scoped path when useEnvExtension() is true;
otherwise fall back to the historical workspace-folder resolution.
Environments-extension users still get per-file (inline-script) resolution.

Stub useEnvExtension() in the existing program-scoped resolver tests and
add a test covering the gated fallback.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: StellaHuang95

src/client/debugger/extension/configuration/resolvers/base.ts

@@ -13,6 +13,7 @@ import {
     getWorkspaceFolder as getVSCodeWorkspaceFolder,
     getWorkspaceFolders,
 } from '../../../../common/vscodeApis/workspaceApis';
+import { useEnvExtension } from '../../../../envExt/api.internal';
 import { IInterpreterService } from '../../../../interpreter/contracts';
 import { AttachRequestArguments, DebugOptions, LaunchRequestArguments, PathMapping } from '../../../types';
 import { PythonPathSource } from '../../types';
@@ -171,6 +172,14 @@ export abstract class BaseConfigurationResolver<T extends DebugConfiguration>
         workspaceFolder: Uri | undefined,
         debugConfiguration: LaunchRequestArguments,
     ) {
+        // Program-scoped (per-file) interpreter resolution only applies when the environments
+        // extension owns interpreter resolution. Without it, preserve the historical behavior of
+        // resolving the interpreter from the launch workspace folder, so users who are not using
+        // the environments extension (e.g. multi-root debugging of another folder's file) see no
+        // change.
+        if (!useEnvExtension()) {
+            return this.interpreterService.getActiveInterpreter(workspaceFolder);
+        }
         let configuredProgram = debugConfiguration.program === '${file}' ? getProgram() : debugConfiguration.program;
         let programWorkspaceFolder = workspaceFolder;
         if (configuredProgram) {

src/test/debugger/extension/configuration/resolvers/base.unit.test.ts

@@ -18,6 +18,7 @@ import { IInterpreterService } from '../../../../../client/interpreter/contracts
 import { PythonEnvironment } from '../../../../../client/pythonEnvironments/info';
 import * as workspaceApis from '../../../../../client/common/vscodeApis/workspaceApis';
 import * as helper from '../../../../../client/debugger/extension/configuration/resolvers/helper';
+import * as extapi from '../../../../../client/envExt/api.internal';
 
 suite('Debugging - Config Resolver', () => {
     class BaseResolver extends BaseConfigurationResolver<AttachRequestArguments | LaunchRequestArguments> {
@@ -70,6 +71,7 @@ suite('Debugging - Config Resolver', () => {
     let getWorkspaceFoldersStub: sinon.SinonStub;
     let getWorkspaceFolderStub: sinon.SinonStub;
     let getProgramStub: sinon.SinonStub;
+    let useEnvExtensionStub: sinon.SinonStub;
 
     setup(() => {
         configurationService = mock(ConfigurationService);
@@ -78,6 +80,7 @@ suite('Debugging - Config Resolver', () => {
         getWorkspaceFoldersStub = sinon.stub(workspaceApis, 'getWorkspaceFolders');
         getWorkspaceFolderStub = sinon.stub(workspaceApis, 'getWorkspaceFolder');
         getProgramStub = sinon.stub(helper, 'getProgram');
+        useEnvExtensionStub = sinon.stub(extapi, 'useEnvExtension').returns(false);
     });
     teardown(() => {
         sinon.restore();
@@ -290,6 +293,7 @@ suite('Debugging - Config Resolver', () => {
     });
 
     test('uses one exact program lookup for command-valued pythonPath and python', async () => {
+        useEnvExtensionStub.returns(true);
         const workspaceUri = Uri.file(path.resolve('workspace'));
         const programPath = path.join(workspaceUri.fsPath, 'script.py');
         const workspacePython = path.resolve('workspace-env', 'python');
@@ -318,6 +322,7 @@ suite('Debugging - Config Resolver', () => {
     });
 
     test('falls back to the workspace interpreter when exact program lookup has no environment', async () => {
+        useEnvExtensionStub.returns(true);
         const workspaceUri = Uri.file(path.resolve('workspace'));
         const programPath = path.join(workspaceUri.fsPath, 'script.py');
         const workspacePython = path.resolve('workspace-env', 'python');
@@ -336,6 +341,7 @@ suite('Debugging - Config Resolver', () => {
     });
 
     test('resolves a named workspace-folder program before exact interpreter lookup', async () => {
+        useEnvExtensionStub.returns(true);
         const launchWorkspaceUri = Uri.file(path.resolve('workspace-a'));
         const programWorkspaceUri = Uri.file(path.resolve('workspace-b'));
         const programPath = path.join(programWorkspaceUri.fsPath, 'script.py');
@@ -360,6 +366,7 @@ suite('Debugging - Config Resolver', () => {
     });
 
     test('does not mark a program interpreter that matches the workspace interpreter', async () => {
+        useEnvExtensionStub.returns(true);
         const workspaceUri = Uri.file(path.resolve('workspace'));
         const programPath = path.join(workspaceUri.fsPath, 'script.py');
         const pythonPath = path.resolve('env', 'python');
@@ -374,6 +381,28 @@ suite('Debugging - Config Resolver', () => {
         expect(config).to.not.have.property('__pythonIsProgramInterpreter');
     });
 
+    test('does not use the program interpreter when the environments extension is not in use', async () => {
+        useEnvExtensionStub.returns(false);
+        const workspaceUri = Uri.file(path.resolve('workspace-a'));
+        const programWorkspaceUri = Uri.file(path.resolve('workspace-b'));
+        const programPath = path.join(programWorkspaceUri.fsPath, 'script.py');
+        const workspacePython = path.resolve('workspace-env', 'python');
+        const config = { program: programPath };
+        when(interpreterService.getActiveInterpreter(anything(), anything())).thenResolve({
+            path: path.resolve('program-env', 'python'),
+        } as PythonEnvironment);
+        when(interpreterService.getActiveInterpreter(anything())).thenResolve({
+            path: workspacePython,
+        } as PythonEnvironment);
+
+        await resolver.resolveAndUpdatePythonPath(workspaceUri, config as LaunchRequestArguments);
+
+        expect(config).to.have.property('python', workspacePython);
+        expect(config).to.not.have.property('__pythonIsProgramInterpreter');
+        verify(interpreterService.getActiveInterpreter(anything(), anything())).never();
+        verify(interpreterService.getActiveInterpreter(anything())).once();
+    });
+
     const localHostTestMatrix: Record<string, boolean> = {
         localhost: true,
         '127.0.0.1': true,