debug: return result of a msg to debug adapter can be undefined

Author: isidorn

src/vs/workbench/contrib/debug/browser/debugActions.ts

@@ -408,7 +408,9 @@ export class CopyValueAction extends Action {
 
 		try {
 			const evaluation = await session.evaluate(toEvaluate, stackFrame.frameId, context);
-			this.clipboardService.writeText(evaluation.body.result);
+			if (evaluation) {
+				this.clipboardService.writeText(evaluation.body.result);
+			}
 		} catch (e) {
 			this.clipboardService.writeText(typeof this.value === 'string' ? this.value : this.value.value);
 		}

src/vs/workbench/contrib/debug/browser/debugCommands.ts

@@ -167,8 +167,8 @@ export function registerCommands(): void {
 				const source = stackFrame.thread.session.getSourceForUri(resource);
 				if (source) {
 					const response = await stackFrame.thread.session.gotoTargets(source.raw, position.lineNumber, position.column);
-					const targets = response.body.targets;
-					if (targets.length) {
+					const targets = response?.body.targets;
+					if (targets && targets.length) {
 						let id = targets[0].id;
 						if (targets.length > 1) {
 							const picks = targets.map(t => ({ label: t.label, _id: t.id }));

src/vs/workbench/contrib/debug/browser/debugEditorActions.ts

@@ -277,6 +277,10 @@ class StepIntoTargetsAction extends EditorAction {
 
 		if (session && frame && editor.hasModel() && editor.getModel().uri.toString() === frame.source.uri.toString()) {
 			const targets = await session.stepInTargets(frame.frameId);
+			if (!targets) {
+				return;
+			}
+
 			editor.revealLineInCenterIfOutsideViewport(frame.range.startLineNumber);
 			const cursorCoords = editor.getScrolledVisiblePosition({ lineNumber: frame.range.startLineNumber, column: frame.range.startColumn });
 			const editorCoords = getDomNodePagePosition(editor.getDomNode());

src/vs/workbench/contrib/debug/browser/debugSession.ts

@@ -404,7 +404,7 @@ export class DebugSession implements IDebugSession {
 		}
 
 		const response = await this.raw.dataBreakpointInfo({ name, variablesReference });
-		return response.body;
+		return response?.body;
 	}
 
 	async sendDataBreakpoints(dataBreakpoints: IDataBreakpoint[]): Promise<void> {
@@ -431,7 +431,7 @@ export class DebugSession implements IDebugSession {
 
 		const source = this.getRawSource(uri);
 		const response = await this.raw.breakpointLocations({ source, line: lineNumber });
-		if (!response.body || !response.body.breakpoints) {
+		if (!response || !response.body || !response.body.breakpoints) {
 			return [];
 		}
 
@@ -444,15 +444,15 @@ export class DebugSession implements IDebugSession {
 		return this.model.getDebugProtocolBreakpoint(breakpointId, this.getId());
 	}
 
-	customRequest(request: string, args: any): Promise<DebugProtocol.Response> {
+	customRequest(request: string, args: any): Promise<DebugProtocol.Response | undefined> {
 		if (!this.raw) {
 			throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", request));
 		}
 
 		return this.raw.custom(request, args);
 	}
 
-	stackTrace(threadId: number, startFrame: number, levels: number, token: CancellationToken): Promise<DebugProtocol.StackTraceResponse> {
+	stackTrace(threadId: number, startFrame: number, levels: number, token: CancellationToken): Promise<DebugProtocol.StackTraceResponse | undefined> {
 		if (!this.raw) {
 			throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'stackTrace'));
 		}
@@ -479,7 +479,7 @@ export class DebugSession implements IDebugSession {
 		return undefined;
 	}
 
-	scopes(frameId: number, threadId: number): Promise<DebugProtocol.ScopesResponse> {
+	scopes(frameId: number, threadId: number): Promise<DebugProtocol.ScopesResponse | undefined> {
 		if (!this.raw) {
 			throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'scopes'));
 		}
@@ -488,7 +488,7 @@ export class DebugSession implements IDebugSession {
 		return this.raw.scopes({ frameId }, token);
 	}
 
-	variables(variablesReference: number, threadId: number | undefined, filter: 'indexed' | 'named' | undefined, start: number | undefined, count: number | undefined): Promise<DebugProtocol.VariablesResponse> {
+	variables(variablesReference: number, threadId: number | undefined, filter: 'indexed' | 'named' | undefined, start: number | undefined, count: number | undefined): Promise<DebugProtocol.VariablesResponse | undefined> {
 		if (!this.raw) {
 			throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'variables'));
 		}
@@ -497,7 +497,7 @@ export class DebugSession implements IDebugSession {
 		return this.raw.variables({ variablesReference, filter, start, count }, token);
 	}
 
-	evaluate(expression: string, frameId: number, context?: string): Promise<DebugProtocol.EvaluateResponse> {
+	evaluate(expression: string, frameId: number, context?: string): Promise<DebugProtocol.EvaluateResponse | undefined> {
 		if (!this.raw) {
 			throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'evaluate'));
 		}
@@ -577,31 +577,31 @@ export class DebugSession implements IDebugSession {
 		await this.raw.terminateThreads({ threadIds });
 	}
 
-	setVariable(variablesReference: number, name: string, value: string): Promise<DebugProtocol.SetVariableResponse> {
+	setVariable(variablesReference: number, name: string, value: string): Promise<DebugProtocol.SetVariableResponse | undefined> {
 		if (!this.raw) {
 			throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'setVariable'));
 		}
 
 		return this.raw.setVariable({ variablesReference, name, value });
 	}
 
-	gotoTargets(source: DebugProtocol.Source, line: number, column?: number): Promise<DebugProtocol.GotoTargetsResponse> {
+	gotoTargets(source: DebugProtocol.Source, line: number, column?: number): Promise<DebugProtocol.GotoTargetsResponse | undefined> {
 		if (!this.raw) {
 			throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'gotoTargets'));
 		}
 
 		return this.raw.gotoTargets({ source, line, column });
 	}
 
-	goto(threadId: number, targetId: number): Promise<DebugProtocol.GotoResponse> {
+	goto(threadId: number, targetId: number): Promise<DebugProtocol.GotoResponse | undefined> {
 		if (!this.raw) {
 			throw new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'goto'));
 		}
 
 		return this.raw.goto({ threadId, targetId });
 	}
 
-	loadSource(resource: URI): Promise<DebugProtocol.SourceResponse> {
+	loadSource(resource: URI): Promise<DebugProtocol.SourceResponse | undefined> {
 		if (!this.raw) {
 			return Promise.reject(new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'loadSource')));
 		}
@@ -632,7 +632,7 @@ export class DebugSession implements IDebugSession {
 		}
 	}
 
-	async completions(frameId: number | undefined, threadId: number, text: string, position: Position, overwriteBefore: number, token: CancellationToken): Promise<DebugProtocol.CompletionsResponse> {
+	async completions(frameId: number | undefined, threadId: number, text: string, position: Position, overwriteBefore: number, token: CancellationToken): Promise<DebugProtocol.CompletionsResponse | undefined> {
 		if (!this.raw) {
 			return Promise.reject(new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'completions')));
 		}
@@ -646,16 +646,16 @@ export class DebugSession implements IDebugSession {
 		}, sessionCancelationToken);
 	}
 
-	async stepInTargets(frameId: number): Promise<{ id: number, label: string }[]> {
+	async stepInTargets(frameId: number): Promise<{ id: number, label: string }[] | undefined> {
 		if (!this.raw) {
 			return Promise.reject(new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'stepInTargets')));
 		}
 
 		const response = await this.raw.stepInTargets({ frameId });
-		return response.body.targets;
+		return response?.body.targets;
 	}
 
-	async cancel(progressId: string): Promise<DebugProtocol.CancelResponse> {
+	async cancel(progressId: string): Promise<DebugProtocol.CancelResponse | undefined> {
 		if (!this.raw) {
 			return Promise.reject(new Error(localize('noDebugAdapter', "No debugger available, can not send '{0}'", 'cancel')));
 		}