git.iko.soy/helix
on 2158366 help sign in
helix/helix-dap/src/types.rs
662 lines 20 kB history raw
1use serde::{Deserialize, Serialize};
2use serde_json::Value;
3use std::path::PathBuf;
5#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
6#[serde(rename_all = "kebab-case")]
7pub struct DebugAdapterConfig {
8 pub name: String,
9 pub transport: String,
10 pub command: String,
11 pub args: Vec<String>,
12 pub port_arg: Option<String>,
15pub trait Request {
16 type Arguments: serde::de::DeserializeOwned + serde::Serialize;
17 type Result: serde::de::DeserializeOwned + serde::Serialize;
18 const COMMAND: &'static str;
21#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
22#[serde(rename_all = "camelCase")]
23pub struct ColumnDescriptor {
24 pub attribute_name: String,
25 pub label: String,
26 pub format: Option<String>,
27 #[serde(rename = "type")]
28 pub col_type: Option<String>,
29 pub width: Option<usize>,
32#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
33#[serde(rename_all = "camelCase")]
34pub struct ExceptionBreakpointsFilter {
35 pub filter: String,
36 pub label: String,
37 pub description: Option<String>,
38 pub default: Option<bool>,
39 pub supports_condition: Option<bool>,
40 pub condition_description: Option<String>,
43#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
44#[serde(rename_all = "camelCase")]
45pub struct DebuggerCapabilities {
46 pub supports_configuration_done_request: Option<bool>,
47 pub supports_function_breakpoints: Option<bool>,
48 pub supports_conditional_breakpoints: Option<bool>,
49 pub supports_hit_conditional_breakpoints: Option<bool>,
50 pub supports_evaluate_for_hovers: Option<bool>,
51 pub supports_step_back: Option<bool>,
52 pub supports_set_variable: Option<bool>,
53 pub supports_restart_frame: Option<bool>,
54 pub supports_goto_targets_request: Option<bool>,
55 pub supports_step_in_targets_request: Option<bool>,
56 pub supports_completions_request: Option<bool>,
57 pub supports_modules_request: Option<bool>,
58 pub supports_restart_request: Option<bool>,
59 pub supports_exception_options: Option<bool>,
60 pub supports_value_formatting_options: Option<bool>,
61 pub supports_exception_info_request: Option<bool>,
62 pub support_terminate_debuggee: Option<bool>,
63 pub support_suspend_debuggee: Option<bool>,
64 pub supports_delayed_stack_trace_loading: Option<bool>,
65 pub supports_loaded_sources_request: Option<bool>,
66 pub supports_log_points: Option<bool>,
67 pub supports_terminate_threads_request: Option<bool>,
68 pub supports_set_expression: Option<bool>,
69 pub supports_terminate_request: Option<bool>,
70 pub supports_data_breakpoints: Option<bool>,
71 pub supports_read_memory_request: Option<bool>,
72 pub supports_write_memory_request: Option<bool>,
73 pub supports_disassemble_request: Option<bool>,
74 pub supports_cancel_request: Option<bool>,
75 pub supports_breakpoint_locations_request: Option<bool>,
76 pub supports_clipboard_context: Option<bool>,
77 pub supports_stepping_granularity: Option<bool>,
78 pub supports_instruction_breakpoints: Option<bool>,
79 pub supports_exception_filter_options: Option<bool>,
80 pub exception_breakpoint_filters: Option<Vec<ExceptionBreakpointsFilter>>,
81 pub completion_trigger_characters: Option<Vec<String>>,
82 pub additional_module_columns: Option<Vec<ColumnDescriptor>>,
83 pub supported_checksum_algorithms: Option<Vec<String>>,
86impl std::ops::Deref for DebuggerCapabilities {
87 type Target = Option<bool>;
89 fn deref(&self) -> &Self::Target {
90 &self.supports_exception_options
91 }
94#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
95#[serde(rename_all = "camelCase")]
96pub struct Checksum {
97 pub algorithm: String,
98 pub checksum: String,
101#[derive(Debug, Default, PartialEq, Clone, Deserialize, Serialize)]
102#[serde(rename_all = "camelCase")]
103pub struct Source {
104 pub name: Option<String>,
105 pub path: Option<PathBuf>,
106 pub source_reference: Option<usize>,
107 pub presentation_hint: Option<String>,
108 pub origin: Option<String>,
109 pub sources: Option<Vec<Source>>,
110 pub adapter_data: Option<Value>,
111 pub checksums: Option<Vec<Checksum>>,
114#[derive(Debug, Default, PartialEq, Clone, Deserialize, Serialize)]
115#[serde(rename_all = "camelCase")]
116pub struct SourceBreakpoint {
117 pub line: usize,
118 pub column: Option<usize>,
119 pub condition: Option<String>,
120 pub hit_condition: Option<String>,
121 pub log_message: Option<String>,
124#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
125#[serde(rename_all = "camelCase")]
126pub struct Breakpoint {
127 pub id: Option<usize>,
128 pub verified: bool,
129 pub message: Option<String>,
130 pub source: Option<Source>,
131 pub line: Option<usize>,
132 pub column: Option<usize>,
133 pub end_line: Option<usize>,
134 pub end_column: Option<usize>,
135 pub instruction_reference: Option<String>,
136 pub offset: Option<usize>,
139#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
140#[serde(rename_all = "camelCase")]
141pub struct StackFrameFormat {
142 pub parameters: Option<bool>,
143 pub parameter_types: Option<bool>,
144 pub parameter_names: Option<bool>,
145 pub parameter_values: Option<bool>,
146 pub line: Option<bool>,
147 pub module: Option<bool>,
148 pub include_all: Option<bool>,
151#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
152#[serde(rename_all = "camelCase")]
153pub struct StackFrame {
154 pub id: usize,
155 pub name: String,
156 pub source: Option<Source>,
157 pub line: usize,
158 pub column: usize,
159 pub end_line: Option<usize>,
160 pub end_column: Option<usize>,
161 pub can_restart: Option<bool>,
162 pub instruction_pointer_reference: Option<String>,
163 pub module_id: Option<Value>,
164 pub presentation_hint: Option<String>,
167#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
168#[serde(rename_all = "camelCase")]
169pub struct Thread {
170 pub id: usize,
171 pub name: String,
174#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
175#[serde(rename_all = "camelCase")]
176pub struct Scope {
177 pub name: String,
178 pub presentation_hint: Option<String>,
179 pub variables_reference: usize,
180 pub named_variables: Option<usize>,
181 pub indexed_variables: Option<usize>,
182 pub expensive: bool,
183 pub source: Option<Source>,
184 pub line: Option<usize>,
185 pub column: Option<usize>,
186 pub end_line: Option<usize>,
187 pub end_column: Option<usize>,
190#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
191#[serde(rename_all = "camelCase")]
192pub struct ValueFormat {
193 pub hex: Option<bool>,
196#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
197#[serde(rename_all = "camelCase")]
198pub struct VariablePresentationHint {
199 pub kind: Option<String>,
200 pub attributes: Option<Vec<String>>,
201 pub visibility: Option<String>,
204#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
205#[serde(rename_all = "camelCase")]
206pub struct Variable {
207 pub name: String,
208 pub value: String,
209 #[serde(rename = "type")]
210 pub data_type: Option<String>,
211 pub presentation_hint: Option<VariablePresentationHint>,
212 pub evaluate_name: Option<String>,
213 pub variables_reference: usize,
214 pub named_variables: Option<usize>,
215 pub indexed_variables: Option<usize>,
216 pub memory_reference: Option<String>,
219#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
220#[serde(rename_all = "camelCase")]
221pub struct Module {
222 pub id: String, // TODO: || number
223 pub name: String,
224 pub path: Option<PathBuf>,
225 pub is_optimized: Option<bool>,
226 pub is_user_code: Option<bool>,
227 pub version: Option<String>,
228 pub symbol_status: Option<String>,
229 pub symbol_file_path: Option<String>,
230 pub date_time_stamp: Option<String>,
231 pub address_range: Option<String>,
234pub mod requests {
235 use super::*;
236 #[derive(Debug, Default, PartialEq, Clone, Deserialize, Serialize)]
237 #[serde(rename_all = "camelCase")]
238 pub struct InitializeArguments {
239 #[serde(rename = "clientID")]
240 pub client_id: Option<String>,
241 pub client_name: Option<String>,
242 #[serde(rename = "adapterID")]
243 pub adapter_id: String,
244 pub locale: Option<String>,
245 #[serde(rename = "linesStartAt1")]
246 pub lines_start_at_one: Option<bool>,
247 #[serde(rename = "columnsStartAt1")]
248 pub columns_start_at_one: Option<bool>,
249 pub path_format: Option<String>,
250 pub supports_variable_type: Option<bool>,
251 pub supports_variable_paging: Option<bool>,
252 pub supports_run_in_terminal_request: Option<bool>,
253 pub supports_memory_references: Option<bool>,
254 pub supports_progress_reporting: Option<bool>,
255 pub supports_invalidated_event: Option<bool>,
256 }
258 #[derive(Debug)]
259 pub enum Initialize {}
261 impl Request for Initialize {
262 type Arguments = InitializeArguments;
263 type Result = DebuggerCapabilities;
264 const COMMAND: &'static str = "initialize";
265 }
267 #[derive(Debug)]
268 pub enum Launch {}
270 impl Request for Launch {
271 type Arguments = Value;
272 type Result = Value;
273 const COMMAND: &'static str = "launch";
274 }
276 #[derive(Debug)]
277 pub enum Attach {}
279 impl Request for Attach {
280 type Arguments = Value;
281 type Result = Value;
282 const COMMAND: &'static str = "attach";
283 }
285 #[derive(Debug)]
286 pub enum Disconnect {}
288 impl Request for Disconnect {
289 type Arguments = ();
290 type Result = ();
291 const COMMAND: &'static str = "disconnect";
292 }
294 #[derive(Debug)]
295 pub enum ConfigurationDone {}
297 impl Request for ConfigurationDone {
298 type Arguments = ();
299 type Result = ();
300 const COMMAND: &'static str = "configurationDone";
301 }
303 #[derive(Debug, Default, PartialEq, Clone, Deserialize, Serialize)]
304 #[serde(rename_all = "camelCase")]
305 pub struct SetBreakpointsArguments {
306 pub source: Source,
307 pub breakpoints: Option<Vec<SourceBreakpoint>>,
308 // lines is deprecated
309 pub source_modified: Option<bool>,
310 }
312 #[derive(Debug, Default, PartialEq, Clone, Deserialize, Serialize)]
313 #[serde(rename_all = "camelCase")]
314 pub struct SetBreakpointsResponse {
315 pub breakpoints: Option<Vec<Breakpoint>>,
316 }
318 #[derive(Debug)]
319 pub enum SetBreakpoints {}
321 impl Request for SetBreakpoints {
322 type Arguments = SetBreakpointsArguments;
323 type Result = SetBreakpointsResponse;
324 const COMMAND: &'static str = "setBreakpoints";
325 }
327 #[derive(Debug, Default, PartialEq, Clone, Deserialize, Serialize)]
328 #[serde(rename_all = "camelCase")]
329 pub struct ContinueArguments {
330 pub thread_id: usize,
331 }
333 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
334 #[serde(rename_all = "camelCase")]
335 pub struct ContinueResponse {
336 pub all_threads_continued: Option<bool>,
337 }
339 #[derive(Debug)]
340 pub enum Continue {}
342 impl Request for Continue {
343 type Arguments = ContinueArguments;
344 type Result = ContinueResponse;
345 const COMMAND: &'static str = "continue";
346 }
348 #[derive(Debug, Default, PartialEq, Clone, Deserialize, Serialize)]
349 #[serde(rename_all = "camelCase")]
350 pub struct StackTraceArguments {
351 pub thread_id: usize,
352 pub start_frame: Option<usize>,
353 pub levels: Option<usize>,
354 pub format: Option<StackFrameFormat>,
355 }
357 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
358 #[serde(rename_all = "camelCase")]
359 pub struct StackTraceResponse {
360 pub total_frames: Option<usize>,
361 pub stack_frames: Vec<StackFrame>,
362 }
364 #[derive(Debug)]
365 pub enum StackTrace {}
367 impl Request for StackTrace {
368 type Arguments = StackTraceArguments;
369 type Result = StackTraceResponse;
370 const COMMAND: &'static str = "stackTrace";
371 }
373 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
374 #[serde(rename_all = "camelCase")]
375 pub struct ThreadsResponse {
376 pub threads: Vec<Thread>,
377 }
379 #[derive(Debug)]
380 pub enum Threads {}
382 impl Request for Threads {
383 type Arguments = ();
384 type Result = ThreadsResponse;
385 const COMMAND: &'static str = "threads";
386 }
388 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
389 #[serde(rename_all = "camelCase")]
390 pub struct ScopesArguments {
391 pub frame_id: usize,
392 }
394 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
395 #[serde(rename_all = "camelCase")]
396 pub struct ScopesResponse {
397 pub scopes: Vec<Scope>,
398 }
400 #[derive(Debug)]
401 pub enum Scopes {}
403 impl Request for Scopes {
404 type Arguments = ScopesArguments;
405 type Result = ScopesResponse;
406 const COMMAND: &'static str = "scopes";
407 }
409 #[derive(Debug, Default, PartialEq, Clone, Deserialize, Serialize)]
410 #[serde(rename_all = "camelCase")]
411 pub struct VariablesArguments {
412 pub variables_reference: usize,
413 pub filter: Option<String>,
414 pub start: Option<usize>,
415 pub count: Option<usize>,
416 pub format: Option<ValueFormat>,
417 }
419 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
420 #[serde(rename_all = "camelCase")]
421 pub struct VariablesResponse {
422 pub variables: Vec<Variable>,
423 }
425 #[derive(Debug)]
426 pub enum Variables {}
428 impl Request for Variables {
429 type Arguments = VariablesArguments;
430 type Result = VariablesResponse;
431 const COMMAND: &'static str = "variables";
432 }
434 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
435 #[serde(rename_all = "camelCase")]
436 pub struct StepInArguments {
437 pub thread_id: usize,
438 pub target_id: Option<usize>,
439 pub granularity: Option<String>,
440 }
442 #[derive(Debug)]
443 pub enum StepIn {}
445 impl Request for StepIn {
446 type Arguments = StepInArguments;
447 type Result = ();
448 const COMMAND: &'static str = "stepIn";
449 }
451 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
452 #[serde(rename_all = "camelCase")]
453 pub struct StepOutArguments {
454 pub thread_id: usize,
455 pub granularity: Option<String>,
456 }
458 #[derive(Debug)]
459 pub enum StepOut {}
461 impl Request for StepOut {
462 type Arguments = StepOutArguments;
463 type Result = ();
464 const COMMAND: &'static str = "stepOut";
465 }
467 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
468 #[serde(rename_all = "camelCase")]
469 pub struct NextArguments {
470 pub thread_id: usize,
471 pub granularity: Option<String>,
472 }
474 #[derive(Debug)]
475 pub enum Next {}
477 impl Request for Next {
478 type Arguments = NextArguments;
479 type Result = ();
480 const COMMAND: &'static str = "next";
481 }
483 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
484 #[serde(rename_all = "camelCase")]
485 pub struct PauseArguments {
486 pub thread_id: usize,
487 }
489 #[derive(Debug)]
490 pub enum Pause {}
492 impl Request for Pause {
493 type Arguments = PauseArguments;
494 type Result = ();
495 const COMMAND: &'static str = "pause";
496 }
498 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
499 #[serde(rename_all = "camelCase")]
500 pub struct EvaluateArguments {
501 pub expression: String,
502 pub frame_id: Option<usize>,
503 pub context: Option<String>,
504 pub format: Option<ValueFormat>,
505 }
507 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
508 #[serde(rename_all = "camelCase")]
509 pub struct EvaluateResponse {
510 pub result: String,
511 #[serde(rename = "type")]
512 pub data_type: Option<String>,
513 pub presentation_hint: Option<VariablePresentationHint>,
514 pub variables_reference: usize,
515 pub named_variables: Option<usize>,
516 pub indexed_variables: Option<usize>,
517 pub memory_reference: Option<String>,
518 }
520 #[derive(Debug)]
521 pub enum Evaluate {}
523 impl Request for Evaluate {
524 type Arguments = EvaluateArguments;
525 type Result = EvaluateResponse;
526 const COMMAND: &'static str = "evaluate";
527 }
530// Events
532pub mod events {
533 use super::*;
535 #[derive(Debug, Clone, Serialize, Deserialize)]
536 #[serde(rename_all = "camelCase")]
537 #[serde(tag = "event", content = "body")]
538 // seq is omitted as unused and is not sent by some implementations
539 pub enum Event {
540 Initialized,
541 Stopped(Stopped),
542 Continued(Continued),
543 Exited(Exited),
544 Terminated(Option<Terminated>),
545 Thread(Thread),
546 Output(Output),
547 Breakpoint(Breakpoint),
548 Module(Module),
549 LoadedSource(LoadedSource),
550 Process(Process),
551 Capabilities(Capabilities),
552 // ProgressStart(),
553 // ProgressUpdate(),
554 // ProgressEnd(),
555 // Invalidated(),
556 Memory(Memory),
557 }
559 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
560 #[serde(rename_all = "camelCase")]
561 pub struct Stopped {
562 pub reason: String,
563 pub description: Option<String>,
564 pub thread_id: Option<usize>,
565 pub preserve_focus_hint: Option<bool>,
566 pub text: Option<String>,
567 pub all_threads_stopped: Option<bool>,
568 pub hit_breakpoint_ids: Option<Vec<usize>>,
569 }
571 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
572 #[serde(rename_all = "camelCase")]
573 pub struct Continued {
574 pub thread_id: usize,
575 pub all_threads_continued: Option<bool>,
576 }
578 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
579 #[serde(rename_all = "camelCase")]
580 pub struct Exited {
581 pub exit_code: usize,
582 }
584 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
585 #[serde(rename_all = "camelCase")]
586 pub struct Terminated {
587 pub restart: Option<Value>,
588 }
590 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
591 #[serde(rename_all = "camelCase")]
592 pub struct Thread {
593 pub reason: String,
594 pub thread_id: usize,
595 }
597 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
598 #[serde(rename_all = "camelCase")]
599 pub struct Output {
600 pub output: String,
601 pub category: Option<String>,
602 pub group: Option<String>,
603 pub line: Option<usize>,
604 pub column: Option<usize>,
605 pub variables_reference: Option<usize>,
606 pub source: Option<Source>,
607 pub data: Option<Value>,
608 }
610 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
611 #[serde(rename_all = "camelCase")]
612 pub struct Breakpoint {
613 pub reason: String,
614 pub breakpoint: super::Breakpoint,
615 }
617 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
618 #[serde(rename_all = "camelCase")]
619 pub struct Module {
620 pub reason: String,
621 pub module: super::Module,
622 }
624 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
625 #[serde(rename_all = "camelCase")]
626 pub struct LoadedSource {
627 pub reason: String,
628 pub source: super::Source,
629 }
631 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
632 #[serde(rename_all = "camelCase")]
633 pub struct Process {
634 pub name: String,
635 pub system_process_id: Option<usize>,
636 pub is_local_process: Option<bool>,
637 pub start_method: Option<String>, // TODO: use enum
638 pub pointer_size: Option<usize>,
639 }
641 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
642 #[serde(rename_all = "camelCase")]
643 pub struct Capabilities {
644 pub capabilities: super::DebuggerCapabilities,
645 }
647 // #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
648 // #[serde(rename_all = "camelCase")]
649 // pub struct Invalidated {
650 // pub areas: Vec<InvalidatedArea>,
651 // pub thread_id: Option<usize>,
652 // pub stack_frame_id: Option<usize>,
653 // }
655 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
656 #[serde(rename_all = "camelCase")]
657 pub struct Memory {
658 pub memory_reference: String,
659 pub offset: usize,
660 pub count: usize,
661 }