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