debugSession: simplify return types where not used

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

@@ -183,13 +183,13 @@ export interface IDebugSession extends ITreeElement {
 
 	initialize(dbgr: IDebugger): TPromise<void>;
 	launchOrAttach(config: IConfig): TPromise<void>;
-	restart(): TPromise<DebugProtocol.RestartResponse>;
+	restart(): TPromise<void>;
 	terminate(restart?: boolean /* false */): TPromise<void>;
 	disconnect(restart?: boolean /* false */): TPromise<void>;
 
 	sendBreakpoints(modelUri: uri, bpts: IBreakpoint[], sourceModified: boolean): TPromise<ActualBreakpoints | undefined>;
 	sendFunctionBreakpoints(fbps: IFunctionBreakpoint[]): TPromise<ActualBreakpoints | undefined>;
-	sendExceptionBreakpoints(exbpts: IExceptionBreakpoint[]): TPromise<any>;
+	sendExceptionBreakpoints(exbpts: IExceptionBreakpoint[]): TPromise<void>;
 
 	stackTrace(threadId: number, startFrame: number, levels: number): TPromise<DebugProtocol.StackTraceResponse>;
 	exceptionInfo(threadId: number): TPromise<IExceptionInfo>;
@@ -198,15 +198,15 @@ export interface IDebugSession extends ITreeElement {
 	evaluate(expression: string, frameId?: number, context?: string): TPromise<DebugProtocol.EvaluateResponse>;
 	customRequest(request: string, args: any): TPromise<DebugProtocol.Response>;
 
-	restartFrame(frameId: number, threadId: number): TPromise<DebugProtocol.RestartFrameResponse>;
-	next(threadId: number): TPromise<DebugProtocol.NextResponse>;
-	stepIn(threadId: number): TPromise<DebugProtocol.StepInResponse>;
-	stepOut(threadId: number): TPromise<DebugProtocol.StepOutResponse>;
-	stepBack(threadId: number): TPromise<DebugProtocol.StepBackResponse>;
-	continue(threadId: number): TPromise<DebugProtocol.ContinueResponse>;
-	reverseContinue(threadId: number): TPromise<DebugProtocol.ReverseContinueResponse>;
-	pause(threadId: number): TPromise<DebugProtocol.PauseResponse>;
-	terminateThreads(threadIds: number[]): TPromise<DebugProtocol.TerminateThreadsResponse>;
+	restartFrame(frameId: number, threadId: number): TPromise<void>;
+	next(threadId: number): TPromise<void>;
+	stepIn(threadId: number): TPromise<void>;
+	stepOut(threadId: number): TPromise<void>;
+	stepBack(threadId: number): TPromise<void>;
+	continue(threadId: number): TPromise<void>;
+	reverseContinue(threadId: number): TPromise<void>;
+	pause(threadId: number): TPromise<void>;
+	terminateThreads(threadIds: number[]): TPromise<void>;
 
 	completions(frameId: number, text: string, position: Position, overwriteBefore: number): TPromise<CompletionItem[]>;
 	setVariable(variablesReference: number, name: string, value: string): TPromise<DebugProtocol.SetVariableResponse>;

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

@@ -376,7 +376,7 @@ export class StackFrame implements IStackFrame {
 		});
 	}
 
-	public restart(): TPromise<any> {
+	public restart(): TPromise<void> {
 		return this.thread.session.restartFrame(this.frameId, this.thread.threadId);
 	}
 

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

@@ -165,7 +165,7 @@ export class DebugSession implements IDebugSession {
 						supportsVariablePaging: true, // #9537
 						supportsRunInTerminalRequest: true, // #10574
 						locale: platform.locale
-					}).then(response => {
+					}).then(() => {
 						this.model.addSession(this);
 						this._onDidChangeState.fire();
 						this.model.setExceptionBreakpoints(this.raw.capabilities.exceptionBreakpointFilters);
@@ -223,9 +223,9 @@ export class DebugSession implements IDebugSession {
 	/**
 	 * restart debug adapter session
 	 */
-	restart(): TPromise<DebugProtocol.RestartResponse> {
+	restart(): TPromise<void> {
 		if (this.raw) {
-			return this.raw.restart();
+			return this.raw.restart().then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}
@@ -293,10 +293,10 @@ export class DebugSession implements IDebugSession {
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	sendExceptionBreakpoints(exbpts: IExceptionBreakpoint[]): TPromise<any> {
+	sendExceptionBreakpoints(exbpts: IExceptionBreakpoint[]): TPromise<void> {
 		if (this.raw) {
 			if (this.raw.readyForBreakpoints) {
-				return this.raw.setExceptionBreakpoints({ filters: exbpts.map(exb => exb.filter) });
+				return this.raw.setExceptionBreakpoints({ filters: exbpts.map(exb => exb.filter) }).then(() => undefined);
 			}
 			return Promise.resolve(null);
 		}
@@ -355,65 +355,65 @@ export class DebugSession implements IDebugSession {
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	restartFrame(frameId: number, threadId: number): TPromise<DebugProtocol.RestartFrameResponse> {
+	restartFrame(frameId: number, threadId: number): TPromise<void> {
 		if (this.raw) {
-			return this.raw.restartFrame({ frameId }, threadId);
+			return this.raw.restartFrame({ frameId }, threadId).then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	next(threadId: number): TPromise<DebugProtocol.NextResponse> {
+	next(threadId: number): TPromise<void> {
 		if (this.raw) {
-			return this.raw.next({ threadId });
+			return this.raw.next({ threadId }).then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	stepIn(threadId: number): TPromise<DebugProtocol.StepInResponse> {
+	stepIn(threadId: number): TPromise<void> {
 		if (this.raw) {
-			return this.raw.stepIn({ threadId });
+			return this.raw.stepIn({ threadId }).then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	stepOut(threadId: number): TPromise<DebugProtocol.StepOutResponse> {
+	stepOut(threadId: number): TPromise<void> {
 		if (this.raw) {
-			return this.raw.stepOut({ threadId });
+			return this.raw.stepOut({ threadId }).then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	stepBack(threadId: number): TPromise<DebugProtocol.StepBackResponse> {
+	stepBack(threadId: number): TPromise<void> {
 		if (this.raw) {
-			return this.raw.stepBack({ threadId });
+			return this.raw.stepBack({ threadId }).then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	continue(threadId: number): TPromise<DebugProtocol.ContinueResponse> {
+	continue(threadId: number): TPromise<void> {
 		if (this.raw) {
-			return this.raw.continue({ threadId });
+			return this.raw.continue({ threadId }).then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	reverseContinue(threadId: number): TPromise<DebugProtocol.ReverseContinueResponse> {
+	reverseContinue(threadId: number): TPromise<void> {
 		if (this.raw) {
-			return this.raw.reverseContinue({ threadId });
+			return this.raw.reverseContinue({ threadId }).then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	pause(threadId: number): TPromise<DebugProtocol.PauseResponse> {
+	pause(threadId: number): TPromise<void> {
 		if (this.raw) {
-			return this.raw.pause({ threadId });
+			return this.raw.pause({ threadId }).then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}
 
-	terminateThreads(threadIds?: number[]): TPromise<DebugProtocol.TerminateThreadsResponse> {
+	terminateThreads(threadIds?: number[]): TPromise<void> {
 		if (this.raw) {
-			return this.raw.terminateThreads({ threadIds });
+			return this.raw.terminateThreads({ threadIds }).then(() => undefined);
 		}
 		return Promise.reject(new Error('no debug adapter'));
 	}

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

@@ -206,7 +206,7 @@ export class MockSession implements IDebugSession {
 	launchOrAttach(config: IConfig): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	restart(): TPromise<DebugProtocol.RestartResponse> {
+	restart(): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
 	sendBreakpoints(modelUri: uri, bpts: IBreakpoint[], sourceModified: boolean): TPromise<ActualBreakpoints> {
@@ -215,7 +215,7 @@ export class MockSession implements IDebugSession {
 	sendFunctionBreakpoints(fbps: IFunctionBreakpoint[]): TPromise<ActualBreakpoints> {
 		throw new Error('Method not implemented.');
 	}
-	sendExceptionBreakpoints(exbpts: IExceptionBreakpoint[]): TPromise<any> {
+	sendExceptionBreakpoints(exbpts: IExceptionBreakpoint[]): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
 	customRequest(request: string, args: any): TPromise<DebugProtocol.Response> {
@@ -236,31 +236,31 @@ export class MockSession implements IDebugSession {
 	evaluate(expression: string, frameId: number, context?: string): TPromise<DebugProtocol.EvaluateResponse> {
 		throw new Error('Method not implemented.');
 	}
-	restartFrame(frameId: number, threadId: number): TPromise<DebugProtocol.RestartFrameResponse> {
+	restartFrame(frameId: number, threadId: number): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	next(threadId: number): TPromise<DebugProtocol.NextResponse> {
+	next(threadId: number): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	stepIn(threadId: number): TPromise<DebugProtocol.StepInResponse> {
+	stepIn(threadId: number): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	stepOut(threadId: number): TPromise<DebugProtocol.StepOutResponse> {
+	stepOut(threadId: number): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	stepBack(threadId: number): TPromise<DebugProtocol.StepBackResponse> {
+	stepBack(threadId: number): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	continue(threadId: number): TPromise<DebugProtocol.ContinueResponse> {
+	continue(threadId: number): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	reverseContinue(threadId: number): TPromise<DebugProtocol.ReverseContinueResponse> {
+	reverseContinue(threadId: number): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	pause(threadId: number): TPromise<DebugProtocol.PauseResponse> {
+	pause(threadId: number): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
-	terminateThreads(threadIds: number[]): TPromise<DebugProtocol.TerminateThreadsResponse> {
+	terminateThreads(threadIds: number[]): TPromise<void> {
 		throw new Error('Method not implemented.');
 	}
 	setVariable(variablesReference: number, name: string, value: string): TPromise<DebugProtocol.SetVariableResponse> {