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