add proposed debug API; fixes #28234

src/vs/workbench/api/node/extHost.api.impl.ts

@@ -34,6 +34,7 @@ import { ExtHostLanguages } from 'vs/workbench/api/node/extHostLanguages';
 import { ExtHostLanguageFeatures } from 'vs/workbench/api/node/extHostLanguageFeatures';
 import { ExtHostApiCommands } from 'vs/workbench/api/node/extHostApiCommands';
 import { ExtHostTask } from 'vs/workbench/api/node/extHostTask';
+import { ExtHostDebugService } from 'vs/workbench/api/node/extHostDebugService';
 import * as extHostTypes from 'vs/workbench/api/node/extHostTypes';
 import URI from 'vs/base/common/uri';
 import Severity from 'vs/base/common/severity';
@@ -83,6 +84,7 @@ export function createApiFactory(
 	// Addressable instances
 	const col = new InstanceCollection();
 	const extHostHeapService = col.define(ExtHostContext.ExtHostHeapService).set<ExtHostHeapService>(new ExtHostHeapService());
+	const extHostDebugService = col.define(ExtHostContext.ExtHostDebugService).set<ExtHostDebugService>(new ExtHostDebugService(threadService));
 	const extHostDocumentsAndEditors = col.define(ExtHostContext.ExtHostDocumentsAndEditors).set<ExtHostDocumentsAndEditors>(new ExtHostDocumentsAndEditors(threadService));
 	const extHostDocuments = col.define(ExtHostContext.ExtHostDocuments).set<ExtHostDocuments>(new ExtHostDocuments(threadService, extHostDocumentsAndEditors));
 	const extHostDocumentSaveParticipant = col.define(ExtHostContext.ExtHostDocumentSaveParticipant).set<ExtHostDocumentSaveParticipant>(new ExtHostDocumentSaveParticipant(extHostDocuments, threadService.get(MainContext.MainThreadWorkspace)));
@@ -448,6 +450,17 @@ export function createApiFactory(
 			}
 		};
 
+		// namespace: debug
+		const debug: typeof vscode.debug = {
+			createDebugSession: proposedApiFunction(extension, (config: vscode.DebugConfiguration) => {
+				return extHostDebugService.createDebugSession(config);
+			}),
+			onDidTerminateDebugSession: proposedApiFunction(extension, (listener, thisArg?, disposables?) => {
+				return extHostDebugService.onDidTerminateDebugSession(listener, thisArg, disposables);
+			})
+		};
+
+
 		return {
 			version: pkg.version,
 			// namespaces
@@ -458,6 +471,7 @@ export function createApiFactory(
 			window,
 			workspace,
 			scm,
+			debug,
 			// types
 			CancellationTokenSource: CancellationTokenSource,
 			CodeLens: extHostTypes.CodeLens,

src/vs/workbench/api/node/extHost.protocol.ts

@@ -342,6 +342,13 @@ export abstract class MainThreadSCMShape {
 	$setInputBoxValue(value: string): void { throw ni(); }
 }
 
+export type DebugSessionUUID = string;
+
+export abstract class MainThreadDebugServiceShape {
+	$createDebugSession(config: vscode.DebugConfiguration): TPromise<DebugSessionUUID> { throw ni(); }
+	$customDebugAdapterRequest(id: DebugSessionUUID, command: string, args: any): TPromise<any> { throw ni(); }
+}
+
 // -- extension host
 
 export abstract class ExtHostCommandsShape {
@@ -492,11 +499,16 @@ export abstract class ExtHostTaskShape {
 	$provideTasks(handle: number): TPromise<TaskSet> { throw ni(); }
 }
 
+export abstract class ExtHostDebugServiceShape {
+	$acceptDebugSessionTerminated(id: DebugSessionUUID, type: string, name: string): void { throw ni(); }
+}
+
 // --- proxy identifiers
 
 export const MainContext = {
 	MainThreadCommands: createMainId<MainThreadCommandsShape>('MainThreadCommands', MainThreadCommandsShape),
 	MainThreadConfiguration: createMainId<MainThreadConfigurationShape>('MainThreadConfiguration', MainThreadConfigurationShape),
+	MainThreadDebugService: createMainId<MainThreadDebugServiceShape>('MainThreadDebugService', MainThreadDebugServiceShape),
 	MainThreadDiagnostics: createMainId<MainThreadDiagnosticsShape>('MainThreadDiagnostics', MainThreadDiagnosticsShape),
 	MainThreadDocuments: createMainId<MainThreadDocumentsShape>('MainThreadDocuments', MainThreadDocumentsShape),
 	MainThreadEditors: createMainId<MainThreadEditorsShape>('MainThreadEditors', MainThreadEditorsShape),
@@ -522,6 +534,7 @@ export const ExtHostContext = {
 	ExtHostCommands: createExtId<ExtHostCommandsShape>('ExtHostCommands', ExtHostCommandsShape),
 	ExtHostConfiguration: createExtId<ExtHostConfigurationShape>('ExtHostConfiguration', ExtHostConfigurationShape),
 	ExtHostDiagnostics: createExtId<ExtHostDiagnosticsShape>('ExtHostDiagnostics', ExtHostDiagnosticsShape),
+	ExtHostDebugService: createExtId<ExtHostDebugServiceShape>('ExtHostDebugService', ExtHostDebugServiceShape),
 	ExtHostDocumentsAndEditors: createExtId<ExtHostDocumentsAndEditorsShape>('ExtHostDocumentsAndEditors', ExtHostDocumentsAndEditorsShape),
 	ExtHostDocuments: createExtId<ExtHostDocumentsShape>('ExtHostDocuments', ExtHostDocumentsShape),
 	ExtHostDocumentSaveParticipant: createExtId<ExtHostDocumentSaveParticipantShape>('ExtHostDocumentSaveParticipant', ExtHostDocumentSaveParticipantShape),

src/vs/workbench/api/node/extHostDebugService.ts

@@ -0,0 +1,80 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import { TPromise } from 'vs/base/common/winjs.base';
+import Event, { Emitter } from 'vs/base/common/event';
+
+import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
+import { MainContext, MainThreadDebugServiceShape, ExtHostDebugServiceShape, DebugSessionUUID } from 'vs/workbench/api/node/extHost.protocol';
+
+import * as vscode from 'vscode';
+
+
+export class ExtHostDebugService extends ExtHostDebugServiceShape {
+
+	private _debugServiceProxy: MainThreadDebugServiceShape;
+	private _debugSessions: Map<DebugSessionUUID, ExtHostDebugSession> = new Map<DebugSessionUUID, ExtHostDebugSession>();
+
+	private _onDidTerminateDebugSession: Emitter<vscode.DebugSession>;
+	get onDidTerminateDebugSession(): Event<vscode.DebugSession> { return this._onDidTerminateDebugSession.event; }
+
+
+	constructor(threadService: IThreadService) {
+		super();
+
+		this._onDidTerminateDebugSession = new Emitter<vscode.DebugSession>();
+		this._debugServiceProxy = threadService.get(MainContext.MainThreadDebugService);
+	}
+
+	public createDebugSession(config: vscode.DebugConfiguration): TPromise<vscode.DebugSession> {
+
+		return this._debugServiceProxy.$createDebugSession(config).then((id: DebugSessionUUID) => {
+			const debugSession = new ExtHostDebugSession(this._debugServiceProxy, id, config.type, config.name);
+			this._debugSessions.set(id, debugSession);
+			return debugSession;
+		});
+	}
+
+	public $acceptDebugSessionTerminated(id: DebugSessionUUID, type: string, name: string): void {
+
+		let debugSession = this._debugSessions.get(id);
+		if (!debugSession) {
+			debugSession = new ExtHostDebugSession(this._debugServiceProxy, id, type, name);
+		}
+		this._onDidTerminateDebugSession.fire(debugSession);
+		this._debugSessions.delete(id);
+	}
+}
+
+export class ExtHostDebugSession implements vscode.DebugSession {
+
+	private _debugServiceProxy: MainThreadDebugServiceShape;
+
+	private _id: DebugSessionUUID;
+
+	private _type: string;
+	private _name: string;
+
+
+	constructor(proxy: MainThreadDebugServiceShape, id: DebugSessionUUID, type: string, name: string) {
+		this._debugServiceProxy = proxy;
+		this._id = id;
+		this._type = type;
+		this._name = name;
+	};
+
+	public get type(): string {
+		return this._type;
+	}
+
+	public get name(): string {
+		return this._name;
+	}
+
+	public customRequest(command: string, args: any): Thenable<any> {
+		return this._debugServiceProxy.$customDebugAdapterRequest(this._id, command, args);
+	}
+}