Skip to content

Remove casts #230

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 1 commit into
base: main
Choose a base branch
from
Open

Remove casts #230

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
125 changes: 82 additions & 43 deletions adapter/src/debugSession.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,7 @@

import {DebugProtocol} from 'vscode-debugprotocol';
import {ProtocolServer} from './protocol';
import {Response, Event} from './messages';
import {ContinueResponse, Response, Event, SetBreakpointsResponse, SetFunctionBreakpointsResponse, StackTraceResponse, ScopesResponse, VariablesResponse, SetVariableResponse, SetExpressionResponse, ThreadsResponse, SourceResponse, EvaluateResponse, StepInTargetsResponse, GotoTargetsResponse, CompletionsResponse, ExceptionInfoResponse, LoadedSourcesResponse, DataBreakpointInfoResponse, SetDataBreakpointsResponse, BreakpointLocationsResponse} from './messages';
import * as Net from 'net';
import {URL} from 'url';

Expand Down Expand Up @@ -466,8 +466,6 @@ export class DebugSession extends ProtocolServer {

protected dispatchRequest(request: DebugProtocol.Request): void {

const response = new Response(request);

try {
if (request.command === 'initialize') {
var args = <DebugProtocol.InitializeRequestArguments> request.arguments;
Expand All @@ -479,132 +477,173 @@ export class DebugSession extends ProtocolServer {
this._clientColumnsStartAt1 = args.columnsStartAt1;
}

const response = new Response(request);
if (args.pathFormat !== 'path') {
this.sendErrorResponse(response, 2018, 'debug adapter only supports native paths', null, ErrorDestination.Telemetry);
} else {
const initializeResponse = <DebugProtocol.InitializeResponse> response;
const initializeResponse: DebugProtocol.InitializeResponse = response;
initializeResponse.body = {};
this.initializeRequest(initializeResponse, args);
}

} else if (request.command === 'launch') {
this.launchRequest(<DebugProtocol.LaunchResponse> response, request.arguments, request);
const response = new Response(request);
this.launchRequest(response, request.arguments, request);

} else if (request.command === 'attach') {
this.attachRequest(<DebugProtocol.AttachResponse> response, request.arguments, request);
const response = new Response(request);
this.attachRequest(response, request.arguments, request);

} else if (request.command === 'disconnect') {
this.disconnectRequest(<DebugProtocol.DisconnectResponse> response, request.arguments, request);
const response = new Response(request);
this.disconnectRequest(response, request.arguments, request);

} else if (request.command === 'terminate') {
this.terminateRequest(<DebugProtocol.TerminateResponse> response, request.arguments, request);
const response = new Response(request);
this.terminateRequest(response, request.arguments, request);

} else if (request.command === 'restart') {
this.restartRequest(<DebugProtocol.RestartResponse> response, request.arguments, request);
const response = new Response(request);
this.restartRequest(response, request.arguments, request);

} else if (request.command === 'setBreakpoints') {
this.setBreakPointsRequest(<DebugProtocol.SetBreakpointsResponse> response, request.arguments, request);
const response = new SetBreakpointsResponse(request);
this.setBreakPointsRequest(response, request.arguments, request);

} else if (request.command === 'setFunctionBreakpoints') {
this.setFunctionBreakPointsRequest(<DebugProtocol.SetFunctionBreakpointsResponse> response, request.arguments, request);
const response = new SetFunctionBreakpointsResponse(request);
this.setFunctionBreakPointsRequest(response, request.arguments, request);

} else if (request.command === 'setExceptionBreakpoints') {
this.setExceptionBreakPointsRequest(<DebugProtocol.SetExceptionBreakpointsResponse> response, request.arguments, request);
const response = new Response(request);
this.setExceptionBreakPointsRequest(response, request.arguments, request);

} else if (request.command === 'configurationDone') {
this.configurationDoneRequest(<DebugProtocol.ConfigurationDoneResponse> response, request.arguments, request);
const response = new Response(request);
this.configurationDoneRequest(response, request.arguments, request);

} else if (request.command === 'continue') {
this.continueRequest(<DebugProtocol.ContinueResponse> response, request.arguments, request);
const response = new ContinueResponse(request);
this.continueRequest(response, request.arguments, request);

} else if (request.command === 'next') {
this.nextRequest(<DebugProtocol.NextResponse> response, request.arguments, request);
const response = new Response(request);
this.nextRequest(response, request.arguments, request);

} else if (request.command === 'stepIn') {
this.stepInRequest(<DebugProtocol.StepInResponse> response, request.arguments, request);
const response = new Response(request);
this.stepInRequest(response, request.arguments, request);

} else if (request.command === 'stepOut') {
this.stepOutRequest(<DebugProtocol.StepOutResponse> response, request.arguments, request);
const response = new Response(request);
this.stepOutRequest(response, request.arguments, request);

} else if (request.command === 'stepBack') {
this.stepBackRequest(<DebugProtocol.StepBackResponse> response, request.arguments, request);
const response = new Response(request);
this.stepBackRequest(response, request.arguments, request);

} else if (request.command === 'reverseContinue') {
this.reverseContinueRequest(<DebugProtocol.ReverseContinueResponse> response, request.arguments, request);
const response = new Response(request);
this.reverseContinueRequest(response, request.arguments, request);

} else if (request.command === 'restartFrame') {
this.restartFrameRequest(<DebugProtocol.RestartFrameResponse> response, request.arguments, request);
const response = new Response(request);
this.restartFrameRequest(response, request.arguments, request);

} else if (request.command === 'goto') {
this.gotoRequest(<DebugProtocol.GotoResponse> response, request.arguments, request);
const response = new Response(request);
this.gotoRequest(response, request.arguments, request);

} else if (request.command === 'pause') {
this.pauseRequest(<DebugProtocol.PauseResponse> response, request.arguments, request);
const response = new Response(request);
this.pauseRequest(response, request.arguments, request);

} else if (request.command === 'stackTrace') {
this.stackTraceRequest(<DebugProtocol.StackTraceResponse> response, request.arguments, request);
const response = new StackTraceResponse(request);
this.stackTraceRequest(response, request.arguments, request);

} else if (request.command === 'scopes') {
this.scopesRequest(<DebugProtocol.ScopesResponse> response, request.arguments, request);
const response = new ScopesResponse(request);
this.scopesRequest(response, request.arguments, request);

} else if (request.command === 'variables') {
this.variablesRequest(<DebugProtocol.VariablesResponse> response, request.arguments, request);
const response = new VariablesResponse(request);
this.variablesRequest(response, request.arguments, request);

} else if (request.command === 'setVariable') {
this.setVariableRequest(<DebugProtocol.SetVariableResponse> response, request.arguments, request);
const response = new SetVariableResponse(request);
this.setVariableRequest(response, request.arguments, request);

} else if (request.command === 'setExpression') {
this.setExpressionRequest(<DebugProtocol.SetExpressionResponse> response, request.arguments, request);
const response = new SetExpressionResponse(request);
this.setExpressionRequest(response, request.arguments, request);

} else if (request.command === 'source') {
this.sourceRequest(<DebugProtocol.SourceResponse> response, request.arguments, request);
const response = new SourceResponse(request);
this.sourceRequest(response, request.arguments, request);

} else if (request.command === 'threads') {
this.threadsRequest(<DebugProtocol.ThreadsResponse> response, request);
const response = new ThreadsResponse(request);
this.threadsRequest(response, request);

} else if (request.command === 'terminateThreads') {
this.terminateThreadsRequest(<DebugProtocol.TerminateThreadsResponse> response, request.arguments, request);
const response = new Response(request);
this.terminateThreadsRequest(response, request.arguments, request);

} else if (request.command === 'evaluate') {
this.evaluateRequest(<DebugProtocol.EvaluateResponse> response, request.arguments, request);
const response = new EvaluateResponse(request);
this.evaluateRequest(response, request.arguments, request);

} else if (request.command === 'stepInTargets') {
this.stepInTargetsRequest(<DebugProtocol.StepInTargetsResponse> response, request.arguments, request);
const response = new StepInTargetsResponse(request);
this.stepInTargetsRequest(response, request.arguments, request);

} else if (request.command === 'gotoTargets') {
this.gotoTargetsRequest(<DebugProtocol.GotoTargetsResponse> response, request.arguments, request);
const response = new GotoTargetsResponse(request);
this.gotoTargetsRequest(response, request.arguments, request);

} else if (request.command === 'completions') {
this.completionsRequest(<DebugProtocol.CompletionsResponse> response, request.arguments, request);
const response = new CompletionsResponse(request);
this.completionsRequest(response, request.arguments, request);

} else if (request.command === 'exceptionInfo') {
this.exceptionInfoRequest(<DebugProtocol.ExceptionInfoResponse> response, request.arguments, request);
const response = new ExceptionInfoResponse(request);
this.exceptionInfoRequest(response, request.arguments, request);

} else if (request.command === 'loadedSources') {
this.loadedSourcesRequest(<DebugProtocol.LoadedSourcesResponse> response, request.arguments, request);
const response = new LoadedSourcesResponse(request);
this.loadedSourcesRequest(response, request.arguments, request);

} else if (request.command === 'dataBreakpointInfo') {
this.dataBreakpointInfoRequest(<DebugProtocol.DataBreakpointInfoResponse> response, request.arguments, request);
const response = new DataBreakpointInfoResponse(request);
this.dataBreakpointInfoRequest(response, request.arguments, request);

} else if (request.command === 'setDataBreakpoints') {
this.setDataBreakpointsRequest(<DebugProtocol.SetDataBreakpointsResponse> response, request.arguments, request);
const response = new SetDataBreakpointsResponse(request);
this.setDataBreakpointsRequest(response, request.arguments, request);

} else if (request.command === 'readMemory') {
this.readMemoryRequest(<DebugProtocol.ReadMemoryResponse> response, request.arguments, request);
const response = new Response(request);
this.readMemoryRequest(response, request.arguments, request);

} else if (request.command === 'disassemble') {
this.disassembleRequest(<DebugProtocol.DisassembleResponse> response, request.arguments, request);
const response = new Response(request);
this.disassembleRequest(response, request.arguments, request);

} else if (request.command === 'cancel') {
this.cancelRequest(<DebugProtocol.CancelResponse> response, request.arguments, request);
const response = new Response(request);
this.cancelRequest(response, request.arguments, request);

} else if (request.command === 'breakpointLocations') {
this.breakpointLocationsRequest(<DebugProtocol.BreakpointLocationsResponse> response, request.arguments, request);
const response = new BreakpointLocationsResponse(request);
this.breakpointLocationsRequest(response, request.arguments, request);

} else {
this.customRequest(request.command, <DebugProtocol.Response> response, request.arguments, request);
const response = new Response(request);
this.customRequest(request.command, response, request.arguments, request);
}
} catch (e) {
const response = new Response(request);
this.sendErrorResponse(response, 1104, '{_stack}', { _exception: e.message, _stack: e.stack }, ErrorDestination.Telemetry);
}
}
Expand Down
137 changes: 137 additions & 0 deletions adapter/src/messages.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -34,6 +34,143 @@ export class Response extends Message implements DebugProtocol.Response {
}
}

export class SetBreakpointsResponse extends Response implements DebugProtocol.SetBreakpointsResponse {
body = {
breakpoints: []
};
}

export class SetFunctionBreakpointsResponse extends Response implements DebugProtocol.SetFunctionBreakpointsResponse {
body = {
breakpoints: []
};
}

export class ContinueResponse extends Response implements DebugProtocol.ContinueResponse {
body = {
allThreadsContinued: undefined
};
}

export class ScopesResponse extends Response implements DebugProtocol.ScopesResponse {
body = {
scopes: []
};
}

export class StackTraceResponse extends Response implements DebugProtocol.StackTraceResponse {
body = {
stackFrames: [],
totalFrames: undefined
};
}

export class VariablesResponse extends Response implements DebugProtocol.VariablesResponse {
body = {
variables: []
};
}

export class SetVariableResponse extends Response implements DebugProtocol.SetVariableResponse {
body: {
value: "";
type: undefined,
variablesReference: undefined,
namedVariables: undefined,
indexedVariables: undefined
};
}

export class SetExpressionResponse extends Response implements DebugProtocol.SetExpressionResponse {
body: {
value: "";
type: undefined,
presentationHint: undefined,
variablesReference: undefined,
namedVariables: undefined,
indexedVariables: undefined
};
}

export class SourceResponse extends Response implements DebugProtocol.SourceResponse {
body: {
content: "";
mimeType: undefined;
};
}

export class ThreadsResponse extends Response implements DebugProtocol.ThreadsResponse {
body: {
threads: []
};
}

export class EvaluateResponse extends Response implements DebugProtocol.EvaluateResponse {
body: {
result: "",
type: undefined,
presentationHint: undefined,
variablesReference: 0,
namedVariables: undefined,
indexedVariables: undefined,
memoryReference: undefined
};
}

export class StepInTargetsResponse extends Response implements DebugProtocol.StepInTargetsResponse {
body: {
targets: []
};
}

export class GotoTargetsResponse extends Response implements DebugProtocol.GotoTargetsResponse {
body: {
targets: []
};
}

export class CompletionsResponse extends Response implements DebugProtocol.CompletionsResponse {
body: {
targets: []
};
}

export class ExceptionInfoResponse extends Response implements DebugProtocol.ExceptionInfoResponse {
body: {
exceptionId: "",
description: undefined,
breakMode: 'never',
details: undefined
};
}

export class LoadedSourcesResponse extends Response implements DebugProtocol.LoadedSourcesResponse {
body: {
sources: []
};
}

export class DataBreakpointInfoResponse extends Response implements DebugProtocol.DataBreakpointInfoResponse {
body: {
dataId: null,
description: "",
accessTypes: undefined,
canPersist: undefined
};
}

export class BreakpointLocationsResponse extends Response implements DebugProtocol.BreakpointLocationsResponse {
body: {
breakpoints: []
};
}

export class SetDataBreakpointsResponse extends Response implements DebugProtocol.SetDataBreakpointsResponse {
body: {
breakpoints: []
};
}

export class Event extends Message implements DebugProtocol.Event {
event: string;

Expand Down