1use crate::{
2 diagnostic_set::DiagnosticEntry, CodeAction, CodeLabel, Completion, CursorShape, Diagnostic,
3 Language,
4};
5use anyhow::{anyhow, Result};
6use clock::ReplicaId;
7use lsp::{DiagnosticSeverity, LanguageServerId};
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) -> text::LineEnding {
24 match message {
25 proto::LineEnding::Unix => text::LineEnding::Unix,
26 proto::LineEnding::Windows => text::LineEnding::Windows,
27 }
28}
29
30pub fn serialize_line_ending(message: text::LineEnding) -> proto::LineEnding {
31 match message {
32 text::LineEnding::Unix => proto::LineEnding::Unix,
33 text::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
44 crate::Operation::Buffer(text::Operation::Undo(undo)) => {
45 proto::operation::Variant::Undo(proto::operation::Undo {
46 replica_id: undo.timestamp.replica_id as u32,
47 lamport_timestamp: undo.timestamp.value,
48 version: serialize_version(&undo.version),
49 counts: undo
50 .counts
51 .iter()
52 .map(|(edit_id, count)| proto::UndoCount {
53 replica_id: edit_id.replica_id as u32,
54 lamport_timestamp: edit_id.value,
55 count: *count,
56 })
57 .collect(),
58 })
59 }
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
74 crate::Operation::UpdateDiagnostics {
75 lamport_timestamp,
76 server_id,
77 diagnostics,
78 } => proto::operation::Variant::UpdateDiagnostics(proto::UpdateDiagnostics {
79 replica_id: lamport_timestamp.replica_id as u32,
80 lamport_timestamp: lamport_timestamp.value,
81 server_id: server_id.0 as u64,
82 diagnostics: serialize_diagnostics(diagnostics.iter()),
83 }),
84
85 crate::Operation::UpdateCompletionTriggers {
86 triggers,
87 lamport_timestamp,
88 } => proto::operation::Variant::UpdateCompletionTriggers(
89 proto::operation::UpdateCompletionTriggers {
90 replica_id: lamport_timestamp.replica_id as u32,
91 lamport_timestamp: lamport_timestamp.value,
92 triggers: triggers.clone(),
93 },
94 ),
95 }),
96 }
97}
98
99pub fn serialize_edit_operation(operation: &EditOperation) -> proto::operation::Edit {
100 proto::operation::Edit {
101 replica_id: operation.timestamp.replica_id as u32,
102 lamport_timestamp: operation.timestamp.value,
103 version: serialize_version(&operation.version),
104 ranges: operation.ranges.iter().map(serialize_range).collect(),
105 new_text: operation
106 .new_text
107 .iter()
108 .map(|text| text.to_string())
109 .collect(),
110 }
111}
112
113pub fn serialize_undo_map_entry(
114 (edit_id, counts): (&clock::Lamport, &[(clock::Lamport, u32)]),
115) -> proto::UndoMapEntry {
116 proto::UndoMapEntry {
117 replica_id: edit_id.replica_id as u32,
118 local_timestamp: edit_id.value,
119 counts: counts
120 .iter()
121 .map(|(undo_id, count)| proto::UndoCount {
122 replica_id: undo_id.replica_id as u32,
123 lamport_timestamp: undo_id.value,
124 count: *count,
125 })
126 .collect(),
127 }
128}
129
130pub fn serialize_selections(selections: &Arc<[Selection<Anchor>]>) -> Vec<proto::Selection> {
131 selections.iter().map(serialize_selection).collect()
132}
133
134pub fn serialize_selection(selection: &Selection<Anchor>) -> proto::Selection {
135 proto::Selection {
136 id: selection.id as u64,
137 start: Some(proto::EditorAnchor {
138 anchor: Some(serialize_anchor(&selection.start)),
139 excerpt_id: 0,
140 }),
141 end: Some(proto::EditorAnchor {
142 anchor: Some(serialize_anchor(&selection.end)),
143 excerpt_id: 0,
144 }),
145 reversed: selection.reversed,
146 }
147}
148
149pub fn serialize_cursor_shape(cursor_shape: &CursorShape) -> proto::CursorShape {
150 match cursor_shape {
151 CursorShape::Bar => proto::CursorShape::CursorBar,
152 CursorShape::Block => proto::CursorShape::CursorBlock,
153 CursorShape::Underscore => proto::CursorShape::CursorUnderscore,
154 CursorShape::Hollow => proto::CursorShape::CursorHollow,
155 }
156}
157
158pub fn deserialize_cursor_shape(cursor_shape: proto::CursorShape) -> CursorShape {
159 match cursor_shape {
160 proto::CursorShape::CursorBar => CursorShape::Bar,
161 proto::CursorShape::CursorBlock => CursorShape::Block,
162 proto::CursorShape::CursorUnderscore => CursorShape::Underscore,
163 proto::CursorShape::CursorHollow => CursorShape::Hollow,
164 }
165}
166
167pub fn serialize_diagnostics<'a>(
168 diagnostics: impl IntoIterator<Item = &'a DiagnosticEntry<Anchor>>,
169) -> Vec<proto::Diagnostic> {
170 diagnostics
171 .into_iter()
172 .map(|entry| proto::Diagnostic {
173 source: entry.diagnostic.source.clone(),
174 start: Some(serialize_anchor(&entry.range.start)),
175 end: Some(serialize_anchor(&entry.range.end)),
176 message: entry.diagnostic.message.clone(),
177 severity: match entry.diagnostic.severity {
178 DiagnosticSeverity::ERROR => proto::diagnostic::Severity::Error,
179 DiagnosticSeverity::WARNING => proto::diagnostic::Severity::Warning,
180 DiagnosticSeverity::INFORMATION => proto::diagnostic::Severity::Information,
181 DiagnosticSeverity::HINT => proto::diagnostic::Severity::Hint,
182 _ => proto::diagnostic::Severity::None,
183 } as i32,
184 group_id: entry.diagnostic.group_id as u64,
185 is_primary: entry.diagnostic.is_primary,
186 is_valid: entry.diagnostic.is_valid,
187 code: entry.diagnostic.code.clone(),
188 is_disk_based: entry.diagnostic.is_disk_based,
189 is_unnecessary: entry.diagnostic.is_unnecessary,
190 })
191 .collect()
192}
193
194pub fn serialize_anchor(anchor: &Anchor) -> proto::Anchor {
195 proto::Anchor {
196 replica_id: anchor.timestamp.replica_id as u32,
197 timestamp: anchor.timestamp.value,
198 offset: anchor.offset as u64,
199 bias: match anchor.bias {
200 Bias::Left => proto::Bias::Left as i32,
201 Bias::Right => proto::Bias::Right as i32,
202 },
203 buffer_id: anchor.buffer_id,
204 }
205}
206
207// This behavior is currently copied in the collab database, for snapshotting channel notes
208pub fn deserialize_operation(message: proto::Operation) -> Result<crate::Operation> {
209 Ok(
210 match message
211 .variant
212 .ok_or_else(|| anyhow!("missing operation variant"))?
213 {
214 proto::operation::Variant::Edit(edit) => {
215 crate::Operation::Buffer(text::Operation::Edit(deserialize_edit_operation(edit)))
216 }
217 proto::operation::Variant::Undo(undo) => {
218 crate::Operation::Buffer(text::Operation::Undo(UndoOperation {
219 timestamp: clock::Lamport {
220 replica_id: undo.replica_id as ReplicaId,
221 value: undo.lamport_timestamp,
222 },
223 version: deserialize_version(&undo.version),
224 counts: undo
225 .counts
226 .into_iter()
227 .map(|c| {
228 (
229 clock::Lamport {
230 replica_id: c.replica_id as ReplicaId,
231 value: c.lamport_timestamp,
232 },
233 c.count,
234 )
235 })
236 .collect(),
237 }))
238 }
239 proto::operation::Variant::UpdateSelections(message) => {
240 let selections = message
241 .selections
242 .into_iter()
243 .filter_map(|selection| {
244 Some(Selection {
245 id: selection.id as usize,
246 start: deserialize_anchor(selection.start?.anchor?)?,
247 end: deserialize_anchor(selection.end?.anchor?)?,
248 reversed: selection.reversed,
249 goal: SelectionGoal::None,
250 })
251 })
252 .collect::<Vec<_>>();
253
254 crate::Operation::UpdateSelections {
255 lamport_timestamp: clock::Lamport {
256 replica_id: message.replica_id as ReplicaId,
257 value: message.lamport_timestamp,
258 },
259 selections: Arc::from(selections),
260 line_mode: message.line_mode,
261 cursor_shape: deserialize_cursor_shape(
262 proto::CursorShape::from_i32(message.cursor_shape)
263 .ok_or_else(|| anyhow!("Missing cursor shape"))?,
264 ),
265 }
266 }
267 proto::operation::Variant::UpdateDiagnostics(message) => {
268 crate::Operation::UpdateDiagnostics {
269 lamport_timestamp: clock::Lamport {
270 replica_id: message.replica_id as ReplicaId,
271 value: message.lamport_timestamp,
272 },
273 server_id: LanguageServerId(message.server_id as usize),
274 diagnostics: deserialize_diagnostics(message.diagnostics),
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: clock::Lamport {
293 replica_id: edit.replica_id as ReplicaId,
294 value: edit.lamport_timestamp,
295 },
296 version: deserialize_version(&edit.version),
297 ranges: edit.ranges.into_iter().map(deserialize_range).collect(),
298 new_text: edit.new_text.into_iter().map(Arc::from).collect(),
299 }
300}
301
302pub fn deserialize_undo_map_entry(
303 entry: proto::UndoMapEntry,
304) -> (clock::Lamport, Vec<(clock::Lamport, u32)>) {
305 (
306 clock::Lamport {
307 replica_id: entry.replica_id as u16,
308 value: entry.local_timestamp,
309 },
310 entry
311 .counts
312 .into_iter()
313 .map(|undo_count| {
314 (
315 clock::Lamport {
316 replica_id: undo_count.replica_id as u16,
317 value: undo_count.lamport_timestamp,
318 },
319 undo_count.count,
320 )
321 })
322 .collect(),
323 )
324}
325
326pub fn deserialize_selections(selections: Vec<proto::Selection>) -> Arc<[Selection<Anchor>]> {
327 Arc::from(
328 selections
329 .into_iter()
330 .filter_map(deserialize_selection)
331 .collect::<Vec<_>>(),
332 )
333}
334
335pub fn deserialize_selection(selection: proto::Selection) -> Option<Selection<Anchor>> {
336 Some(Selection {
337 id: selection.id as usize,
338 start: deserialize_anchor(selection.start?.anchor?)?,
339 end: deserialize_anchor(selection.end?.anchor?)?,
340 reversed: selection.reversed,
341 goal: SelectionGoal::None,
342 })
343}
344
345pub fn deserialize_diagnostics(
346 diagnostics: Vec<proto::Diagnostic>,
347) -> Arc<[DiagnosticEntry<Anchor>]> {
348 diagnostics
349 .into_iter()
350 .filter_map(|diagnostic| {
351 Some(DiagnosticEntry {
352 range: deserialize_anchor(diagnostic.start?)?..deserialize_anchor(diagnostic.end?)?,
353 diagnostic: Diagnostic {
354 source: diagnostic.source,
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::Lamport {
378 replica_id: anchor.replica_id as ReplicaId,
379 value: anchor.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 server_id: completion.server_id.0 as u64,
428 lsp_completion: serde_json::to_vec(&completion.lsp_completion).unwrap(),
429 }
430}
431
432pub async fn deserialize_completion(
433 completion: proto::Completion,
434 language: Option<Arc<Language>>,
435) -> Result<Completion> {
436 let old_start = completion
437 .old_start
438 .and_then(deserialize_anchor)
439 .ok_or_else(|| anyhow!("invalid old start"))?;
440 let old_end = completion
441 .old_end
442 .and_then(deserialize_anchor)
443 .ok_or_else(|| anyhow!("invalid old end"))?;
444 let lsp_completion = serde_json::from_slice(&completion.lsp_completion)?;
445
446 let mut label = None;
447 if let Some(language) = language {
448 label = language.label_for_completion(&lsp_completion).await;
449 }
450
451 Ok(Completion {
452 old_range: old_start..old_end,
453 new_text: completion.new_text,
454 label: label.unwrap_or_else(|| {
455 CodeLabel::plain(
456 lsp_completion.label.clone(),
457 lsp_completion.filter_text.as_deref(),
458 )
459 }),
460 server_id: LanguageServerId(completion.server_id as usize),
461 lsp_completion,
462 })
463}
464
465pub fn serialize_code_action(action: &CodeAction) -> proto::CodeAction {
466 proto::CodeAction {
467 server_id: action.server_id.0 as u64,
468 start: Some(serialize_anchor(&action.range.start)),
469 end: Some(serialize_anchor(&action.range.end)),
470 lsp_action: serde_json::to_vec(&action.lsp_action).unwrap(),
471 }
472}
473
474pub fn deserialize_code_action(action: proto::CodeAction) -> Result<CodeAction> {
475 let start = action
476 .start
477 .and_then(deserialize_anchor)
478 .ok_or_else(|| anyhow!("invalid start"))?;
479 let end = action
480 .end
481 .and_then(deserialize_anchor)
482 .ok_or_else(|| anyhow!("invalid end"))?;
483 let lsp_action = serde_json::from_slice(&action.lsp_action)?;
484 Ok(CodeAction {
485 server_id: LanguageServerId(action.server_id as usize),
486 range: start..end,
487 lsp_action,
488 })
489}
490
491pub fn serialize_transaction(transaction: &Transaction) -> proto::Transaction {
492 proto::Transaction {
493 id: Some(serialize_timestamp(transaction.id)),
494 edit_ids: transaction
495 .edit_ids
496 .iter()
497 .copied()
498 .map(serialize_timestamp)
499 .collect(),
500 start: serialize_version(&transaction.start),
501 }
502}
503
504pub fn deserialize_transaction(transaction: proto::Transaction) -> Result<Transaction> {
505 Ok(Transaction {
506 id: deserialize_timestamp(
507 transaction
508 .id
509 .ok_or_else(|| anyhow!("missing transaction id"))?,
510 ),
511 edit_ids: transaction
512 .edit_ids
513 .into_iter()
514 .map(deserialize_timestamp)
515 .collect(),
516 start: deserialize_version(&transaction.start),
517 })
518}
519
520pub fn serialize_timestamp(timestamp: clock::Lamport) -> proto::LamportTimestamp {
521 proto::LamportTimestamp {
522 replica_id: timestamp.replica_id as u32,
523 value: timestamp.value,
524 }
525}
526
527pub fn deserialize_timestamp(timestamp: proto::LamportTimestamp) -> clock::Lamport {
528 clock::Lamport {
529 replica_id: timestamp.replica_id as ReplicaId,
530 value: timestamp.value,
531 }
532}
533
534pub fn serialize_range(range: &Range<FullOffset>) -> proto::Range {
535 proto::Range {
536 start: range.start.0 as u64,
537 end: range.end.0 as u64,
538 }
539}
540
541pub fn deserialize_range(range: proto::Range) -> Range<FullOffset> {
542 FullOffset(range.start as usize)..FullOffset(range.end as usize)
543}
544
545pub fn deserialize_version(message: &[proto::VectorClockEntry]) -> clock::Global {
546 let mut version = clock::Global::new();
547 for entry in message {
548 version.observe(clock::Lamport {
549 replica_id: entry.replica_id as ReplicaId,
550 value: entry.timestamp,
551 });
552 }
553 version
554}
555
556pub fn serialize_version(version: &clock::Global) -> Vec<proto::VectorClockEntry> {
557 version
558 .iter()
559 .map(|entry| proto::VectorClockEntry {
560 replica_id: entry.replica_id as u32,
561 timestamp: entry.value,
562 })
563 .collect()
564}