1use crate::{
2 diagnostic_set::DiagnosticEntry, CodeAction, CodeLabel, Completion, Diagnostic, Language,
3 Operation,
4};
5use anyhow::{anyhow, Result};
6use clock::ReplicaId;
7use lsp::DiagnosticSeverity;
8use rpc::proto;
9use std::{ops::Range, sync::Arc};
10use text::*;
11
12pub use proto::{Buffer, BufferState, SelectionSet};
13
14pub fn serialize_operation(operation: &Operation) -> proto::Operation {
15 proto::Operation {
16 variant: Some(match operation {
17 Operation::Buffer(text::Operation::Edit(edit)) => {
18 proto::operation::Variant::Edit(serialize_edit_operation(edit))
19 }
20 Operation::Buffer(text::Operation::Undo {
21 undo,
22 lamport_timestamp,
23 }) => proto::operation::Variant::Undo(proto::operation::Undo {
24 replica_id: undo.id.replica_id as u32,
25 local_timestamp: undo.id.value,
26 lamport_timestamp: lamport_timestamp.value,
27 version: serialize_version(&undo.version),
28 transaction_ranges: undo
29 .transaction_ranges
30 .iter()
31 .map(serialize_range)
32 .collect(),
33 transaction_version: serialize_version(&undo.transaction_version),
34 counts: undo
35 .counts
36 .iter()
37 .map(|(edit_id, count)| proto::UndoCount {
38 replica_id: edit_id.replica_id as u32,
39 local_timestamp: edit_id.value,
40 count: *count,
41 })
42 .collect(),
43 }),
44 Operation::UpdateSelections {
45 selections,
46 line_mode,
47 lamport_timestamp,
48 } => proto::operation::Variant::UpdateSelections(proto::operation::UpdateSelections {
49 replica_id: lamport_timestamp.replica_id as u32,
50 lamport_timestamp: lamport_timestamp.value,
51 selections: serialize_selections(selections),
52 line_mode: *line_mode,
53 }),
54 Operation::UpdateDiagnostics {
55 diagnostics,
56 lamport_timestamp,
57 } => proto::operation::Variant::UpdateDiagnostics(proto::UpdateDiagnostics {
58 replica_id: lamport_timestamp.replica_id as u32,
59 lamport_timestamp: lamport_timestamp.value,
60 diagnostics: serialize_diagnostics(diagnostics.iter()),
61 }),
62 Operation::UpdateCompletionTriggers {
63 triggers,
64 lamport_timestamp,
65 } => proto::operation::Variant::UpdateCompletionTriggers(
66 proto::operation::UpdateCompletionTriggers {
67 replica_id: lamport_timestamp.replica_id as u32,
68 lamport_timestamp: lamport_timestamp.value,
69 triggers: triggers.clone(),
70 },
71 ),
72 }),
73 }
74}
75
76pub fn serialize_edit_operation(operation: &EditOperation) -> proto::operation::Edit {
77 proto::operation::Edit {
78 replica_id: operation.timestamp.replica_id as u32,
79 local_timestamp: operation.timestamp.local,
80 lamport_timestamp: operation.timestamp.lamport,
81 version: serialize_version(&operation.version),
82 ranges: operation.ranges.iter().map(serialize_range).collect(),
83 new_text: operation
84 .new_text
85 .iter()
86 .map(|text| text.to_string())
87 .collect(),
88 }
89}
90
91pub fn serialize_undo_map_entry(
92 (edit_id, counts): (&clock::Local, &[(clock::Local, u32)]),
93) -> proto::UndoMapEntry {
94 proto::UndoMapEntry {
95 replica_id: edit_id.replica_id as u32,
96 local_timestamp: edit_id.value,
97 counts: counts
98 .iter()
99 .map(|(undo_id, count)| proto::UndoCount {
100 replica_id: undo_id.replica_id as u32,
101 local_timestamp: undo_id.value,
102 count: *count,
103 })
104 .collect(),
105 }
106}
107
108pub fn serialize_selections(selections: &Arc<[Selection<Anchor>]>) -> Vec<proto::Selection> {
109 selections.iter().map(serialize_selection).collect()
110}
111
112pub fn serialize_selection(selection: &Selection<Anchor>) -> proto::Selection {
113 proto::Selection {
114 id: selection.id as u64,
115 start: Some(serialize_anchor(&selection.start)),
116 end: Some(serialize_anchor(&selection.end)),
117 reversed: selection.reversed,
118 }
119}
120
121pub fn serialize_diagnostics<'a>(
122 diagnostics: impl IntoIterator<Item = &'a DiagnosticEntry<Anchor>>,
123) -> Vec<proto::Diagnostic> {
124 diagnostics
125 .into_iter()
126 .map(|entry| proto::Diagnostic {
127 start: Some(serialize_anchor(&entry.range.start)),
128 end: Some(serialize_anchor(&entry.range.end)),
129 message: entry.diagnostic.message.clone(),
130 severity: match entry.diagnostic.severity {
131 DiagnosticSeverity::ERROR => proto::diagnostic::Severity::Error,
132 DiagnosticSeverity::WARNING => proto::diagnostic::Severity::Warning,
133 DiagnosticSeverity::INFORMATION => proto::diagnostic::Severity::Information,
134 DiagnosticSeverity::HINT => proto::diagnostic::Severity::Hint,
135 _ => proto::diagnostic::Severity::None,
136 } as i32,
137 group_id: entry.diagnostic.group_id as u64,
138 is_primary: entry.diagnostic.is_primary,
139 is_valid: entry.diagnostic.is_valid,
140 code: entry.diagnostic.code.clone(),
141 is_disk_based: entry.diagnostic.is_disk_based,
142 is_unnecessary: entry.diagnostic.is_unnecessary,
143 })
144 .collect()
145}
146
147pub fn serialize_anchor(anchor: &Anchor) -> proto::Anchor {
148 proto::Anchor {
149 replica_id: anchor.timestamp.replica_id as u32,
150 local_timestamp: anchor.timestamp.value,
151 offset: anchor.offset as u64,
152 bias: match anchor.bias {
153 Bias::Left => proto::Bias::Left as i32,
154 Bias::Right => proto::Bias::Right as i32,
155 },
156 buffer_id: anchor.buffer_id,
157 }
158}
159
160pub fn deserialize_operation(message: proto::Operation) -> Result<Operation> {
161 Ok(
162 match message
163 .variant
164 .ok_or_else(|| anyhow!("missing operation variant"))?
165 {
166 proto::operation::Variant::Edit(edit) => {
167 Operation::Buffer(text::Operation::Edit(deserialize_edit_operation(edit)))
168 }
169 proto::operation::Variant::Undo(undo) => Operation::Buffer(text::Operation::Undo {
170 lamport_timestamp: clock::Lamport {
171 replica_id: undo.replica_id as ReplicaId,
172 value: undo.lamport_timestamp,
173 },
174 undo: UndoOperation {
175 id: clock::Local {
176 replica_id: undo.replica_id as ReplicaId,
177 value: undo.local_timestamp,
178 },
179 version: deserialize_version(undo.version),
180 counts: undo
181 .counts
182 .into_iter()
183 .map(|c| {
184 (
185 clock::Local {
186 replica_id: c.replica_id as ReplicaId,
187 value: c.local_timestamp,
188 },
189 c.count,
190 )
191 })
192 .collect(),
193 transaction_ranges: undo
194 .transaction_ranges
195 .into_iter()
196 .map(deserialize_range)
197 .collect(),
198 transaction_version: deserialize_version(undo.transaction_version),
199 },
200 }),
201 proto::operation::Variant::UpdateSelections(message) => {
202 let selections = message
203 .selections
204 .into_iter()
205 .filter_map(|selection| {
206 Some(Selection {
207 id: selection.id as usize,
208 start: deserialize_anchor(selection.start?)?,
209 end: deserialize_anchor(selection.end?)?,
210 reversed: selection.reversed,
211 goal: SelectionGoal::None,
212 })
213 })
214 .collect::<Vec<_>>();
215
216 Operation::UpdateSelections {
217 lamport_timestamp: clock::Lamport {
218 replica_id: message.replica_id as ReplicaId,
219 value: message.lamport_timestamp,
220 },
221 selections: Arc::from(selections),
222 line_mode: message.line_mode,
223 }
224 }
225 proto::operation::Variant::UpdateDiagnostics(message) => Operation::UpdateDiagnostics {
226 diagnostics: deserialize_diagnostics(message.diagnostics),
227 lamport_timestamp: clock::Lamport {
228 replica_id: message.replica_id as ReplicaId,
229 value: message.lamport_timestamp,
230 },
231 },
232 proto::operation::Variant::UpdateCompletionTriggers(message) => {
233 Operation::UpdateCompletionTriggers {
234 triggers: message.triggers,
235 lamport_timestamp: clock::Lamport {
236 replica_id: message.replica_id as ReplicaId,
237 value: message.lamport_timestamp,
238 },
239 }
240 }
241 },
242 )
243}
244
245pub fn deserialize_edit_operation(edit: proto::operation::Edit) -> EditOperation {
246 EditOperation {
247 timestamp: InsertionTimestamp {
248 replica_id: edit.replica_id as ReplicaId,
249 local: edit.local_timestamp,
250 lamport: edit.lamport_timestamp,
251 },
252 version: deserialize_version(edit.version),
253 ranges: edit.ranges.into_iter().map(deserialize_range).collect(),
254 new_text: edit.new_text.into_iter().map(Arc::from).collect(),
255 }
256}
257
258pub fn deserialize_undo_map_entry(
259 entry: proto::UndoMapEntry,
260) -> (clock::Local, Vec<(clock::Local, u32)>) {
261 (
262 clock::Local {
263 replica_id: entry.replica_id as u16,
264 value: entry.local_timestamp,
265 },
266 entry
267 .counts
268 .into_iter()
269 .map(|undo_count| {
270 (
271 clock::Local {
272 replica_id: undo_count.replica_id as u16,
273 value: undo_count.local_timestamp,
274 },
275 undo_count.count,
276 )
277 })
278 .collect(),
279 )
280}
281
282pub fn deserialize_selections(selections: Vec<proto::Selection>) -> Arc<[Selection<Anchor>]> {
283 Arc::from(
284 selections
285 .into_iter()
286 .filter_map(deserialize_selection)
287 .collect::<Vec<_>>(),
288 )
289}
290
291pub fn deserialize_selection(selection: proto::Selection) -> Option<Selection<Anchor>> {
292 Some(Selection {
293 id: selection.id as usize,
294 start: deserialize_anchor(selection.start?)?,
295 end: deserialize_anchor(selection.end?)?,
296 reversed: selection.reversed,
297 goal: SelectionGoal::None,
298 })
299}
300
301pub fn deserialize_diagnostics(
302 diagnostics: Vec<proto::Diagnostic>,
303) -> Arc<[DiagnosticEntry<Anchor>]> {
304 diagnostics
305 .into_iter()
306 .filter_map(|diagnostic| {
307 Some(DiagnosticEntry {
308 range: deserialize_anchor(diagnostic.start?)?..deserialize_anchor(diagnostic.end?)?,
309 diagnostic: Diagnostic {
310 severity: match proto::diagnostic::Severity::from_i32(diagnostic.severity)? {
311 proto::diagnostic::Severity::Error => DiagnosticSeverity::ERROR,
312 proto::diagnostic::Severity::Warning => DiagnosticSeverity::WARNING,
313 proto::diagnostic::Severity::Information => DiagnosticSeverity::INFORMATION,
314 proto::diagnostic::Severity::Hint => DiagnosticSeverity::HINT,
315 proto::diagnostic::Severity::None => return None,
316 },
317 message: diagnostic.message,
318 group_id: diagnostic.group_id as usize,
319 code: diagnostic.code,
320 is_valid: diagnostic.is_valid,
321 is_primary: diagnostic.is_primary,
322 is_disk_based: diagnostic.is_disk_based,
323 is_unnecessary: diagnostic.is_unnecessary,
324 },
325 })
326 })
327 .collect()
328}
329
330pub fn deserialize_anchor(anchor: proto::Anchor) -> Option<Anchor> {
331 Some(Anchor {
332 timestamp: clock::Local {
333 replica_id: anchor.replica_id as ReplicaId,
334 value: anchor.local_timestamp,
335 },
336 offset: anchor.offset as usize,
337 bias: match proto::Bias::from_i32(anchor.bias)? {
338 proto::Bias::Left => Bias::Left,
339 proto::Bias::Right => Bias::Right,
340 },
341 buffer_id: anchor.buffer_id,
342 })
343}
344
345pub fn lamport_timestamp_for_operation(operation: &proto::Operation) -> Option<clock::Lamport> {
346 let replica_id;
347 let value;
348 match operation.variant.as_ref()? {
349 proto::operation::Variant::Edit(op) => {
350 replica_id = op.replica_id;
351 value = op.lamport_timestamp;
352 }
353 proto::operation::Variant::Undo(op) => {
354 replica_id = op.replica_id;
355 value = op.lamport_timestamp;
356 }
357 proto::operation::Variant::UpdateDiagnostics(op) => {
358 replica_id = op.replica_id;
359 value = op.lamport_timestamp;
360 }
361 proto::operation::Variant::UpdateSelections(op) => {
362 replica_id = op.replica_id;
363 value = op.lamport_timestamp;
364 }
365 proto::operation::Variant::UpdateCompletionTriggers(op) => {
366 replica_id = op.replica_id;
367 value = op.lamport_timestamp;
368 }
369 }
370
371 Some(clock::Lamport {
372 replica_id: replica_id as ReplicaId,
373 value,
374 })
375}
376
377pub fn serialize_completion(completion: &Completion) -> proto::Completion {
378 proto::Completion {
379 old_start: Some(serialize_anchor(&completion.old_range.start)),
380 old_end: Some(serialize_anchor(&completion.old_range.end)),
381 new_text: completion.new_text.clone(),
382 lsp_completion: serde_json::to_vec(&completion.lsp_completion).unwrap(),
383 }
384}
385
386pub fn deserialize_completion(
387 completion: proto::Completion,
388 language: Option<&Arc<Language>>,
389) -> Result<Completion> {
390 let old_start = completion
391 .old_start
392 .and_then(deserialize_anchor)
393 .ok_or_else(|| anyhow!("invalid old start"))?;
394 let old_end = completion
395 .old_end
396 .and_then(deserialize_anchor)
397 .ok_or_else(|| anyhow!("invalid old end"))?;
398 let lsp_completion = serde_json::from_slice(&completion.lsp_completion)?;
399 Ok(Completion {
400 old_range: old_start..old_end,
401 new_text: completion.new_text,
402 label: language
403 .and_then(|l| l.label_for_completion(&lsp_completion))
404 .unwrap_or(CodeLabel::plain(
405 lsp_completion.label.clone(),
406 lsp_completion.filter_text.as_deref(),
407 )),
408 lsp_completion,
409 })
410}
411
412pub fn serialize_code_action(action: &CodeAction) -> proto::CodeAction {
413 proto::CodeAction {
414 start: Some(serialize_anchor(&action.range.start)),
415 end: Some(serialize_anchor(&action.range.end)),
416 lsp_action: serde_json::to_vec(&action.lsp_action).unwrap(),
417 }
418}
419
420pub fn deserialize_code_action(action: proto::CodeAction) -> Result<CodeAction> {
421 let start = action
422 .start
423 .and_then(deserialize_anchor)
424 .ok_or_else(|| anyhow!("invalid start"))?;
425 let end = action
426 .end
427 .and_then(deserialize_anchor)
428 .ok_or_else(|| anyhow!("invalid end"))?;
429 let lsp_action = serde_json::from_slice(&action.lsp_action)?;
430 Ok(CodeAction {
431 range: start..end,
432 lsp_action,
433 })
434}
435
436pub fn serialize_transaction(transaction: &Transaction) -> proto::Transaction {
437 proto::Transaction {
438 id: Some(serialize_local_timestamp(transaction.id)),
439 edit_ids: transaction
440 .edit_ids
441 .iter()
442 .copied()
443 .map(serialize_local_timestamp)
444 .collect(),
445 start: serialize_version(&transaction.start),
446 end: serialize_version(&transaction.end),
447 ranges: transaction.ranges.iter().map(serialize_range).collect(),
448 }
449}
450
451pub fn deserialize_transaction(transaction: proto::Transaction) -> Result<Transaction> {
452 Ok(Transaction {
453 id: deserialize_local_timestamp(
454 transaction
455 .id
456 .ok_or_else(|| anyhow!("missing transaction id"))?,
457 ),
458 edit_ids: transaction
459 .edit_ids
460 .into_iter()
461 .map(deserialize_local_timestamp)
462 .collect(),
463 start: deserialize_version(transaction.start.into()),
464 end: deserialize_version(transaction.end),
465 ranges: transaction
466 .ranges
467 .into_iter()
468 .map(deserialize_range)
469 .collect(),
470 })
471}
472
473pub fn serialize_local_timestamp(timestamp: clock::Local) -> proto::LocalTimestamp {
474 proto::LocalTimestamp {
475 replica_id: timestamp.replica_id as u32,
476 value: timestamp.value,
477 }
478}
479
480pub fn deserialize_local_timestamp(timestamp: proto::LocalTimestamp) -> clock::Local {
481 clock::Local {
482 replica_id: timestamp.replica_id as ReplicaId,
483 value: timestamp.value,
484 }
485}
486
487pub fn serialize_range(range: &Range<FullOffset>) -> proto::Range {
488 proto::Range {
489 start: range.start.0 as u64,
490 end: range.end.0 as u64,
491 }
492}
493
494pub fn deserialize_range(range: proto::Range) -> Range<FullOffset> {
495 FullOffset(range.start as usize)..FullOffset(range.end as usize)
496}
497
498pub fn deserialize_version(message: Vec<proto::VectorClockEntry>) -> clock::Global {
499 let mut version = clock::Global::new();
500 for entry in message {
501 version.observe(clock::Local {
502 replica_id: entry.replica_id as ReplicaId,
503 value: entry.timestamp,
504 });
505 }
506 version
507}
508
509pub fn serialize_version(version: &clock::Global) -> Vec<proto::VectorClockEntry> {
510 version
511 .iter()
512 .map(|entry| proto::VectorClockEntry {
513 replica_id: entry.replica_id as u32,
514 timestamp: entry.value,
515 })
516 .collect()
517}