Don Jayamanne (DonJayamanne) · Feb 13, 2018 · Nov 3, 2017 · Nov 9, 2017 · Nov 9, 2017 · Nov 9, 2017
diff --git a/src/client/common/variables/systemVariables.ts b/src/client/common/variables/systemVariables.ts
@@ -3,44 +3,6 @@ import * as Types from './sysTypes';
 import { IStringDictionary, ISystemVariables } from './types';
 /* tslint:disable:rule1 no-any no-unnecessary-callback-wrapper jsdoc-format no-for-in prefer-const no-increment-decrement */
 
-export abstract class Parser {
-
-    protected static merge<T>(destination: T, source: T, overwrite: boolean): void {
-        Object.keys(source).forEach((key) => {
-            const destValue = (destination as any as { [key: string]: string })[key];
-            const sourceValue = (source as any as { [key: string]: string })[key];
-            if (Types.isUndefined(sourceValue)) {
-                return;
-            }
-            if (Types.isUndefined(destValue)) {
-                (destination as any as { [key: string]: string })[key] = sourceValue;
-            } else {
-                if (overwrite) {
-                    if (Types.isObject(destValue) && Types.isObject(sourceValue)) {
-                        this.merge(destValue, sourceValue, overwrite);
-                    } else {
-                        (destination as any as { [key: string]: string })[key] = sourceValue;
-                    }
-                }
-            }
-        });
-    }
-
-    // tslint:disable-next-line:no-empty
-    protected log(message: string): void { }
-
-    // tslint:disable-next-line:no-any
-    protected is(value: any, func: (value: any) => boolean, wrongTypeState?: any, wrongTypeMessage?: string, undefinedState?: any, undefinedMessage?: string): boolean {
-        if (Types.isUndefined(value)) {
-            return false;
-        }
-        if (!func(value)) {
-            return false;
-        }
-        return true;
-    }
-}
-
 export abstract class AbstractSystemVariables implements ISystemVariables {
 
     public resolve(value: string): string;

diff --git a/src/client/debugger/Common/Contracts.ts b/src/client/debugger/Common/Contracts.ts
@@ -44,8 +44,10 @@ export interface ExceptionHandling {
     unhandled: string[];
 }
 
+export type DebuggerType = 'python' | 'pythonExperimental';
+
 export interface LaunchRequestArguments extends DebugProtocol.LaunchRequestArguments {
-    type?: 'python' | 'pythonExperimental';
+    type?: DebuggerType;
     /** An absolute path to the program to debug. */
     module?: string;
     program: string;

diff --git a/src/client/debugger/configProviders/baseProvider.ts b/src/client/debugger/configProviders/baseProvider.ts
@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { injectable, unmanaged } from 'inversify';
+import * as path from 'path';
+import { CancellationToken, DebugConfiguration, DebugConfigurationProvider, ProviderResult, Uri, WorkspaceFolder } from 'vscode';
+import { IDocumentManager, IWorkspaceService } from '../../common/application/types';
+import { PythonLanguage } from '../../common/constants';
+import { IConfigurationService } from '../../common/types';
+import { IServiceContainer } from '../../ioc/types';
+import { DebuggerType, LaunchRequestArguments } from '../Common/Contracts';
+
+// tslint:disable:no-invalid-template-strings
+
+export type PythonDebugConfiguration = DebugConfiguration & LaunchRequestArguments;
+
+@injectable()
+export abstract class BaseConfigurationProvider implements DebugConfigurationProvider {
+    constructor(@unmanaged() public debugType: DebuggerType, private serviceContainer: IServiceContainer) { }
+    public resolveDebugConfiguration(folder: WorkspaceFolder | undefined, debugConfiguration: DebugConfiguration, token?: CancellationToken): ProviderResult<DebugConfiguration> {
+        const config = debugConfiguration as PythonDebugConfiguration;
+        const numberOfSettings = Object.keys(config);
+        const provideDefaultConfigSettings = (config.noDebug === true && numberOfSettings.length === 1) || numberOfSettings.length === 0;
+        const workspaceFolder = this.getWorkspaceFolder(folder, config);
+        if (!provideDefaultConfigSettings) {
+            this.resolveAndUpdatePythonPath(workspaceFolder, config);
+            return config;
+        }
+
+        const configService = this.serviceContainer.get<IConfigurationService>(IConfigurationService);
+        const pythonPath = configService.getSettings(workspaceFolder).pythonPath;
+        const defaultProgram = this.getProgram(config);
+        const envFile = workspaceFolder ? path.join(workspaceFolder.fsPath, '.env') : '';
+
+        config.name = 'Launch';
+        config.type = this.debugType;
+        config.request = 'launch';
+        config.pythonPath = pythonPath;
+        config.program = defaultProgram ? defaultProgram : '';
+        config.cwd = workspaceFolder ? workspaceFolder.fsPath : undefined;
+        config.envFile = envFile;
+        config.env = {};
+        config.debugOptions = [];
+
+        this.provideDefaults(config);
+        return config;
+    }
+    protected abstract provideDefaults(debugConfiguration: PythonDebugConfiguration): void;
+    private getWorkspaceFolder(folder: WorkspaceFolder | undefined, config: PythonDebugConfiguration): Uri | undefined {
+        if (folder) {
+            return folder.uri;
+        }
+        const program = this.getProgram(config);
+        const workspaceService = this.serviceContainer.get<IWorkspaceService>(IWorkspaceService);
+        if (!Array.isArray(workspaceService.workspaceFolders) || workspaceService.workspaceFolders.length === 0) {
+            return program ? Uri.file(path.dirname(program)) : undefined;
+        }
+        if (workspaceService.workspaceFolders.length === 1) {
+            return workspaceService.workspaceFolders[0].uri;
+        }
+        if (program) {
+            const workspaceFolder = workspaceService.getWorkspaceFolder(Uri.file(program));
+            if (workspaceFolder) {
+                return workspaceFolder.uri;
+            }
+        }
+    }
+    private getProgram(config: PythonDebugConfiguration): string | undefined {
+        const documentManager = this.serviceContainer.get<IDocumentManager>(IDocumentManager);
+        const editor = documentManager.activeTextEditor;
+        if (editor && editor.document.languageId === PythonLanguage.language) {
+            return editor.document.fileName;
+        }
+    }
+    private resolveAndUpdatePythonPath(workspaceFolder: Uri | undefined, debugConfiguration: PythonDebugConfiguration): void {
+        if (!debugConfiguration || debugConfiguration.pythonPath !== '${config:python.pythonPath}') {
+            return;
+        }
+        const configService = this.serviceContainer.get<IConfigurationService>(IConfigurationService);
+        const pythonPath = configService.getSettings(workspaceFolder).pythonPath;
+        debugConfiguration.pythonPath = pythonPath;
+    }
+}
diff --git a/src/client/debugger/configProviders/pyhtonV2Provider.ts b/src/client/debugger/configProviders/pyhtonV2Provider.ts
@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { inject, injectable } from 'inversify';
+import { IServiceContainer } from '../../ioc/types';
+import { BaseConfigurationProvider, PythonDebugConfiguration } from './baseProvider';
+
+@injectable()
+export class PythonV2DebugConfigurationProvider extends BaseConfigurationProvider {
+    constructor(@inject(IServiceContainer) serviceContainer: IServiceContainer) {
+        super('pythonExperimental', serviceContainer);
+    }
+    protected provideDefaults(debugConfiguration: PythonDebugConfiguration): void {
+        debugConfiguration.stopOnEntry = false;
+        debugConfiguration.console = 'integratedTerminal';
+    }
+}
diff --git a/src/client/debugger/configProviders/pythonProvider.ts b/src/client/debugger/configProviders/pythonProvider.ts
@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { inject, injectable } from 'inversify';
+import { IServiceContainer } from '../../ioc/types';
+import { BaseConfigurationProvider, PythonDebugConfiguration } from './baseProvider';
+
+@injectable()
+export class PythonDebugConfigurationProvider extends BaseConfigurationProvider {
+    constructor(@inject(IServiceContainer) serviceContainer: IServiceContainer) {
+        super('python', serviceContainer);
+    }
+    protected provideDefaults(debugConfiguration: PythonDebugConfiguration): void {
+        debugConfiguration.stopOnEntry = true;
+        debugConfiguration.debugOptions = [
+            'RedirectOutput'
+        ];
+    }
+}
diff --git a/src/client/debugger/configProviders/serviceRegistry.ts b/src/client/debugger/configProviders/serviceRegistry.ts
@@ -0,0 +1,15 @@
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { DebugConfigurationProvider } from 'vscode';
+import { PythonDebugConfigurationProvider, PythonV2DebugConfigurationProvider } from '..';
+import { IServiceManager } from '../../ioc/types';
+import { IDebugConfigurationProvider } from '../types';
+
+export function registerTypes(serviceManager: IServiceManager) {
+    serviceManager.addSingleton<DebugConfigurationProvider>(IDebugConfigurationProvider, PythonDebugConfigurationProvider);
+    serviceManager.addSingleton<DebugConfigurationProvider>(IDebugConfigurationProvider, PythonV2DebugConfigurationProvider);
+}
diff --git a/src/client/debugger/configProviders/simpleProvider.ts b/src/client/debugger/configProviders/simpleProvider.ts
diff --git a/src/client/debugger/index.ts b/src/client/debugger/index.ts
@@ -1 +1,2 @@
-export * from './configProviders/simpleProvider';
+export * from './configProviders/pythonProvider';
+export * from './configProviders/pyhtonV2Provider';
diff --git a/src/client/debugger/types.ts b/src/client/debugger/types.ts
@@ -36,3 +36,5 @@ export const IProtocolMessageWriter = Symbol('IProtocolMessageWriter');
 export interface IProtocolMessageWriter {
     write(stream: Socket | NodeJS.WriteStream, message: Message): void;
 }
+
+export const IDebugConfigurationProvider = Symbol('DebugConfigurationProvider');
diff --git a/src/client/extension.ts b/src/client/extension.ts
@@ -6,7 +6,6 @@ if ((Reflect as any).metadata === undefined) {
     require('reflect-metadata');
 }
 import { Container } from 'inversify';
-import * as os from 'os';
 import * as vscode from 'vscode';
 import { Disposable, Memento, OutputChannel, window } from 'vscode';
 import { BannerService } from './banner';
@@ -23,7 +22,9 @@ import { IProcessService } from './common/process/types';
 import { registerTypes as commonRegisterTypes } from './common/serviceRegistry';
 import { GLOBAL_MEMENTO, IDisposableRegistry, ILogger, IMemento, IOutputChannel, IPersistentStateFactory, WORKSPACE_MEMENTO } from './common/types';
 import { registerTypes as variableRegisterTypes } from './common/variables/serviceRegistry';
-import { SimpleConfigurationProvider } from './debugger';
+import { BaseConfigurationProvider } from './debugger/configProviders/baseProvider';
+import { registerTypes as debugConfigurationRegisterTypes } from './debugger/configProviders/serviceRegistry';
+import { IDebugConfigurationProvider } from './debugger/types';
 import { registerTypes as formattersRegisterTypes } from './formatters/serviceRegistry';
 import { InterpreterSelector } from './interpreter/configuration/interpreterSelector';
 import { ICondaService, IInterpreterService, IInterpreterVersionService } from './interpreter/contracts';
@@ -92,6 +93,7 @@ export async function activate(context: vscode.ExtensionContext) {
     platformRegisterTypes(serviceManager);
     installerRegisterTypes(serviceManager);
     commonRegisterTerminalTypes(serviceManager);
+    debugConfigurationRegisterTypes(serviceManager);
 
     serviceManager.get<ICodeExecutionManager>(ICodeExecutionManager).registerCommands();
 
@@ -193,11 +195,9 @@ export async function activate(context: vscode.ExtensionContext) {
     context.subscriptions.push(vscode.languages.registerOnTypeFormattingEditProvider(PYTHON, new BlockFormatProviders(), ':'));
     context.subscriptions.push(vscode.languages.registerOnTypeFormattingEditProvider(PYTHON, new OnEnterFormatter(), '\n'));
 
-    // In case we have CR LF
-    const triggerCharacters: string[] = os.EOL.split('');
-    triggerCharacters.shift();
-
-    context.subscriptions.push(vscode.debug.registerDebugConfigurationProvider('python', new SimpleConfigurationProvider()));
+    serviceContainer.getAll<BaseConfigurationProvider>(IDebugConfigurationProvider).forEach(debugConfig => {
+        context.subscriptions.push(vscode.debug.registerDebugConfigurationProvider(debugConfig.debugType, debugConfig));
+    });
     activationDeferred.resolve();
 
     // tslint:disable-next-line:no-unused-expression