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 split_operations(
131 mut operations: Vec<proto::Operation>,
132) -> impl Iterator<Item = Vec<proto::Operation>> {
133 #[cfg(any(test, feature = "test-support"))]
134 const CHUNK_SIZE: usize = 5;
135
136 #[cfg(not(any(test, feature = "test-support")))]
137 const CHUNK_SIZE: usize = 100;
138
139 let mut done = false;
140 std::iter::from_fn(move || {
141 if done {
142 return None;
143 }
144
145 let operations = operations
146 .drain(..std::cmp::min(CHUNK_SIZE, operations.len()))
147 .collect::<Vec<_>>();
148 if operations.is_empty() {
149 done = true;
150 }
151 Some(operations)
152 })
153}
154
155pub fn serialize_selections(selections: &Arc<[Selection<Anchor>]>) -> Vec<proto::Selection> {
156 selections.iter().map(serialize_selection).collect()
157}
158
159pub fn serialize_selection(selection: &Selection<Anchor>) -> proto::Selection {
160 proto::Selection {
161 id: selection.id as u64,
162 start: Some(proto::EditorAnchor {
163 anchor: Some(serialize_anchor(&selection.start)),
164 excerpt_id: 0,
165 }),
166 end: Some(proto::EditorAnchor {
167 anchor: Some(serialize_anchor(&selection.end)),
168 excerpt_id: 0,
169 }),
170 reversed: selection.reversed,
171 }
172}
173
174pub fn serialize_cursor_shape(cursor_shape: &CursorShape) -> proto::CursorShape {
175 match cursor_shape {
176 CursorShape::Bar => proto::CursorShape::CursorBar,
177 CursorShape::Block => proto::CursorShape::CursorBlock,
178 CursorShape::Underscore => proto::CursorShape::CursorUnderscore,
179 CursorShape::Hollow => proto::CursorShape::CursorHollow,
180 }
181}
182
183pub fn deserialize_cursor_shape(cursor_shape: proto::CursorShape) -> CursorShape {
184 match cursor_shape {
185 proto::CursorShape::CursorBar => CursorShape::Bar,
186 proto::CursorShape::CursorBlock => CursorShape::Block,
187 proto::CursorShape::CursorUnderscore => CursorShape::Underscore,
188 proto::CursorShape::CursorHollow => CursorShape::Hollow,
189 }
190}
191
192pub fn serialize_diagnostics<'a>(
193 diagnostics: impl IntoIterator<Item = &'a DiagnosticEntry<Anchor>>,
194) -> Vec<proto::Diagnostic> {
195 diagnostics
196 .into_iter()
197 .map(|entry| proto::Diagnostic {
198 source: entry.diagnostic.source.clone(),
199 start: Some(serialize_anchor(&entry.range.start)),
200 end: Some(serialize_anchor(&entry.range.end)),
201 message: entry.diagnostic.message.clone(),
202 severity: match entry.diagnostic.severity {
203 DiagnosticSeverity::ERROR => proto::diagnostic::Severity::Error,
204 DiagnosticSeverity::WARNING => proto::diagnostic::Severity::Warning,
205 DiagnosticSeverity::INFORMATION => proto::diagnostic::Severity::Information,
206 DiagnosticSeverity::HINT => proto::diagnostic::Severity::Hint,
207 _ => proto::diagnostic::Severity::None,
208 } as i32,
209 group_id: entry.diagnostic.group_id as u64,
210 is_primary: entry.diagnostic.is_primary,
211 is_valid: entry.diagnostic.is_valid,
212 code: entry.diagnostic.code.clone(),
213 is_disk_based: entry.diagnostic.is_disk_based,
214 is_unnecessary: entry.diagnostic.is_unnecessary,
215 })
216 .collect()
217}
218
219pub fn serialize_anchor(anchor: &Anchor) -> proto::Anchor {
220 proto::Anchor {
221 replica_id: anchor.timestamp.replica_id as u32,
222 timestamp: anchor.timestamp.value,
223 offset: anchor.offset as u64,
224 bias: match anchor.bias {
225 Bias::Left => proto::Bias::Left as i32,
226 Bias::Right => proto::Bias::Right as i32,
227 },
228 buffer_id: anchor.buffer_id,
229 }
230}
231
232// This behavior is currently copied in the collab database, for snapshotting channel notes
233pub fn deserialize_operation(message: proto::Operation) -> Result<crate::Operation> {
234 Ok(
235 match message
236 .variant
237 .ok_or_else(|| anyhow!("missing operation variant"))?
238 {
239 proto::operation::Variant::Edit(edit) => {
240 crate::Operation::Buffer(text::Operation::Edit(deserialize_edit_operation(edit)))
241 }
242 proto::operation::Variant::Undo(undo) => {
243 crate::Operation::Buffer(text::Operation::Undo(UndoOperation {
244 timestamp: clock::Lamport {
245 replica_id: undo.replica_id as ReplicaId,
246 value: undo.lamport_timestamp,
247 },
248 version: deserialize_version(&undo.version),
249 counts: undo
250 .counts
251 .into_iter()
252 .map(|c| {
253 (
254 clock::Lamport {
255 replica_id: c.replica_id as ReplicaId,
256 value: c.lamport_timestamp,
257 },
258 c.count,
259 )
260 })
261 .collect(),
262 }))
263 }
264 proto::operation::Variant::UpdateSelections(message) => {
265 let selections = message
266 .selections
267 .into_iter()
268 .filter_map(|selection| {
269 Some(Selection {
270 id: selection.id as usize,
271 start: deserialize_anchor(selection.start?.anchor?)?,
272 end: deserialize_anchor(selection.end?.anchor?)?,
273 reversed: selection.reversed,
274 goal: SelectionGoal::None,
275 })
276 })
277 .collect::<Vec<_>>();
278
279 crate::Operation::UpdateSelections {
280 lamport_timestamp: clock::Lamport {
281 replica_id: message.replica_id as ReplicaId,
282 value: message.lamport_timestamp,
283 },
284 selections: Arc::from(selections),
285 line_mode: message.line_mode,
286 cursor_shape: deserialize_cursor_shape(
287 proto::CursorShape::from_i32(message.cursor_shape)
288 .ok_or_else(|| anyhow!("Missing cursor shape"))?,
289 ),
290 }
291 }
292 proto::operation::Variant::UpdateDiagnostics(message) => {
293 crate::Operation::UpdateDiagnostics {
294 lamport_timestamp: clock::Lamport {
295 replica_id: message.replica_id as ReplicaId,
296 value: message.lamport_timestamp,
297 },
298 server_id: LanguageServerId(message.server_id as usize),
299 diagnostics: deserialize_diagnostics(message.diagnostics),
300 }
301 }
302 proto::operation::Variant::UpdateCompletionTriggers(message) => {
303 crate::Operation::UpdateCompletionTriggers {
304 triggers: message.triggers,
305 lamport_timestamp: clock::Lamport {
306 replica_id: message.replica_id as ReplicaId,
307 value: message.lamport_timestamp,
308 },
309 }
310 }
311 },
312 )
313}
314
315pub fn deserialize_edit_operation(edit: proto::operation::Edit) -> EditOperation {
316 EditOperation {
317 timestamp: clock::Lamport {
318 replica_id: edit.replica_id as ReplicaId,
319 value: edit.lamport_timestamp,
320 },
321 version: deserialize_version(&edit.version),
322 ranges: edit.ranges.into_iter().map(deserialize_range).collect(),
323 new_text: edit.new_text.into_iter().map(Arc::from).collect(),
324 }
325}
326
327pub fn deserialize_undo_map_entry(
328 entry: proto::UndoMapEntry,
329) -> (clock::Lamport, Vec<(clock::Lamport, u32)>) {
330 (
331 clock::Lamport {
332 replica_id: entry.replica_id as u16,
333 value: entry.local_timestamp,
334 },
335 entry
336 .counts
337 .into_iter()
338 .map(|undo_count| {
339 (
340 clock::Lamport {
341 replica_id: undo_count.replica_id as u16,
342 value: undo_count.lamport_timestamp,
343 },
344 undo_count.count,
345 )
346 })
347 .collect(),
348 )
349}
350
351pub fn deserialize_selections(selections: Vec<proto::Selection>) -> Arc<[Selection<Anchor>]> {
352 Arc::from(
353 selections
354 .into_iter()
355 .filter_map(deserialize_selection)
356 .collect::<Vec<_>>(),
357 )
358}
359
360pub fn deserialize_selection(selection: proto::Selection) -> Option<Selection<Anchor>> {
361 Some(Selection {
362 id: selection.id as usize,
363 start: deserialize_anchor(selection.start?.anchor?)?,
364 end: deserialize_anchor(selection.end?.anchor?)?,
365 reversed: selection.reversed,
366 goal: SelectionGoal::None,
367 })
368}
369
370pub fn deserialize_diagnostics(
371 diagnostics: Vec<proto::Diagnostic>,
372) -> Arc<[DiagnosticEntry<Anchor>]> {
373 diagnostics
374 .into_iter()
375 .filter_map(|diagnostic| {
376 Some(DiagnosticEntry {
377 range: deserialize_anchor(diagnostic.start?)?..deserialize_anchor(diagnostic.end?)?,
378 diagnostic: Diagnostic {
379 source: diagnostic.source,
380 severity: match proto::diagnostic::Severity::from_i32(diagnostic.severity)? {
381 proto::diagnostic::Severity::Error => DiagnosticSeverity::ERROR,
382 proto::diagnostic::Severity::Warning => DiagnosticSeverity::WARNING,
383 proto::diagnostic::Severity::Information => DiagnosticSeverity::INFORMATION,
384 proto::diagnostic::Severity::Hint => DiagnosticSeverity::HINT,
385 proto::diagnostic::Severity::None => return None,
386 },
387 message: diagnostic.message,
388 group_id: diagnostic.group_id as usize,
389 code: diagnostic.code,
390 is_valid: diagnostic.is_valid,
391 is_primary: diagnostic.is_primary,
392 is_disk_based: diagnostic.is_disk_based,
393 is_unnecessary: diagnostic.is_unnecessary,
394 },
395 })
396 })
397 .collect()
398}
399
400pub fn deserialize_anchor(anchor: proto::Anchor) -> Option<Anchor> {
401 Some(Anchor {
402 timestamp: clock::Lamport {
403 replica_id: anchor.replica_id as ReplicaId,
404 value: anchor.timestamp,
405 },
406 offset: anchor.offset as usize,
407 bias: match proto::Bias::from_i32(anchor.bias)? {
408 proto::Bias::Left => Bias::Left,
409 proto::Bias::Right => Bias::Right,
410 },
411 buffer_id: anchor.buffer_id,
412 })
413}
414
415pub fn lamport_timestamp_for_operation(operation: &proto::Operation) -> Option<clock::Lamport> {
416 let replica_id;
417 let value;
418 match operation.variant.as_ref()? {
419 proto::operation::Variant::Edit(op) => {
420 replica_id = op.replica_id;
421 value = op.lamport_timestamp;
422 }
423 proto::operation::Variant::Undo(op) => {
424 replica_id = op.replica_id;
425 value = op.lamport_timestamp;
426 }
427 proto::operation::Variant::UpdateDiagnostics(op) => {
428 replica_id = op.replica_id;
429 value = op.lamport_timestamp;
430 }
431 proto::operation::Variant::UpdateSelections(op) => {
432 replica_id = op.replica_id;
433 value = op.lamport_timestamp;
434 }
435 proto::operation::Variant::UpdateCompletionTriggers(op) => {
436 replica_id = op.replica_id;
437 value = op.lamport_timestamp;
438 }
439 }
440
441 Some(clock::Lamport {
442 replica_id: replica_id as ReplicaId,
443 value,
444 })
445}
446
447pub fn serialize_completion(completion: &Completion) -> proto::Completion {
448 proto::Completion {
449 old_start: Some(serialize_anchor(&completion.old_range.start)),
450 old_end: Some(serialize_anchor(&completion.old_range.end)),
451 new_text: completion.new_text.clone(),
452 server_id: completion.server_id.0 as u64,
453 lsp_completion: serde_json::to_vec(&completion.lsp_completion).unwrap(),
454 }
455}
456
457pub async fn deserialize_completion(
458 completion: proto::Completion,
459 language: Option<Arc<Language>>,
460) -> Result<Completion> {
461 let old_start = completion
462 .old_start
463 .and_then(deserialize_anchor)
464 .ok_or_else(|| anyhow!("invalid old start"))?;
465 let old_end = completion
466 .old_end
467 .and_then(deserialize_anchor)
468 .ok_or_else(|| anyhow!("invalid old end"))?;
469 let lsp_completion = serde_json::from_slice(&completion.lsp_completion)?;
470
471 let mut label = None;
472 if let Some(language) = language {
473 label = language.label_for_completion(&lsp_completion).await;
474 }
475
476 Ok(Completion {
477 old_range: old_start..old_end,
478 new_text: completion.new_text,
479 label: label.unwrap_or_else(|| {
480 CodeLabel::plain(
481 lsp_completion.label.clone(),
482 lsp_completion.filter_text.as_deref(),
483 )
484 }),
485 server_id: LanguageServerId(completion.server_id as usize),
486 lsp_completion,
487 })
488}
489
490pub fn serialize_code_action(action: &CodeAction) -> proto::CodeAction {
491 proto::CodeAction {
492 server_id: action.server_id.0 as u64,
493 start: Some(serialize_anchor(&action.range.start)),
494 end: Some(serialize_anchor(&action.range.end)),
495 lsp_action: serde_json::to_vec(&action.lsp_action).unwrap(),
496 }
497}
498
499pub fn deserialize_code_action(action: proto::CodeAction) -> Result<CodeAction> {
500 let start = action
501 .start
502 .and_then(deserialize_anchor)
503 .ok_or_else(|| anyhow!("invalid start"))?;
504 let end = action
505 .end
506 .and_then(deserialize_anchor)
507 .ok_or_else(|| anyhow!("invalid end"))?;
508 let lsp_action = serde_json::from_slice(&action.lsp_action)?;
509 Ok(CodeAction {
510 server_id: LanguageServerId(action.server_id as usize),
511 range: start..end,
512 lsp_action,
513 })
514}
515
516pub fn serialize_transaction(transaction: &Transaction) -> proto::Transaction {
517 proto::Transaction {
518 id: Some(serialize_timestamp(transaction.id)),
519 edit_ids: transaction
520 .edit_ids
521 .iter()
522 .copied()
523 .map(serialize_timestamp)
524 .collect(),
525 start: serialize_version(&transaction.start),
526 }
527}
528
529pub fn deserialize_transaction(transaction: proto::Transaction) -> Result<Transaction> {
530 Ok(Transaction {
531 id: deserialize_timestamp(
532 transaction
533 .id
534 .ok_or_else(|| anyhow!("missing transaction id"))?,
535 ),
536 edit_ids: transaction
537 .edit_ids
538 .into_iter()
539 .map(deserialize_timestamp)
540 .collect(),
541 start: deserialize_version(&transaction.start),
542 })
543}
544
545pub fn serialize_timestamp(timestamp: clock::Lamport) -> proto::LamportTimestamp {
546 proto::LamportTimestamp {
547 replica_id: timestamp.replica_id as u32,
548 value: timestamp.value,
549 }
550}
551
552pub fn deserialize_timestamp(timestamp: proto::LamportTimestamp) -> clock::Lamport {
553 clock::Lamport {
554 replica_id: timestamp.replica_id as ReplicaId,
555 value: timestamp.value,
556 }
557}
558
559pub fn serialize_range(range: &Range<FullOffset>) -> proto::Range {
560 proto::Range {
561 start: range.start.0 as u64,
562 end: range.end.0 as u64,
563 }
564}
565
566pub fn deserialize_range(range: proto::Range) -> Range<FullOffset> {
567 FullOffset(range.start as usize)..FullOffset(range.end as usize)
568}
569
570pub fn deserialize_version(message: &[proto::VectorClockEntry]) -> clock::Global {
571 let mut version = clock::Global::new();
572 for entry in message {
573 version.observe(clock::Lamport {
574 replica_id: entry.replica_id as ReplicaId,
575 value: entry.timestamp,
576 });
577 }
578 version
579}
580
581pub fn serialize_version(version: &clock::Global) -> Vec<proto::VectorClockEntry> {
582 version
583 .iter()
584 .map(|entry| proto::VectorClockEntry {
585 replica_id: entry.replica_id as u32,
586 timestamp: entry.value,
587 })
588 .collect()
589}