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