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