do not break existing debug extensions

src/vs/workbench/api/electron-browser/mainThreadDebugService.ts

@@ -50,12 +50,12 @@ export class MainThreadDebugService implements MainThreadDebugServiceShape {
 			type: debugType
 		};
 		if (hasProvide) {
-			provider.provideDebugConfigurations = (folder: URI | undefined) => {
+			provider.provideDebugConfigurations = folder => {
 				return this._proxy.$provideDebugConfigurations(handle, folder);
 			};
 		}
 		if (hasResolve) {
-			provider.resolveDebugConfiguration = (folder: URI | undefined, debugConfiguration: any) => {
+			provider.resolveDebugConfiguration = (folder, debugConfiguration) => {
 				return this._proxy.$resolveDebugConfiguration(handle, folder, debugConfiguration);
 			};
 		}

src/vs/workbench/parts/debug/common/debug.ts

@@ -375,8 +375,8 @@ export interface IRawAdapter extends IRawEnvAdapter {
 
 export interface IDebugConfigurationProvider {
 	type: string;
-	resolveDebugConfiguration?(folderUri: uri | undefined, debugConfiguration: any): TPromise<any>;
-	provideDebugConfigurations?(folderUri: uri | undefined): TPromise<any[]>;
+	resolveDebugConfiguration?(folderUri: uri | undefined, debugConfiguration: IConfig): TPromise<IConfig>;
+	provideDebugConfigurations?(folderUri: uri | undefined): TPromise<IConfig[]>;
 }
 
 export interface IConfigurationManager {
@@ -410,7 +410,7 @@ export interface IConfigurationManager {
 
 	registerDebugConfigurationProvider(handle: number, debugConfigurationProvider: IDebugConfigurationProvider): void;
 	unregisterDebugConfigurationProvider(handle: number): void;
-	resolveDebugConfiguration(folderUri: uri | undefined, debugConfiguration: any): TPromise<any>;
+	resolveDebugConfiguration(folderUri: uri | undefined, type: string | undefined, debugConfiguration: any): TPromise<any>;
 }
 
 export interface ILaunch {

src/vs/workbench/parts/debug/electron-browser/debugConfigurationManager.ts

@@ -259,12 +259,12 @@ export class ConfigurationManager implements IConfigurationManager {
 		return this._providers.delete(handle);
 	}
 
-	public resolveDebugConfiguration(folderUri: uri | undefined, debugConfiguration: IConfig): TPromise<IConfig> {
+	public resolveDebugConfiguration(folderUri: uri | undefined, type: string | undefined, debugConfiguration: IConfig): TPromise<IConfig> {
 
 		// collect all candidates
 		const providers: IDebugConfigurationProvider[] = [];
 		this._providers.forEach(provider => {
-			if (provider.type === debugConfiguration.type && provider.resolveDebugConfiguration) {
+			if (provider.type === type && provider.resolveDebugConfiguration) {
 				providers.push(provider);
 			}
 		});
@@ -272,7 +272,11 @@ export class ConfigurationManager implements IConfigurationManager {
 		// pipe the config through the promises sequentially
 		return providers.reduce((promise, provider) => {
 			return promise.then(config => {
-				return provider.resolveDebugConfiguration(folderUri, config);
+				if (config) {
+					return provider.resolveDebugConfiguration(folderUri, config);
+				} else {
+					return Promise.resolve(config);
+				}
 			});
 		}, TPromise.as(debugConfiguration));
 	}

src/vs/workbench/parts/debug/electron-browser/debugService.ts

@@ -639,47 +639,55 @@ export class DebugService implements debug.IDebugService {
 
 				return manager.getStartSessionCommand(config ? config.type : undefined).then<any>(commandAndType => {
 
-					if (!config) {
-						// no-folder workspace
+					// We keep the debug type in a separate variable 'type' so that a no-folder config has no attributes.
+					// Storing the type in the config would break extensions that assume that the no-folder case is indicated by an empty config.
+					let type: string;
+
+					if (config) {
+						type = config.type;
+					} else {
+						// a no-folder workspace has no launch.config
 						config = <debug.IConfig>{};
-						if (commandAndType && commandAndType.type) {
-							config.type = commandAndType.type;
-						}
+					}
+
+					if (!type && commandAndType && commandAndType.type) {
+						type = commandAndType.type;
 					}
 
 					if (noDebug) {
 						config.noDebug = true;
 					}
 
-					return this.configurationManager.resolveDebugConfiguration(launch ? launch.workspaceUri : undefined, config).then(config => {
-
-						// deprecated code: use DebugConfigurationProvider instead of startSessionCommand
-						if (commandAndType && commandAndType.command) {
-							const defaultConfig = noDebug ? { noDebug: true } : {};
-							return this.commandService.executeCommand(commandAndType.command, config || defaultConfig, launch ? launch.workspaceUri : undefined).then((result: StartSessionResult) => {
-								if (launch) {
-									if (result && result.status === 'initialConfiguration') {
-										return launch.openConfigFile(false, commandAndType.type);
-									}
+					return this.configurationManager.resolveDebugConfiguration(launch ? launch.workspaceUri : undefined, type, config).then(config => {
 
-									if (result && result.status === 'saveConfiguration') {
-										return this.fileService.updateContent(launch.uri, result.content).then(() => launch.openConfigFile(false));
-									}
-								}
-								return <TPromise>undefined;
-							});
-						}
-						// end of deprecation
+						// a falsy config indicates an aborted launch
+						if (config) {
 
-						if (config.type) {
-							// TODO@AW: handle the 'initialConfiguration' and 'saveConfiguration' cases from above!
-							return this.createProcess(root, config);
-						}
+							// deprecated code: use DebugConfigurationProvider instead of startSessionCommand
+							if (commandAndType && commandAndType.command) {
+								return this.commandService.executeCommand(commandAndType.command, config, launch ? launch.workspaceUri : undefined).then((result: StartSessionResult) => {
+									if (launch) {
+										if (result && result.status === 'initialConfiguration') {
+											return launch.openConfigFile(false, commandAndType.type);
+										}
 
-						if (launch && commandAndType) {
-							return launch.openConfigFile(false, commandAndType.type);
+										if (result && result.status === 'saveConfiguration') {
+											return this.fileService.updateContent(launch.uri, result.content).then(() => launch.openConfigFile(false));
+										}
+									}
+									return <TPromise>undefined;
+								});
+							}
+							// end of deprecation
+
+							if (config.type) {
+								return this.createProcess(root, config);
+							}
+
+							if (launch && commandAndType) {
+								return launch.openConfigFile(false, commandAndType.type);
+							}
 						}
-
 						return undefined;
 					});
 				});