Fix #12462, #14674 for debugging

news/1 Enhancements/12462.md

@@ -0,0 +1 @@
+Replaced "pythonPath" debug configuration property with "python".

package.json

@@ -1571,9 +1571,9 @@
                                 "description": "Absolute path to the program.",
                                 "default": "${file}"
                             },
-                            "pythonPath": {
+                            "python": {
                                 "type": "string",
-                                "description": "Path (fully qualified) to python executable. Defaults to the value in settings",
+                                "description": "Absolute path to the Python interpreter executable; overrides workspace configuration if set.",
                                 "default": "${command:python.interpreterPath}"
                             },
                             "pythonArgs": {
@@ -3685,4 +3685,4 @@
         "publisherDisplayName": "Microsoft",
         "publisherId": "998b010b-e2af-44a5-a6cd-0b5fd3b9b6f8"
     }
-}
+}

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

@@ -71,6 +71,7 @@ export class InvalidLaunchJsonDebuggerService extends BaseDiagnosticsService {
             true
         );
     }
+
     public async diagnose(resource: Resource): Promise<IDiagnostic[]> {
         if (!this.workspaceService.hasWorkspaceFolders) {
             return [];
@@ -80,9 +81,11 @@ export class InvalidLaunchJsonDebuggerService extends BaseDiagnosticsService {
             : this.workspaceService.workspaceFolders![0];
         return this.diagnoseWorkspace(workspaceFolder, resource);
     }
+
     protected async onHandle(diagnostics: IDiagnostic[]): Promise<void> {
         diagnostics.forEach((diagnostic) => this.handleDiagnostic(diagnostic));
     }
+
     protected async fixLaunchJson(code: DiagnosticCodes) {
         if (!this.workspaceService.hasWorkspaceFolders) {
             return;
@@ -94,6 +97,7 @@ export class InvalidLaunchJsonDebuggerService extends BaseDiagnosticsService {
             )
         );
     }
+
     private async diagnoseWorkspace(workspaceFolder: WorkspaceFolder, resource: Resource) {
         const launchJson = this.getLaunchJsonFile(workspaceFolder);
         if (!(await this.fs.fileExists(launchJson))) {
@@ -114,6 +118,7 @@ export class InvalidLaunchJsonDebuggerService extends BaseDiagnosticsService {
             diagnostics.push(new InvalidLaunchJsonDebuggerDiagnostic(DiagnosticCodes.ConsoleTypeDiagnostic, resource));
         }
         if (
+            fileContents.indexOf('"pythonPath":') > 0 ||
             fileContents.indexOf('{config:python.pythonPath}') > 0 ||
             fileContents.indexOf('{config:python.interpreterPath}') > 0
         ) {
@@ -123,6 +128,7 @@ export class InvalidLaunchJsonDebuggerService extends BaseDiagnosticsService {
         }
         return diagnostics;
     }
+
     private async handleDiagnostic(diagnostic: IDiagnostic): Promise<void> {
         if (!this.canHandle(diagnostic)) {
             return;
@@ -147,6 +153,7 @@ export class InvalidLaunchJsonDebuggerService extends BaseDiagnosticsService {
 
         await this.messageService.handle(diagnostic, { commandPrompts });
     }
+
     private async fixLaunchJsonInWorkspace(code: DiagnosticCodes, workspaceFolder: WorkspaceFolder) {
         if ((await this.diagnoseWorkspace(workspaceFolder, undefined)).length === 0) {
             return;
@@ -169,6 +176,7 @@ export class InvalidLaunchJsonDebuggerService extends BaseDiagnosticsService {
                 break;
             }
             case DiagnosticCodes.ConfigPythonPathDiagnostic: {
+                fileContents = this.findAndReplace(fileContents, '"pythonPath":', '"python":');
                 fileContents = this.findAndReplace(
                     fileContents,
                     '{config:python.pythonPath}',
@@ -188,10 +196,12 @@ export class InvalidLaunchJsonDebuggerService extends BaseDiagnosticsService {
 
         await this.fs.writeFile(launchJson, fileContents);
     }
+
     private findAndReplace(fileContents: string, search: string, replace: string) {
         const searchRegex = new RegExp(search, 'g');
         return fileContents.replace(searchRegex, replace);
     }
+
     private getLaunchJsonFile(workspaceFolder: WorkspaceFolder) {
         return path.join(workspaceFolder.uri.fsPath, '.vscode', 'launch.json');
     }

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

@@ -27,6 +27,7 @@ export class DebugAdapterDescriptorFactory implements IDebugAdapterDescriptorFac
         @inject(IInterpreterService) private readonly interpreterService: IInterpreterService,
         @inject(IApplicationShell) private readonly appShell: IApplicationShell
     ) {}
+
     public async createDebugAdapterDescriptor(
         session: DebugSession,
         _executable: DebugAdapterExecutable | undefined
@@ -54,7 +55,7 @@ export class DebugAdapterDescriptorFactory implements IDebugAdapterDescriptorFac
             }
         }
 
-        const pythonPath = await this.getPythonPath(configuration, session.workspaceFolder);
+        const pythonPath = await this.getDebugAdapterPython(configuration, session.workspaceFolder);
         if (pythonPath.length !== 0) {
             if (configuration.request === 'attach' && configuration.processId !== undefined) {
                 sendTelemetryEvent(EventName.DEBUGGER_ATTACH_TO_LOCAL_PROCESS);
@@ -96,13 +97,16 @@ export class DebugAdapterDescriptorFactory implements IDebugAdapterDescriptorFac
      * @returns {Promise<string>} Path to the python interpreter for this workspace.
      * @memberof DebugAdapterDescriptorFactory
      */
-    private async getPythonPath(
+    private async getDebugAdapterPython(
         configuration: LaunchRequestArguments | AttachRequestArguments,
         workspaceFolder?: WorkspaceFolder
     ): Promise<string> {
-        if (configuration.pythonPath) {
+        if (configuration.debugAdapterPython !== undefined) {
+            return configuration.debugAdapterPython;
+        } else if (configuration.pythonPath) {
             return configuration.pythonPath;
         }
+
         const resourceUri = workspaceFolder ? workspaceFolder.uri : undefined;
         const interpreter = await this.interpreterService.getActiveInterpreter(resourceUri);
         if (interpreter) {

src/client/debugger/extension/configuration/debugConfigurationService.ts

@@ -29,6 +29,7 @@ export class PythonDebugConfigurationService implements IDebugConfigurationServi
         private readonly providerFactory: IDebugConfigurationProviderFactory,
         @inject(IMultiStepInputFactory) private readonly multiStepFactory: IMultiStepInputFactory
     ) {}
+
     public async provideDebugConfigurations(
         folder: WorkspaceFolder | undefined,
         token?: CancellationToken
@@ -46,6 +47,7 @@ export class PythonDebugConfigurationService implements IDebugConfigurationServi
             return [state.config as DebugConfiguration];
         }
     }
+
     public async resolveDebugConfiguration(
         folder: WorkspaceFolder | undefined,
         debugConfiguration: DebugConfiguration,
@@ -76,6 +78,18 @@ export class PythonDebugConfigurationService implements IDebugConfigurationServi
             );
         }
     }
+
+    public async resolveDebugConfigurationWithSubstitutedVariables(
+        folder: WorkspaceFolder | undefined,
+        debugConfiguration: DebugConfiguration,
+        token?: CancellationToken
+    ): Promise<DebugConfiguration | undefined> {
+        function resolve<T extends DebugConfiguration>(resolver: IDebugConfigurationResolver<T>) {
+            return resolver.resolveDebugConfigurationWithSubstitutedVariables(folder, debugConfiguration as T, token);
+        }
+        return debugConfiguration.request === 'attach' ? resolve(this.attachResolver) : resolve(this.launchResolver);
+    }
+
     protected async pickDebugConfiguration(
         input: IMultiStepInput<DebugConfigurationState>,
         state: DebugConfigurationState

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

@@ -21,7 +21,8 @@ export class AttachConfigurationResolver extends BaseConfigurationResolver<Attac
     ) {
         super(workspaceService, documentManager, platformService, configurationService);
     }
-    public async resolveDebugConfiguration(
+
+    public async resolveDebugConfigurationWithSubstitutedVariables(
         folder: WorkspaceFolder | undefined,
         debugConfiguration: AttachRequestArguments,
         _token?: CancellationToken
@@ -38,6 +39,7 @@ export class AttachConfigurationResolver extends BaseConfigurationResolver<Attac
         }
         return debugConfiguration;
     }
+
     // tslint:disable-next-line:cyclomatic-complexity
     protected async provideAttachDefaults(
         workspaceFolder: Uri | undefined,

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

@@ -24,17 +24,36 @@ import { IDebugConfigurationResolver } from '../types';
 export abstract class BaseConfigurationResolver<T extends DebugConfiguration>
     implements IDebugConfigurationResolver<T> {
     protected pythonPathSource: PythonPathSource = PythonPathSource.launchJson;
+
     constructor(
         protected readonly workspaceService: IWorkspaceService,
         protected readonly documentManager: IDocumentManager,
         protected readonly platformService: IPlatformService,
         protected readonly configurationService: IConfigurationService
     ) {}
-    public abstract resolveDebugConfiguration(
+
+    // This is a legacy hook used solely for backwards-compatible manual substitution
+    // of ${command:python.interpreterPath} in "pythonPath", for the sake of other
+    // existing implementations of resolveDebugConfiguration() that may rely on it.
+    //
+    // For all future config variables, expansion should be performed by VSCode itself,
+    // and validation of debug configuration in derived classes should be performed in
+    // resolveDebugConfigurationWithSubstitutedVariables() instead, where all variables
+    // are already substituted.
+    public async resolveDebugConfiguration(
+        _folder: WorkspaceFolder | undefined,
+        debugConfiguration: DebugConfiguration,
+        _token?: CancellationToken
+    ): Promise<T | undefined> {
+        return debugConfiguration as T;
+    }
+
+    public abstract resolveDebugConfigurationWithSubstitutedVariables(
         folder: WorkspaceFolder | undefined,
         debugConfiguration: DebugConfiguration,
         token?: CancellationToken
     ): Promise<T | undefined>;
+
     protected getWorkspaceFolder(folder: WorkspaceFolder | undefined): Uri | undefined {
         if (folder) {
             return folder.uri;
@@ -56,19 +75,22 @@ export abstract class BaseConfigurationResolver<T extends DebugConfiguration>
             }
         }
     }
+
     protected getProgram(): string | undefined {
         const editor = this.documentManager.activeTextEditor;
         if (editor && editor.document.languageId === PYTHON_LANGUAGE) {
             return editor.document.fileName;
         }
     }
+
     protected resolveAndUpdatePaths(
         workspaceFolder: Uri | undefined,
         debugConfiguration: LaunchRequestArguments
     ): void {
         this.resolveAndUpdateEnvFilePath(workspaceFolder, debugConfiguration);
         this.resolveAndUpdatePythonPath(workspaceFolder, debugConfiguration);
     }
+
     protected resolveAndUpdateEnvFilePath(
         workspaceFolder: Uri | undefined,
         debugConfiguration: LaunchRequestArguments
@@ -84,6 +106,7 @@ export abstract class BaseConfigurationResolver<T extends DebugConfiguration>
             debugConfiguration.envFile = systemVariables.resolveAny(debugConfiguration.envFile);
         }
     }
+
     protected resolveAndUpdatePythonPath(
         workspaceFolder: Uri | undefined,
         debugConfiguration: LaunchRequestArguments
@@ -99,16 +122,19 @@ export abstract class BaseConfigurationResolver<T extends DebugConfiguration>
             this.pythonPathSource = PythonPathSource.launchJson;
         }
     }
+
     protected debugOption(debugOptions: DebugOptions[], debugOption: DebugOptions) {
         if (debugOptions.indexOf(debugOption) >= 0) {
             return;
         }
         debugOptions.push(debugOption);
     }
+
     protected isLocalHost(hostName?: string) {
         const LocalHosts = ['localhost', '127.0.0.1', '::1'];
         return hostName && LocalHosts.indexOf(hostName.toLowerCase()) >= 0 ? true : false;
     }
+
     protected fixUpPathMappings(
         pathMappings: PathMapping[],
         defaultLocalRoot?: string,
@@ -153,9 +179,11 @@ export abstract class BaseConfigurationResolver<T extends DebugConfiguration>
 
         return pathMappings;
     }
+
     protected isDebuggingFlask(debugConfiguration: Partial<LaunchRequestArguments & AttachRequestArguments>) {
         return debugConfiguration.module && debugConfiguration.module.toUpperCase() === 'FLASK' ? true : false;
     }
+
     protected sendTelemetry(
         trigger: 'launch' | 'attach' | 'test',
         debugConfiguration: Partial<LaunchRequestArguments & AttachRequestArguments>

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

@@ -29,47 +29,69 @@ export class LaunchConfigurationResolver extends BaseConfigurationResolver<Launc
     ) {
         super(workspaceService, documentManager, platformService, configurationService);
     }
+
     public async resolveDebugConfiguration(
         folder: WorkspaceFolder | undefined,
         debugConfiguration: LaunchRequestArguments,
         _token?: CancellationToken
     ): Promise<LaunchRequestArguments | undefined> {
-        const workspaceFolder = this.getWorkspaceFolder(folder);
-
-        const config = debugConfiguration as LaunchRequestArguments;
-        const numberOfSettings = Object.keys(config);
-
-        if ((config.noDebug === true && numberOfSettings.length === 1) || numberOfSettings.length === 0) {
+        if (
+            debugConfiguration.name === undefined &&
+            debugConfiguration.type === undefined &&
+            debugConfiguration.request === undefined &&
+            debugConfiguration.program === undefined &&
+            debugConfiguration.env === undefined
+        ) {
             const defaultProgram = this.getProgram();
-
-            config.name = 'Launch';
-            config.type = DebuggerTypeName;
-            config.request = 'launch';
-            config.program = defaultProgram ? defaultProgram : '';
-            config.env = {};
+            debugConfiguration.name = 'Launch';
+            debugConfiguration.type = DebuggerTypeName;
+            debugConfiguration.request = 'launch';
+            debugConfiguration.program = defaultProgram ?? '';
+            debugConfiguration.env = {};
         }
 
-        await this.provideLaunchDefaults(workspaceFolder, config);
+        const workspaceFolder = this.getWorkspaceFolder(folder);
+        this.resolveAndUpdatePaths(workspaceFolder, debugConfiguration);
+        return debugConfiguration;
+    }
 
-        const isValid = await this.validateLaunchConfiguration(folder, config);
+    public async resolveDebugConfigurationWithSubstitutedVariables(
+        folder: WorkspaceFolder | undefined,
+        debugConfiguration: LaunchRequestArguments,
+        _token?: CancellationToken
+    ): Promise<LaunchRequestArguments | undefined> {
+        const workspaceFolder = this.getWorkspaceFolder(folder);
+        await this.provideLaunchDefaults(workspaceFolder, debugConfiguration);
+
+        const isValid = await this.validateLaunchConfiguration(folder, debugConfiguration);
         if (!isValid) {
             return;
         }
 
-        const dbgConfig = debugConfiguration;
-        if (Array.isArray(dbgConfig.debugOptions)) {
-            dbgConfig.debugOptions = dbgConfig.debugOptions!.filter(
-                (item, pos) => dbgConfig.debugOptions!.indexOf(item) === pos
+        if (Array.isArray(debugConfiguration.debugOptions)) {
+            debugConfiguration.debugOptions = debugConfiguration.debugOptions!.filter(
+                (item, pos) => debugConfiguration.debugOptions!.indexOf(item) === pos
             );
         }
         return debugConfiguration;
     }
+
     // tslint:disable-next-line:cyclomatic-complexity
     protected async provideLaunchDefaults(
         workspaceFolder: Uri | undefined,
         debugConfiguration: LaunchRequestArguments
     ): Promise<void> {
-        this.resolveAndUpdatePaths(workspaceFolder, debugConfiguration);
+        if (debugConfiguration.python === undefined) {
+            debugConfiguration.python = debugConfiguration.pythonPath;
+        }
+        if (debugConfiguration.debugAdapterPython === undefined) {
+            debugConfiguration.debugAdapterPython = debugConfiguration.pythonPath;
+        }
+        if (debugConfiguration.debugLauncherPython === undefined) {
+            debugConfiguration.debugLauncherPython = debugConfiguration.pythonPath;
+        }
+        delete debugConfiguration.pythonPath;
+
         if (typeof debugConfiguration.cwd !== 'string' && workspaceFolder) {
             debugConfiguration.cwd = workspaceFolder.fsPath;
         }
@@ -160,10 +182,18 @@ export class LaunchConfigurationResolver extends BaseConfigurationResolver<Launc
         debugConfiguration: LaunchRequestArguments
     ): Promise<boolean> {
         const diagnosticService = this.invalidPythonPathInDebuggerService;
-        return diagnosticService.validatePythonPath(
-            debugConfiguration.pythonPath,
-            this.pythonPathSource,
-            folder ? folder.uri : undefined
+        return (
+            diagnosticService.validatePythonPath(debugConfiguration.python, this.pythonPathSource, folder?.uri) &&
+            diagnosticService.validatePythonPath(
+                debugConfiguration.debugAdapterPython,
+                this.pythonPathSource,
+                folder?.uri
+            ) &&
+            diagnosticService.validatePythonPath(
+                debugConfiguration.debugLauncherPython,
+                this.pythonPathSource,
+                folder?.uri
+            )
         );
     }
 }