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