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