1pub use crate::{
2 diagnostic_set::DiagnosticSet,
3 highlight_map::{HighlightId, HighlightMap},
4 proto, BracketPair, Grammar, Language, LanguageConfig, LanguageRegistry, PLAIN_TEXT,
5};
6use crate::{
7 diagnostic_set::{DiagnosticEntry, DiagnosticGroup},
8 outline::OutlineItem,
9 CodeLabel, Outline,
10};
11use anyhow::{anyhow, Result};
12use clock::ReplicaId;
13use futures::FutureExt as _;
14use gpui::{fonts::HighlightStyle, AppContext, Entity, ModelContext, MutableAppContext, Task};
15use lazy_static::lazy_static;
16use parking_lot::Mutex;
17use similar::{ChangeTag, TextDiff};
18use smol::future::yield_now;
19use std::{
20 any::Any,
21 cmp::{self, Ordering},
22 collections::{BTreeMap, HashMap},
23 ffi::OsString,
24 future::Future,
25 iter::{self, Iterator, Peekable},
26 mem,
27 ops::{Deref, DerefMut, Range},
28 path::{Path, PathBuf},
29 str,
30 sync::Arc,
31 time::{Duration, Instant, SystemTime, UNIX_EPOCH},
32 vec,
33};
34use sum_tree::TreeMap;
35use text::operation_queue::OperationQueue;
36pub use text::{Buffer as TextBuffer, BufferSnapshot as TextBufferSnapshot, Operation as _, *};
37use theme::SyntaxTheme;
38use tree_sitter::{InputEdit, QueryCursor, Tree};
39use util::TryFutureExt as _;
40
41#[cfg(any(test, feature = "test-support"))]
42pub use {tree_sitter_rust, tree_sitter_typescript};
43
44pub use lsp::DiagnosticSeverity;
45
46lazy_static! {
47 static ref QUERY_CURSORS: Mutex<Vec<QueryCursor>> = Default::default();
48}
49
50pub struct Buffer {
51 text: TextBuffer,
52 file: Option<Arc<dyn File>>,
53 saved_version: clock::Global,
54 saved_version_fingerprint: String,
55 saved_mtime: SystemTime,
56 newline_style: NewlineStyle,
57 transaction_depth: usize,
58 was_dirty_before_starting_transaction: Option<bool>,
59 language: Option<Arc<Language>>,
60 autoindent_requests: Vec<Arc<AutoindentRequest>>,
61 pending_autoindent: Option<Task<()>>,
62 sync_parse_timeout: Duration,
63 syntax_tree: Mutex<Option<SyntaxTree>>,
64 parsing_in_background: bool,
65 parse_count: usize,
66 diagnostics: DiagnosticSet,
67 remote_selections: TreeMap<ReplicaId, SelectionSet>,
68 selections_update_count: usize,
69 diagnostics_update_count: usize,
70 diagnostics_timestamp: clock::Lamport,
71 file_update_count: usize,
72 completion_triggers: Vec<String>,
73 deferred_ops: OperationQueue<Operation>,
74}
75
76pub struct BufferSnapshot {
77 text: text::BufferSnapshot,
78 tree: Option<Tree>,
79 file: Option<Arc<dyn File>>,
80 diagnostics: DiagnosticSet,
81 diagnostics_update_count: usize,
82 file_update_count: usize,
83 remote_selections: TreeMap<ReplicaId, SelectionSet>,
84 selections_update_count: usize,
85 language: Option<Arc<Language>>,
86 parse_count: usize,
87}
88
89#[derive(Clone, Copy, Debug, PartialEq, Eq)]
90pub struct IndentSize {
91 pub len: u32,
92 pub kind: IndentKind,
93}
94
95#[derive(Clone, Copy, Debug, PartialEq, Eq)]
96pub enum IndentKind {
97 Space,
98 Tab,
99}
100
101#[derive(Copy, Clone, PartialEq, Eq)]
102pub enum NewlineStyle {
103 Unix,
104 Windows,
105}
106
107#[derive(Clone, Debug)]
108struct SelectionSet {
109 line_mode: bool,
110 selections: Arc<[Selection<Anchor>]>,
111 lamport_timestamp: clock::Lamport,
112}
113
114#[derive(Clone, Debug, PartialEq, Eq)]
115pub struct GroupId {
116 source: Arc<str>,
117 id: usize,
118}
119
120#[derive(Clone, Debug, PartialEq, Eq)]
121pub struct Diagnostic {
122 pub code: Option<String>,
123 pub severity: DiagnosticSeverity,
124 pub message: String,
125 pub group_id: usize,
126 pub is_valid: bool,
127 pub is_primary: bool,
128 pub is_disk_based: bool,
129 pub is_unnecessary: bool,
130}
131
132#[derive(Clone, Debug)]
133pub struct Completion {
134 pub old_range: Range<Anchor>,
135 pub new_text: String,
136 pub label: CodeLabel,
137 pub lsp_completion: lsp::CompletionItem,
138}
139
140#[derive(Clone, Debug)]
141pub struct CodeAction {
142 pub range: Range<Anchor>,
143 pub lsp_action: lsp::CodeAction,
144}
145
146#[derive(Clone, Debug, PartialEq, Eq)]
147pub enum Operation {
148 Buffer(text::Operation),
149 UpdateDiagnostics {
150 diagnostics: Arc<[DiagnosticEntry<Anchor>]>,
151 lamport_timestamp: clock::Lamport,
152 },
153 UpdateSelections {
154 selections: Arc<[Selection<Anchor>]>,
155 lamport_timestamp: clock::Lamport,
156 line_mode: bool,
157 },
158 UpdateCompletionTriggers {
159 triggers: Vec<String>,
160 lamport_timestamp: clock::Lamport,
161 },
162}
163
164#[derive(Clone, Debug, PartialEq, Eq)]
165pub enum Event {
166 Operation(Operation),
167 Edited,
168 DirtyChanged,
169 Saved,
170 FileHandleChanged,
171 Reloaded,
172 Reparsed,
173 DiagnosticsUpdated,
174 Closed,
175}
176
177pub trait File: Send + Sync {
178 fn as_local(&self) -> Option<&dyn LocalFile>;
179
180 fn is_local(&self) -> bool {
181 self.as_local().is_some()
182 }
183
184 fn mtime(&self) -> SystemTime;
185
186 /// Returns the path of this file relative to the worktree's root directory.
187 fn path(&self) -> &Arc<Path>;
188
189 /// Returns the path of this file relative to the worktree's parent directory (this means it
190 /// includes the name of the worktree's root folder).
191 fn full_path(&self, cx: &AppContext) -> PathBuf;
192
193 /// Returns the last component of this handle's absolute path. If this handle refers to the root
194 /// of its worktree, then this method will return the name of the worktree itself.
195 fn file_name(&self, cx: &AppContext) -> OsString;
196
197 fn is_deleted(&self) -> bool;
198
199 fn save(
200 &self,
201 buffer_id: u64,
202 text: Rope,
203 version: clock::Global,
204 newline_style: NewlineStyle,
205 cx: &mut MutableAppContext,
206 ) -> Task<Result<(clock::Global, String, SystemTime)>>;
207
208 fn as_any(&self) -> &dyn Any;
209
210 fn to_proto(&self) -> rpc::proto::File;
211}
212
213pub trait LocalFile: File {
214 /// Returns the absolute path of this file.
215 fn abs_path(&self, cx: &AppContext) -> PathBuf;
216
217 fn load(&self, cx: &AppContext) -> Task<Result<String>>;
218
219 fn buffer_reloaded(
220 &self,
221 buffer_id: u64,
222 version: &clock::Global,
223 fingerprint: String,
224 mtime: SystemTime,
225 cx: &mut MutableAppContext,
226 );
227}
228
229pub(crate) struct QueryCursorHandle(Option<QueryCursor>);
230
231#[derive(Clone)]
232struct SyntaxTree {
233 tree: Tree,
234 version: clock::Global,
235}
236
237#[derive(Clone)]
238struct AutoindentRequest {
239 before_edit: BufferSnapshot,
240 edited: Vec<Anchor>,
241 inserted: Option<Vec<Range<Anchor>>>,
242 indent_size: IndentSize,
243}
244
245#[derive(Debug)]
246struct IndentSuggestion {
247 basis_row: u32,
248 delta: Ordering,
249}
250
251pub(crate) struct TextProvider<'a>(pub(crate) &'a Rope);
252
253struct BufferChunkHighlights<'a> {
254 captures: tree_sitter::QueryCaptures<'a, 'a, TextProvider<'a>>,
255 next_capture: Option<(tree_sitter::QueryMatch<'a, 'a>, usize)>,
256 stack: Vec<(usize, HighlightId)>,
257 highlight_map: HighlightMap,
258 _query_cursor: QueryCursorHandle,
259}
260
261pub struct BufferChunks<'a> {
262 range: Range<usize>,
263 chunks: rope::Chunks<'a>,
264 diagnostic_endpoints: Peekable<vec::IntoIter<DiagnosticEndpoint>>,
265 error_depth: usize,
266 warning_depth: usize,
267 information_depth: usize,
268 hint_depth: usize,
269 unnecessary_depth: usize,
270 highlights: Option<BufferChunkHighlights<'a>>,
271}
272
273#[derive(Clone, Copy, Debug, Default)]
274pub struct Chunk<'a> {
275 pub text: &'a str,
276 pub syntax_highlight_id: Option<HighlightId>,
277 pub highlight_style: Option<HighlightStyle>,
278 pub diagnostic_severity: Option<DiagnosticSeverity>,
279 pub is_unnecessary: bool,
280}
281
282pub(crate) struct Diff {
283 base_version: clock::Global,
284 new_text: Arc<str>,
285 changes: Vec<(ChangeTag, usize)>,
286 start_offset: usize,
287}
288
289#[derive(Clone, Copy)]
290pub(crate) struct DiagnosticEndpoint {
291 offset: usize,
292 is_start: bool,
293 severity: DiagnosticSeverity,
294 is_unnecessary: bool,
295}
296
297#[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Debug)]
298pub enum CharKind {
299 Punctuation,
300 Whitespace,
301 Word,
302}
303
304impl CharKind {
305 pub fn coerce_punctuation(self, treat_punctuation_as_word: bool) -> Self {
306 if treat_punctuation_as_word && self == CharKind::Punctuation {
307 CharKind::Word
308 } else {
309 self
310 }
311 }
312}
313
314impl Buffer {
315 pub fn new<T: Into<Arc<str>>>(
316 replica_id: ReplicaId,
317 base_text: T,
318 cx: &mut ModelContext<Self>,
319 ) -> Self {
320 let history = History::new(base_text.into());
321 let newline_style = NewlineStyle::detect(&history.base_text);
322 Self::build(
323 TextBuffer::new(replica_id, cx.model_id() as u64, history),
324 None,
325 newline_style,
326 )
327 }
328
329 pub fn from_file<T: Into<Arc<str>>>(
330 replica_id: ReplicaId,
331 base_text: T,
332 file: Arc<dyn File>,
333 cx: &mut ModelContext<Self>,
334 ) -> Self {
335 let history = History::new(base_text.into());
336 let newline_style = NewlineStyle::detect(&history.base_text);
337 Self::build(
338 TextBuffer::new(replica_id, cx.model_id() as u64, history),
339 Some(file),
340 newline_style,
341 )
342 }
343
344 pub fn from_proto(
345 replica_id: ReplicaId,
346 message: proto::BufferState,
347 file: Option<Arc<dyn File>>,
348 cx: &mut ModelContext<Self>,
349 ) -> Result<Self> {
350 let buffer = TextBuffer::new(
351 replica_id,
352 message.id,
353 History::new(Arc::from(message.base_text)),
354 );
355 let newline_style = proto::NewlineStyle::from_i32(message.newline_style)
356 .ok_or_else(|| anyhow!("missing newline_style"))?;
357 let mut this = Self::build(buffer, file, NewlineStyle::from_proto(newline_style));
358 let ops = message
359 .operations
360 .into_iter()
361 .map(proto::deserialize_operation)
362 .collect::<Result<Vec<_>>>()?;
363 this.apply_ops(ops, cx)?;
364
365 for selection_set in message.selections {
366 let lamport_timestamp = clock::Lamport {
367 replica_id: selection_set.replica_id as ReplicaId,
368 value: selection_set.lamport_timestamp,
369 };
370 this.remote_selections.insert(
371 selection_set.replica_id as ReplicaId,
372 SelectionSet {
373 line_mode: selection_set.line_mode,
374 selections: proto::deserialize_selections(selection_set.selections),
375 lamport_timestamp,
376 },
377 );
378 this.text.lamport_clock.observe(lamport_timestamp);
379 }
380 let snapshot = this.snapshot();
381 let entries = proto::deserialize_diagnostics(message.diagnostics);
382 this.apply_diagnostic_update(
383 DiagnosticSet::from_sorted_entries(entries.iter().cloned(), &snapshot),
384 clock::Lamport {
385 replica_id: 0,
386 value: message.diagnostics_timestamp,
387 },
388 cx,
389 );
390
391 this.completion_triggers = message.completion_triggers;
392
393 Ok(this)
394 }
395
396 pub fn to_proto(&self) -> proto::BufferState {
397 let mut operations = self
398 .text
399 .history()
400 .map(|op| proto::serialize_operation(&Operation::Buffer(op.clone())))
401 .chain(self.deferred_ops.iter().map(proto::serialize_operation))
402 .collect::<Vec<_>>();
403 operations.sort_unstable_by_key(proto::lamport_timestamp_for_operation);
404 proto::BufferState {
405 id: self.remote_id(),
406 file: self.file.as_ref().map(|f| f.to_proto()),
407 base_text: self.base_text().to_string(),
408 operations,
409 selections: self
410 .remote_selections
411 .iter()
412 .map(|(replica_id, set)| proto::SelectionSet {
413 replica_id: *replica_id as u32,
414 selections: proto::serialize_selections(&set.selections),
415 lamport_timestamp: set.lamport_timestamp.value,
416 line_mode: set.line_mode,
417 })
418 .collect(),
419 diagnostics: proto::serialize_diagnostics(self.diagnostics.iter()),
420 diagnostics_timestamp: self.diagnostics_timestamp.value,
421 completion_triggers: self.completion_triggers.clone(),
422 newline_style: self.newline_style.to_proto() as i32,
423 }
424 }
425
426 pub fn with_language(mut self, language: Arc<Language>, cx: &mut ModelContext<Self>) -> Self {
427 self.set_language(Some(language), cx);
428 self
429 }
430
431 fn build(buffer: TextBuffer, file: Option<Arc<dyn File>>, newline_style: NewlineStyle) -> Self {
432 let saved_mtime;
433 if let Some(file) = file.as_ref() {
434 saved_mtime = file.mtime();
435 } else {
436 saved_mtime = UNIX_EPOCH;
437 }
438
439 Self {
440 saved_mtime,
441 saved_version: buffer.version(),
442 saved_version_fingerprint: buffer.as_rope().fingerprint(),
443 transaction_depth: 0,
444 was_dirty_before_starting_transaction: None,
445 text: buffer,
446 file,
447 newline_style,
448 syntax_tree: Mutex::new(None),
449 parsing_in_background: false,
450 parse_count: 0,
451 sync_parse_timeout: Duration::from_millis(1),
452 autoindent_requests: Default::default(),
453 pending_autoindent: Default::default(),
454 language: None,
455 remote_selections: Default::default(),
456 selections_update_count: 0,
457 diagnostics: Default::default(),
458 diagnostics_update_count: 0,
459 diagnostics_timestamp: Default::default(),
460 file_update_count: 0,
461 completion_triggers: Default::default(),
462 deferred_ops: OperationQueue::new(),
463 }
464 }
465
466 pub fn snapshot(&self) -> BufferSnapshot {
467 BufferSnapshot {
468 text: self.text.snapshot(),
469 tree: self.syntax_tree(),
470 file: self.file.clone(),
471 remote_selections: self.remote_selections.clone(),
472 diagnostics: self.diagnostics.clone(),
473 diagnostics_update_count: self.diagnostics_update_count,
474 file_update_count: self.file_update_count,
475 language: self.language.clone(),
476 parse_count: self.parse_count,
477 selections_update_count: self.selections_update_count,
478 }
479 }
480
481 pub fn as_text_snapshot(&self) -> &text::BufferSnapshot {
482 &self.text
483 }
484
485 pub fn text_snapshot(&self) -> text::BufferSnapshot {
486 self.text.snapshot()
487 }
488
489 pub fn file(&self) -> Option<&dyn File> {
490 self.file.as_deref()
491 }
492
493 pub fn save(
494 &mut self,
495 cx: &mut ModelContext<Self>,
496 ) -> Task<Result<(clock::Global, String, SystemTime)>> {
497 let file = if let Some(file) = self.file.as_ref() {
498 file
499 } else {
500 return Task::ready(Err(anyhow!("buffer has no file")));
501 };
502 let text = self.as_rope().clone();
503 let version = self.version();
504 let save = file.save(
505 self.remote_id(),
506 text,
507 version,
508 self.newline_style,
509 cx.as_mut(),
510 );
511 cx.spawn(|this, mut cx| async move {
512 let (version, fingerprint, mtime) = save.await?;
513 this.update(&mut cx, |this, cx| {
514 this.did_save(version.clone(), fingerprint.clone(), mtime, None, cx);
515 });
516 Ok((version, fingerprint, mtime))
517 })
518 }
519
520 pub fn saved_version(&self) -> &clock::Global {
521 &self.saved_version
522 }
523
524 pub fn set_language(&mut self, language: Option<Arc<Language>>, cx: &mut ModelContext<Self>) {
525 *self.syntax_tree.lock() = None;
526 self.language = language;
527 self.reparse(cx);
528 }
529
530 pub fn did_save(
531 &mut self,
532 version: clock::Global,
533 fingerprint: String,
534 mtime: SystemTime,
535 new_file: Option<Arc<dyn File>>,
536 cx: &mut ModelContext<Self>,
537 ) {
538 self.saved_version = version;
539 self.saved_version_fingerprint = fingerprint;
540 self.saved_mtime = mtime;
541 if let Some(new_file) = new_file {
542 self.file = Some(new_file);
543 self.file_update_count += 1;
544 }
545 cx.emit(Event::Saved);
546 cx.notify();
547 }
548
549 pub fn reload(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<Option<Transaction>>> {
550 cx.spawn(|this, mut cx| async move {
551 if let Some((new_mtime, new_text)) = this.read_with(&cx, |this, cx| {
552 let file = this.file.as_ref()?.as_local()?;
553 Some((file.mtime(), file.load(cx)))
554 }) {
555 let new_text = new_text.await?;
556 let diff = this
557 .read_with(&cx, |this, cx| this.diff(new_text, cx))
558 .await;
559 this.update(&mut cx, |this, cx| {
560 if let Some(transaction) = this.apply_diff(diff, cx).cloned() {
561 this.did_reload(
562 this.version(),
563 this.as_rope().fingerprint(),
564 new_mtime,
565 cx,
566 );
567 Ok(Some(transaction))
568 } else {
569 Ok(None)
570 }
571 })
572 } else {
573 Ok(None)
574 }
575 })
576 }
577
578 pub fn did_reload(
579 &mut self,
580 version: clock::Global,
581 fingerprint: String,
582 mtime: SystemTime,
583 cx: &mut ModelContext<Self>,
584 ) {
585 self.saved_version = version;
586 self.saved_version_fingerprint = fingerprint;
587 self.saved_mtime = mtime;
588 if let Some(file) = self.file.as_ref().and_then(|f| f.as_local()) {
589 file.buffer_reloaded(
590 self.remote_id(),
591 &self.saved_version,
592 self.saved_version_fingerprint.clone(),
593 self.saved_mtime,
594 cx,
595 );
596 }
597 cx.emit(Event::Reloaded);
598 cx.notify();
599 }
600
601 pub fn file_updated(
602 &mut self,
603 new_file: Arc<dyn File>,
604 cx: &mut ModelContext<Self>,
605 ) -> Task<()> {
606 let old_file = if let Some(file) = self.file.as_ref() {
607 file
608 } else {
609 return Task::ready(());
610 };
611 let mut file_changed = false;
612 let mut task = Task::ready(());
613
614 if new_file.path() != old_file.path() {
615 file_changed = true;
616 }
617
618 if new_file.is_deleted() {
619 if !old_file.is_deleted() {
620 file_changed = true;
621 if !self.is_dirty() {
622 cx.emit(Event::DirtyChanged);
623 }
624 }
625 } else {
626 let new_mtime = new_file.mtime();
627 if new_mtime != old_file.mtime() {
628 file_changed = true;
629
630 if !self.is_dirty() {
631 let reload = self.reload(cx).log_err().map(drop);
632 task = cx.foreground().spawn(reload);
633 }
634 }
635 }
636
637 if file_changed {
638 self.file_update_count += 1;
639 cx.emit(Event::FileHandleChanged);
640 cx.notify();
641 }
642 self.file = Some(new_file);
643 task
644 }
645
646 pub fn close(&mut self, cx: &mut ModelContext<Self>) {
647 cx.emit(Event::Closed);
648 }
649
650 pub fn language(&self) -> Option<&Arc<Language>> {
651 self.language.as_ref()
652 }
653
654 pub fn parse_count(&self) -> usize {
655 self.parse_count
656 }
657
658 pub fn selections_update_count(&self) -> usize {
659 self.selections_update_count
660 }
661
662 pub fn diagnostics_update_count(&self) -> usize {
663 self.diagnostics_update_count
664 }
665
666 pub fn file_update_count(&self) -> usize {
667 self.file_update_count
668 }
669
670 pub(crate) fn syntax_tree(&self) -> Option<Tree> {
671 if let Some(syntax_tree) = self.syntax_tree.lock().as_mut() {
672 self.interpolate_tree(syntax_tree);
673 Some(syntax_tree.tree.clone())
674 } else {
675 None
676 }
677 }
678
679 #[cfg(any(test, feature = "test-support"))]
680 pub fn is_parsing(&self) -> bool {
681 self.parsing_in_background
682 }
683
684 #[cfg(test)]
685 pub fn set_sync_parse_timeout(&mut self, timeout: Duration) {
686 self.sync_parse_timeout = timeout;
687 }
688
689 fn reparse(&mut self, cx: &mut ModelContext<Self>) -> bool {
690 if self.parsing_in_background {
691 return false;
692 }
693
694 if let Some(grammar) = self.grammar().cloned() {
695 let old_tree = self.syntax_tree();
696 let text = self.as_rope().clone();
697 let parsed_version = self.version();
698 let parse_task = cx.background().spawn({
699 let grammar = grammar.clone();
700 async move { grammar.parse_text(&text, old_tree) }
701 });
702
703 match cx
704 .background()
705 .block_with_timeout(self.sync_parse_timeout, parse_task)
706 {
707 Ok(new_tree) => {
708 self.did_finish_parsing(new_tree, parsed_version, cx);
709 return true;
710 }
711 Err(parse_task) => {
712 self.parsing_in_background = true;
713 cx.spawn(move |this, mut cx| async move {
714 let new_tree = parse_task.await;
715 this.update(&mut cx, move |this, cx| {
716 let grammar_changed = this
717 .grammar()
718 .map_or(true, |curr_grammar| !Arc::ptr_eq(&grammar, curr_grammar));
719 let parse_again =
720 this.version.changed_since(&parsed_version) || grammar_changed;
721 this.parsing_in_background = false;
722 this.did_finish_parsing(new_tree, parsed_version, cx);
723
724 if parse_again && this.reparse(cx) {
725 return;
726 }
727 });
728 })
729 .detach();
730 }
731 }
732 }
733 false
734 }
735
736 fn interpolate_tree(&self, tree: &mut SyntaxTree) {
737 for edit in self.edits_since::<(usize, Point)>(&tree.version) {
738 let (bytes, lines) = edit.flatten();
739 tree.tree.edit(&InputEdit {
740 start_byte: bytes.new.start,
741 old_end_byte: bytes.new.start + bytes.old.len(),
742 new_end_byte: bytes.new.end,
743 start_position: lines.new.start.to_ts_point(),
744 old_end_position: (lines.new.start + (lines.old.end - lines.old.start))
745 .to_ts_point(),
746 new_end_position: lines.new.end.to_ts_point(),
747 });
748 }
749 tree.version = self.version();
750 }
751
752 fn did_finish_parsing(
753 &mut self,
754 tree: Tree,
755 version: clock::Global,
756 cx: &mut ModelContext<Self>,
757 ) {
758 self.parse_count += 1;
759 *self.syntax_tree.lock() = Some(SyntaxTree { tree, version });
760 self.request_autoindent(cx);
761 cx.emit(Event::Reparsed);
762 cx.notify();
763 }
764
765 pub fn update_diagnostics(&mut self, diagnostics: DiagnosticSet, cx: &mut ModelContext<Self>) {
766 let lamport_timestamp = self.text.lamport_clock.tick();
767 let op = Operation::UpdateDiagnostics {
768 diagnostics: diagnostics.iter().cloned().collect(),
769 lamport_timestamp,
770 };
771 self.apply_diagnostic_update(diagnostics, lamport_timestamp, cx);
772 self.send_operation(op, cx);
773 }
774
775 fn request_autoindent(&mut self, cx: &mut ModelContext<Self>) {
776 if let Some(indent_sizes) = self.compute_autoindents() {
777 let indent_sizes = cx.background().spawn(indent_sizes);
778 match cx
779 .background()
780 .block_with_timeout(Duration::from_micros(500), indent_sizes)
781 {
782 Ok(indent_sizes) => self.apply_autoindents(indent_sizes, cx),
783 Err(indent_sizes) => {
784 self.pending_autoindent = Some(cx.spawn(|this, mut cx| async move {
785 let indent_sizes = indent_sizes.await;
786 this.update(&mut cx, |this, cx| {
787 this.apply_autoindents(indent_sizes, cx);
788 });
789 }));
790 }
791 }
792 }
793 }
794
795 fn compute_autoindents(&self) -> Option<impl Future<Output = BTreeMap<u32, IndentSize>>> {
796 let max_rows_between_yields = 100;
797 let snapshot = self.snapshot();
798 if snapshot.language.is_none()
799 || snapshot.tree.is_none()
800 || self.autoindent_requests.is_empty()
801 {
802 return None;
803 }
804
805 let autoindent_requests = self.autoindent_requests.clone();
806 Some(async move {
807 let mut indent_sizes = BTreeMap::new();
808 for request in autoindent_requests {
809 let old_to_new_rows = request
810 .edited
811 .iter()
812 .map(|anchor| anchor.summary::<Point>(&request.before_edit).row)
813 .zip(
814 request
815 .edited
816 .iter()
817 .map(|anchor| anchor.summary::<Point>(&snapshot).row),
818 )
819 .collect::<BTreeMap<u32, u32>>();
820
821 let mut old_suggestions = HashMap::<u32, IndentSize>::default();
822 let old_edited_ranges =
823 contiguous_ranges(old_to_new_rows.keys().copied(), max_rows_between_yields);
824 for old_edited_range in old_edited_ranges {
825 let suggestions = request
826 .before_edit
827 .suggest_autoindents(old_edited_range.clone())
828 .into_iter()
829 .flatten();
830 for (old_row, suggestion) in old_edited_range.zip(suggestions) {
831 if let Some(suggestion) = suggestion {
832 let mut suggested_indent = old_to_new_rows
833 .get(&suggestion.basis_row)
834 .and_then(|from_row| old_suggestions.get(from_row).copied())
835 .unwrap_or_else(|| {
836 request
837 .before_edit
838 .indent_size_for_line(suggestion.basis_row)
839 });
840 if suggestion.delta.is_gt() {
841 suggested_indent += request.indent_size;
842 } else if suggestion.delta.is_lt() {
843 suggested_indent -= request.indent_size;
844 }
845 old_suggestions
846 .insert(*old_to_new_rows.get(&old_row).unwrap(), suggested_indent);
847 }
848 }
849 yield_now().await;
850 }
851
852 // At this point, old_suggestions contains the suggested indentation for all edited lines with respect to the state of the
853 // buffer before the edit, but keyed by the row for these lines after the edits were applied.
854 let new_edited_row_ranges =
855 contiguous_ranges(old_to_new_rows.values().copied(), max_rows_between_yields);
856 for new_edited_row_range in new_edited_row_ranges {
857 let suggestions = snapshot
858 .suggest_autoindents(new_edited_row_range.clone())
859 .into_iter()
860 .flatten();
861 for (new_row, suggestion) in new_edited_row_range.zip(suggestions) {
862 if let Some(suggestion) = suggestion {
863 let mut suggested_indent = indent_sizes
864 .get(&suggestion.basis_row)
865 .copied()
866 .unwrap_or_else(|| {
867 snapshot.indent_size_for_line(suggestion.basis_row)
868 });
869 if suggestion.delta.is_gt() {
870 suggested_indent += request.indent_size;
871 } else if suggestion.delta.is_lt() {
872 suggested_indent -= request.indent_size;
873 }
874 if old_suggestions
875 .get(&new_row)
876 .map_or(true, |old_indentation| {
877 suggested_indent != *old_indentation
878 })
879 {
880 indent_sizes.insert(new_row, suggested_indent);
881 }
882 }
883 }
884 yield_now().await;
885 }
886
887 if let Some(inserted) = request.inserted.as_ref() {
888 let inserted_row_ranges = contiguous_ranges(
889 inserted
890 .iter()
891 .map(|range| range.to_point(&snapshot))
892 .flat_map(|range| range.start.row..range.end.row + 1),
893 max_rows_between_yields,
894 );
895 for inserted_row_range in inserted_row_ranges {
896 let suggestions = snapshot
897 .suggest_autoindents(inserted_row_range.clone())
898 .into_iter()
899 .flatten();
900 for (row, suggestion) in inserted_row_range.zip(suggestions) {
901 if let Some(suggestion) = suggestion {
902 let mut suggested_indent = indent_sizes
903 .get(&suggestion.basis_row)
904 .copied()
905 .unwrap_or_else(|| {
906 snapshot.indent_size_for_line(suggestion.basis_row)
907 });
908 if suggestion.delta.is_gt() {
909 suggested_indent += request.indent_size;
910 } else if suggestion.delta.is_lt() {
911 suggested_indent -= request.indent_size;
912 }
913 indent_sizes.insert(row, suggested_indent);
914 }
915 }
916 yield_now().await;
917 }
918 }
919 }
920
921 indent_sizes
922 })
923 }
924
925 fn apply_autoindents(
926 &mut self,
927 indent_sizes: BTreeMap<u32, IndentSize>,
928 cx: &mut ModelContext<Self>,
929 ) {
930 self.autoindent_requests.clear();
931 self.start_transaction();
932 for (row, indent_size) in &indent_sizes {
933 self.set_indent_size_for_line(*row, *indent_size, cx);
934 }
935 self.end_transaction(cx);
936 }
937
938 fn set_indent_size_for_line(
939 &mut self,
940 row: u32,
941 size: IndentSize,
942 cx: &mut ModelContext<Self>,
943 ) {
944 let current_size = indent_size_for_line(&self, row);
945 if size.kind != current_size.kind && current_size.len > 0 {
946 return;
947 }
948
949 if size.len > current_size.len {
950 let offset = Point::new(row, 0).to_offset(&*self);
951 self.edit(
952 [(
953 offset..offset,
954 iter::repeat(size.char())
955 .take((size.len - current_size.len) as usize)
956 .collect::<String>(),
957 )],
958 cx,
959 );
960 } else if size.len < current_size.len {
961 self.edit(
962 [(
963 Point::new(row, 0)..Point::new(row, current_size.len - size.len),
964 "",
965 )],
966 cx,
967 );
968 }
969 }
970
971 pub(crate) fn diff(&self, new_text: String, cx: &AppContext) -> Task<Diff> {
972 let old_text = self.as_rope().clone();
973 let base_version = self.version();
974 cx.background().spawn(async move {
975 let old_text = old_text.to_string();
976 let new_text = new_text.replace("\r\n", "\n").replace('\r', "\n");
977 let changes = TextDiff::from_lines(old_text.as_str(), new_text.as_str())
978 .iter_all_changes()
979 .map(|c| (c.tag(), c.value().len()))
980 .collect::<Vec<_>>();
981 Diff {
982 base_version,
983 new_text: new_text.into(),
984 changes,
985 start_offset: 0,
986 }
987 })
988 }
989
990 pub(crate) fn apply_diff(
991 &mut self,
992 diff: Diff,
993 cx: &mut ModelContext<Self>,
994 ) -> Option<&Transaction> {
995 if self.version == diff.base_version {
996 self.finalize_last_transaction();
997 self.start_transaction();
998 let mut offset = diff.start_offset;
999 for (tag, len) in diff.changes {
1000 let range = offset..(offset + len);
1001 match tag {
1002 ChangeTag::Equal => offset += len,
1003 ChangeTag::Delete => {
1004 self.edit([(range, "")], cx);
1005 }
1006 ChangeTag::Insert => {
1007 self.edit(
1008 [(
1009 offset..offset,
1010 &diff.new_text[range.start - diff.start_offset
1011 ..range.end - diff.start_offset],
1012 )],
1013 cx,
1014 );
1015 offset += len;
1016 }
1017 }
1018 }
1019 if self.end_transaction(cx).is_some() {
1020 self.finalize_last_transaction()
1021 } else {
1022 None
1023 }
1024 } else {
1025 None
1026 }
1027 }
1028
1029 pub fn is_dirty(&self) -> bool {
1030 self.saved_version_fingerprint != self.as_rope().fingerprint()
1031 || self.file.as_ref().map_or(false, |file| file.is_deleted())
1032 }
1033
1034 pub fn has_conflict(&self) -> bool {
1035 self.saved_version_fingerprint != self.as_rope().fingerprint()
1036 && self
1037 .file
1038 .as_ref()
1039 .map_or(false, |file| file.mtime() > self.saved_mtime)
1040 }
1041
1042 pub fn subscribe(&mut self) -> Subscription {
1043 self.text.subscribe()
1044 }
1045
1046 pub fn start_transaction(&mut self) -> Option<TransactionId> {
1047 self.start_transaction_at(Instant::now())
1048 }
1049
1050 pub fn start_transaction_at(&mut self, now: Instant) -> Option<TransactionId> {
1051 self.transaction_depth += 1;
1052 if self.was_dirty_before_starting_transaction.is_none() {
1053 self.was_dirty_before_starting_transaction = Some(self.is_dirty());
1054 }
1055 self.text.start_transaction_at(now)
1056 }
1057
1058 pub fn end_transaction(&mut self, cx: &mut ModelContext<Self>) -> Option<TransactionId> {
1059 self.end_transaction_at(Instant::now(), cx)
1060 }
1061
1062 pub fn end_transaction_at(
1063 &mut self,
1064 now: Instant,
1065 cx: &mut ModelContext<Self>,
1066 ) -> Option<TransactionId> {
1067 assert!(self.transaction_depth > 0);
1068 self.transaction_depth -= 1;
1069 let was_dirty = if self.transaction_depth == 0 {
1070 self.was_dirty_before_starting_transaction.take().unwrap()
1071 } else {
1072 false
1073 };
1074 if let Some((transaction_id, start_version)) = self.text.end_transaction_at(now) {
1075 self.did_edit(&start_version, was_dirty, cx);
1076 Some(transaction_id)
1077 } else {
1078 None
1079 }
1080 }
1081
1082 pub fn push_transaction(&mut self, transaction: Transaction, now: Instant) {
1083 self.text.push_transaction(transaction, now);
1084 }
1085
1086 pub fn finalize_last_transaction(&mut self) -> Option<&Transaction> {
1087 self.text.finalize_last_transaction()
1088 }
1089
1090 pub fn forget_transaction(&mut self, transaction_id: TransactionId) {
1091 self.text.forget_transaction(transaction_id);
1092 }
1093
1094 pub fn wait_for_edits(
1095 &mut self,
1096 edit_ids: impl IntoIterator<Item = clock::Local>,
1097 ) -> impl Future<Output = ()> {
1098 self.text.wait_for_edits(edit_ids)
1099 }
1100
1101 pub fn wait_for_anchors<'a>(
1102 &mut self,
1103 anchors: impl IntoIterator<Item = &'a Anchor>,
1104 ) -> impl Future<Output = ()> {
1105 self.text.wait_for_anchors(anchors)
1106 }
1107
1108 pub fn wait_for_version(&mut self, version: clock::Global) -> impl Future<Output = ()> {
1109 self.text.wait_for_version(version)
1110 }
1111
1112 pub fn set_active_selections(
1113 &mut self,
1114 selections: Arc<[Selection<Anchor>]>,
1115 line_mode: bool,
1116 cx: &mut ModelContext<Self>,
1117 ) {
1118 let lamport_timestamp = self.text.lamport_clock.tick();
1119 self.remote_selections.insert(
1120 self.text.replica_id(),
1121 SelectionSet {
1122 selections: selections.clone(),
1123 lamport_timestamp,
1124 line_mode,
1125 },
1126 );
1127 self.send_operation(
1128 Operation::UpdateSelections {
1129 selections,
1130 line_mode,
1131 lamport_timestamp,
1132 },
1133 cx,
1134 );
1135 }
1136
1137 pub fn remove_active_selections(&mut self, cx: &mut ModelContext<Self>) {
1138 self.set_active_selections(Arc::from([]), false, cx);
1139 }
1140
1141 pub fn set_text<T>(&mut self, text: T, cx: &mut ModelContext<Self>) -> Option<clock::Local>
1142 where
1143 T: Into<Arc<str>>,
1144 {
1145 self.edit_internal([(0..self.len(), text)], None, cx)
1146 }
1147
1148 pub fn edit<I, S, T>(
1149 &mut self,
1150 edits_iter: I,
1151 cx: &mut ModelContext<Self>,
1152 ) -> Option<clock::Local>
1153 where
1154 I: IntoIterator<Item = (Range<S>, T)>,
1155 S: ToOffset,
1156 T: Into<Arc<str>>,
1157 {
1158 self.edit_internal(edits_iter, None, cx)
1159 }
1160
1161 pub fn edit_with_autoindent<I, S, T>(
1162 &mut self,
1163 edits_iter: I,
1164 indent_size: IndentSize,
1165 cx: &mut ModelContext<Self>,
1166 ) -> Option<clock::Local>
1167 where
1168 I: IntoIterator<Item = (Range<S>, T)>,
1169 S: ToOffset,
1170 T: Into<Arc<str>>,
1171 {
1172 self.edit_internal(edits_iter, Some(indent_size), cx)
1173 }
1174
1175 pub fn edit_internal<I, S, T>(
1176 &mut self,
1177 edits_iter: I,
1178 autoindent_size: Option<IndentSize>,
1179 cx: &mut ModelContext<Self>,
1180 ) -> Option<clock::Local>
1181 where
1182 I: IntoIterator<Item = (Range<S>, T)>,
1183 S: ToOffset,
1184 T: Into<Arc<str>>,
1185 {
1186 // Skip invalid edits and coalesce contiguous ones.
1187 let mut edits: Vec<(Range<usize>, Arc<str>)> = Vec::new();
1188 for (range, new_text) in edits_iter {
1189 let mut range = range.start.to_offset(self)..range.end.to_offset(self);
1190 if range.start > range.end {
1191 mem::swap(&mut range.start, &mut range.end);
1192 }
1193 let new_text = new_text.into();
1194 if !new_text.is_empty() || !range.is_empty() {
1195 if let Some((prev_range, prev_text)) = edits.last_mut() {
1196 if prev_range.end >= range.start {
1197 prev_range.end = cmp::max(prev_range.end, range.end);
1198 *prev_text = format!("{prev_text}{new_text}").into();
1199 } else {
1200 edits.push((range, new_text));
1201 }
1202 } else {
1203 edits.push((range, new_text));
1204 }
1205 }
1206 }
1207 if edits.is_empty() {
1208 return None;
1209 }
1210
1211 self.start_transaction();
1212 self.pending_autoindent.take();
1213 let autoindent_request =
1214 self.language
1215 .as_ref()
1216 .and_then(|_| autoindent_size)
1217 .map(|autoindent_size| {
1218 let before_edit = self.snapshot();
1219 let edited = edits
1220 .iter()
1221 .filter_map(|(range, new_text)| {
1222 let start = range.start.to_point(self);
1223 if new_text.starts_with('\n')
1224 && start.column == self.line_len(start.row)
1225 {
1226 None
1227 } else {
1228 Some(self.anchor_before(range.start))
1229 }
1230 })
1231 .collect();
1232 (before_edit, edited, autoindent_size)
1233 });
1234
1235 let edit_operation = self.text.edit(edits.iter().cloned());
1236 let edit_id = edit_operation.local_timestamp();
1237
1238 if let Some((before_edit, edited, size)) = autoindent_request {
1239 let mut delta = 0isize;
1240
1241 let inserted_ranges = edits
1242 .into_iter()
1243 .filter_map(|(range, new_text)| {
1244 let first_newline_ix = new_text.find('\n')?;
1245 let new_text_len = new_text.len();
1246 let start = (delta + range.start as isize) as usize + first_newline_ix + 1;
1247 let end = (delta + range.start as isize) as usize + new_text_len;
1248 delta += new_text_len as isize - (range.end as isize - range.start as isize);
1249 Some(self.anchor_before(start)..self.anchor_after(end))
1250 })
1251 .collect::<Vec<Range<Anchor>>>();
1252
1253 let inserted = if inserted_ranges.is_empty() {
1254 None
1255 } else {
1256 Some(inserted_ranges)
1257 };
1258
1259 self.autoindent_requests.push(Arc::new(AutoindentRequest {
1260 before_edit,
1261 edited,
1262 inserted,
1263 indent_size: size,
1264 }));
1265 }
1266
1267 self.end_transaction(cx);
1268 self.send_operation(Operation::Buffer(edit_operation), cx);
1269 Some(edit_id)
1270 }
1271
1272 fn did_edit(
1273 &mut self,
1274 old_version: &clock::Global,
1275 was_dirty: bool,
1276 cx: &mut ModelContext<Self>,
1277 ) {
1278 if self.edits_since::<usize>(old_version).next().is_none() {
1279 return;
1280 }
1281
1282 self.reparse(cx);
1283
1284 cx.emit(Event::Edited);
1285 if was_dirty != self.is_dirty() {
1286 cx.emit(Event::DirtyChanged);
1287 }
1288 cx.notify();
1289 }
1290
1291 fn grammar(&self) -> Option<&Arc<Grammar>> {
1292 self.language.as_ref().and_then(|l| l.grammar.as_ref())
1293 }
1294
1295 pub fn apply_ops<I: IntoIterator<Item = Operation>>(
1296 &mut self,
1297 ops: I,
1298 cx: &mut ModelContext<Self>,
1299 ) -> Result<()> {
1300 self.pending_autoindent.take();
1301 let was_dirty = self.is_dirty();
1302 let old_version = self.version.clone();
1303 let mut deferred_ops = Vec::new();
1304 let buffer_ops = ops
1305 .into_iter()
1306 .filter_map(|op| match op {
1307 Operation::Buffer(op) => Some(op),
1308 _ => {
1309 if self.can_apply_op(&op) {
1310 self.apply_op(op, cx);
1311 } else {
1312 deferred_ops.push(op);
1313 }
1314 None
1315 }
1316 })
1317 .collect::<Vec<_>>();
1318 self.text.apply_ops(buffer_ops)?;
1319 self.deferred_ops.insert(deferred_ops);
1320 self.flush_deferred_ops(cx);
1321 self.did_edit(&old_version, was_dirty, cx);
1322 // Notify independently of whether the buffer was edited as the operations could include a
1323 // selection update.
1324 cx.notify();
1325 Ok(())
1326 }
1327
1328 fn flush_deferred_ops(&mut self, cx: &mut ModelContext<Self>) {
1329 let mut deferred_ops = Vec::new();
1330 for op in self.deferred_ops.drain().iter().cloned() {
1331 if self.can_apply_op(&op) {
1332 self.apply_op(op, cx);
1333 } else {
1334 deferred_ops.push(op);
1335 }
1336 }
1337 self.deferred_ops.insert(deferred_ops);
1338 }
1339
1340 fn can_apply_op(&self, operation: &Operation) -> bool {
1341 match operation {
1342 Operation::Buffer(_) => {
1343 unreachable!("buffer operations should never be applied at this layer")
1344 }
1345 Operation::UpdateDiagnostics {
1346 diagnostics: diagnostic_set,
1347 ..
1348 } => diagnostic_set.iter().all(|diagnostic| {
1349 self.text.can_resolve(&diagnostic.range.start)
1350 && self.text.can_resolve(&diagnostic.range.end)
1351 }),
1352 Operation::UpdateSelections { selections, .. } => selections
1353 .iter()
1354 .all(|s| self.can_resolve(&s.start) && self.can_resolve(&s.end)),
1355 Operation::UpdateCompletionTriggers { .. } => true,
1356 }
1357 }
1358
1359 fn apply_op(&mut self, operation: Operation, cx: &mut ModelContext<Self>) {
1360 match operation {
1361 Operation::Buffer(_) => {
1362 unreachable!("buffer operations should never be applied at this layer")
1363 }
1364 Operation::UpdateDiagnostics {
1365 diagnostics: diagnostic_set,
1366 lamport_timestamp,
1367 } => {
1368 let snapshot = self.snapshot();
1369 self.apply_diagnostic_update(
1370 DiagnosticSet::from_sorted_entries(diagnostic_set.iter().cloned(), &snapshot),
1371 lamport_timestamp,
1372 cx,
1373 );
1374 }
1375 Operation::UpdateSelections {
1376 selections,
1377 lamport_timestamp,
1378 line_mode,
1379 } => {
1380 if let Some(set) = self.remote_selections.get(&lamport_timestamp.replica_id) {
1381 if set.lamport_timestamp > lamport_timestamp {
1382 return;
1383 }
1384 }
1385
1386 self.remote_selections.insert(
1387 lamport_timestamp.replica_id,
1388 SelectionSet {
1389 selections,
1390 lamport_timestamp,
1391 line_mode,
1392 },
1393 );
1394 self.text.lamport_clock.observe(lamport_timestamp);
1395 self.selections_update_count += 1;
1396 }
1397 Operation::UpdateCompletionTriggers {
1398 triggers,
1399 lamport_timestamp,
1400 } => {
1401 self.completion_triggers = triggers;
1402 self.text.lamport_clock.observe(lamport_timestamp);
1403 }
1404 }
1405 }
1406
1407 fn apply_diagnostic_update(
1408 &mut self,
1409 diagnostics: DiagnosticSet,
1410 lamport_timestamp: clock::Lamport,
1411 cx: &mut ModelContext<Self>,
1412 ) {
1413 if lamport_timestamp > self.diagnostics_timestamp {
1414 self.diagnostics = diagnostics;
1415 self.diagnostics_timestamp = lamport_timestamp;
1416 self.diagnostics_update_count += 1;
1417 self.text.lamport_clock.observe(lamport_timestamp);
1418 cx.notify();
1419 cx.emit(Event::DiagnosticsUpdated);
1420 }
1421 }
1422
1423 fn send_operation(&mut self, operation: Operation, cx: &mut ModelContext<Self>) {
1424 cx.emit(Event::Operation(operation));
1425 }
1426
1427 pub fn remove_peer(&mut self, replica_id: ReplicaId, cx: &mut ModelContext<Self>) {
1428 self.remote_selections.remove(&replica_id);
1429 cx.notify();
1430 }
1431
1432 pub fn undo(&mut self, cx: &mut ModelContext<Self>) -> Option<TransactionId> {
1433 let was_dirty = self.is_dirty();
1434 let old_version = self.version.clone();
1435
1436 if let Some((transaction_id, operation)) = self.text.undo() {
1437 self.send_operation(Operation::Buffer(operation), cx);
1438 self.did_edit(&old_version, was_dirty, cx);
1439 Some(transaction_id)
1440 } else {
1441 None
1442 }
1443 }
1444
1445 pub fn undo_to_transaction(
1446 &mut self,
1447 transaction_id: TransactionId,
1448 cx: &mut ModelContext<Self>,
1449 ) -> bool {
1450 let was_dirty = self.is_dirty();
1451 let old_version = self.version.clone();
1452
1453 let operations = self.text.undo_to_transaction(transaction_id);
1454 let undone = !operations.is_empty();
1455 for operation in operations {
1456 self.send_operation(Operation::Buffer(operation), cx);
1457 }
1458 if undone {
1459 self.did_edit(&old_version, was_dirty, cx)
1460 }
1461 undone
1462 }
1463
1464 pub fn redo(&mut self, cx: &mut ModelContext<Self>) -> Option<TransactionId> {
1465 let was_dirty = self.is_dirty();
1466 let old_version = self.version.clone();
1467
1468 if let Some((transaction_id, operation)) = self.text.redo() {
1469 self.send_operation(Operation::Buffer(operation), cx);
1470 self.did_edit(&old_version, was_dirty, cx);
1471 Some(transaction_id)
1472 } else {
1473 None
1474 }
1475 }
1476
1477 pub fn redo_to_transaction(
1478 &mut self,
1479 transaction_id: TransactionId,
1480 cx: &mut ModelContext<Self>,
1481 ) -> bool {
1482 let was_dirty = self.is_dirty();
1483 let old_version = self.version.clone();
1484
1485 let operations = self.text.redo_to_transaction(transaction_id);
1486 let redone = !operations.is_empty();
1487 for operation in operations {
1488 self.send_operation(Operation::Buffer(operation), cx);
1489 }
1490 if redone {
1491 self.did_edit(&old_version, was_dirty, cx)
1492 }
1493 redone
1494 }
1495
1496 pub fn set_completion_triggers(&mut self, triggers: Vec<String>, cx: &mut ModelContext<Self>) {
1497 self.completion_triggers = triggers.clone();
1498 let lamport_timestamp = self.text.lamport_clock.tick();
1499 self.send_operation(
1500 Operation::UpdateCompletionTriggers {
1501 triggers,
1502 lamport_timestamp,
1503 },
1504 cx,
1505 );
1506 cx.notify();
1507 }
1508
1509 pub fn completion_triggers(&self) -> &[String] {
1510 &self.completion_triggers
1511 }
1512
1513 pub fn newline_style(&self) -> NewlineStyle {
1514 self.newline_style
1515 }
1516}
1517
1518#[cfg(any(test, feature = "test-support"))]
1519impl Buffer {
1520 pub fn set_group_interval(&mut self, group_interval: Duration) {
1521 self.text.set_group_interval(group_interval);
1522 }
1523
1524 pub fn randomly_edit<T>(
1525 &mut self,
1526 rng: &mut T,
1527 old_range_count: usize,
1528 cx: &mut ModelContext<Self>,
1529 ) where
1530 T: rand::Rng,
1531 {
1532 let mut edits: Vec<(Range<usize>, String)> = Vec::new();
1533 let mut last_end = None;
1534 for _ in 0..old_range_count {
1535 if last_end.map_or(false, |last_end| last_end >= self.len()) {
1536 break;
1537 }
1538
1539 let new_start = last_end.map_or(0, |last_end| last_end + 1);
1540 let mut range = self.random_byte_range(new_start, rng);
1541 if rng.gen_bool(0.2) {
1542 mem::swap(&mut range.start, &mut range.end);
1543 }
1544 last_end = Some(range.end);
1545
1546 let new_text_len = rng.gen_range(0..10);
1547 let new_text: String = crate::random_char_iter::RandomCharIter::new(&mut *rng)
1548 .take(new_text_len)
1549 .collect();
1550
1551 edits.push((range, new_text));
1552 }
1553 log::info!("mutating buffer {} with {:?}", self.replica_id(), edits);
1554 self.edit(edits, cx);
1555 }
1556
1557 pub fn randomly_undo_redo(&mut self, rng: &mut impl rand::Rng, cx: &mut ModelContext<Self>) {
1558 let was_dirty = self.is_dirty();
1559 let old_version = self.version.clone();
1560
1561 let ops = self.text.randomly_undo_redo(rng);
1562 if !ops.is_empty() {
1563 for op in ops {
1564 self.send_operation(Operation::Buffer(op), cx);
1565 self.did_edit(&old_version, was_dirty, cx);
1566 }
1567 }
1568 }
1569}
1570
1571impl Entity for Buffer {
1572 type Event = Event;
1573}
1574
1575impl Deref for Buffer {
1576 type Target = TextBuffer;
1577
1578 fn deref(&self) -> &Self::Target {
1579 &self.text
1580 }
1581}
1582
1583impl BufferSnapshot {
1584 pub fn indent_size_for_line(&self, row: u32) -> IndentSize {
1585 indent_size_for_line(&self, row)
1586 }
1587
1588 fn suggest_autoindents<'a>(
1589 &'a self,
1590 row_range: Range<u32>,
1591 ) -> Option<impl Iterator<Item = Option<IndentSuggestion>> + 'a> {
1592 let language = self.language.as_ref()?;
1593 let grammar = language.grammar.as_ref()?;
1594 let config = &language.config;
1595 let prev_non_blank_row = self.prev_non_blank_row(row_range.start);
1596
1597 // Find the suggested indentation ranges based on the syntax tree.
1598 let indents_query = grammar.indents_query.as_ref()?;
1599 let mut query_cursor = QueryCursorHandle::new();
1600 let indent_capture_ix = indents_query.capture_index_for_name("indent");
1601 let end_capture_ix = indents_query.capture_index_for_name("end");
1602 query_cursor.set_point_range(
1603 Point::new(prev_non_blank_row.unwrap_or(row_range.start), 0).to_ts_point()
1604 ..Point::new(row_range.end, 0).to_ts_point(),
1605 );
1606
1607 let mut indent_ranges = Vec::<Range<Point>>::new();
1608 for mat in query_cursor.matches(
1609 indents_query,
1610 self.tree.as_ref()?.root_node(),
1611 TextProvider(self.as_rope()),
1612 ) {
1613 let mut start: Option<Point> = None;
1614 let mut end: Option<Point> = None;
1615 for capture in mat.captures {
1616 if Some(capture.index) == indent_capture_ix {
1617 start.get_or_insert(Point::from_ts_point(capture.node.start_position()));
1618 end.get_or_insert(Point::from_ts_point(capture.node.end_position()));
1619 } else if Some(capture.index) == end_capture_ix {
1620 end = Some(Point::from_ts_point(capture.node.start_position().into()));
1621 }
1622 }
1623
1624 if let Some((start, end)) = start.zip(end) {
1625 if start.row == end.row {
1626 continue;
1627 }
1628
1629 let range = start..end;
1630 match indent_ranges.binary_search_by_key(&range.start, |r| r.start) {
1631 Err(ix) => indent_ranges.insert(ix, range),
1632 Ok(ix) => {
1633 let prev_range = &mut indent_ranges[ix];
1634 prev_range.end = prev_range.end.max(range.end);
1635 }
1636 }
1637 }
1638 }
1639
1640 // Find the suggested indentation increases and decreased based on regexes.
1641 let mut indent_change_rows = Vec::<(u32, Ordering)>::new();
1642 self.for_each_line(
1643 Point::new(prev_non_blank_row.unwrap_or(row_range.start), 0)
1644 ..Point::new(row_range.end, 0),
1645 |row, line| {
1646 if config
1647 .decrease_indent_pattern
1648 .as_ref()
1649 .map_or(false, |regex| regex.is_match(line))
1650 {
1651 indent_change_rows.push((row, Ordering::Less));
1652 }
1653 if config
1654 .increase_indent_pattern
1655 .as_ref()
1656 .map_or(false, |regex| regex.is_match(line))
1657 {
1658 indent_change_rows.push((row + 1, Ordering::Greater));
1659 }
1660 },
1661 );
1662
1663 let mut indent_changes = indent_change_rows.into_iter().peekable();
1664 let mut prev_row = if config.auto_indent_using_last_non_empty_line {
1665 prev_non_blank_row.unwrap_or(0)
1666 } else {
1667 row_range.start.saturating_sub(1)
1668 };
1669 let mut prev_row_start = Point::new(prev_row, self.indent_size_for_line(prev_row).len);
1670 Some(row_range.map(move |row| {
1671 let row_start = Point::new(row, self.indent_size_for_line(row).len);
1672
1673 let mut indent_from_prev_row = false;
1674 let mut outdent_from_prev_row = false;
1675 let mut outdent_to_row = u32::MAX;
1676
1677 while let Some((indent_row, delta)) = indent_changes.peek() {
1678 if *indent_row == row {
1679 match delta {
1680 Ordering::Less => outdent_from_prev_row = true,
1681 Ordering::Greater => indent_from_prev_row = true,
1682 _ => {}
1683 }
1684 } else if *indent_row > row {
1685 break;
1686 }
1687 indent_changes.next();
1688 }
1689
1690 for range in &indent_ranges {
1691 if range.start.row >= row {
1692 break;
1693 }
1694 if range.start.row == prev_row && range.end > row_start {
1695 indent_from_prev_row = true;
1696 }
1697 if range.end > prev_row_start && range.end <= row_start {
1698 outdent_to_row = outdent_to_row.min(range.start.row);
1699 }
1700 }
1701
1702 let suggestion = if outdent_to_row == prev_row
1703 || (outdent_from_prev_row && indent_from_prev_row)
1704 {
1705 Some(IndentSuggestion {
1706 basis_row: prev_row,
1707 delta: Ordering::Equal,
1708 })
1709 } else if indent_from_prev_row {
1710 Some(IndentSuggestion {
1711 basis_row: prev_row,
1712 delta: Ordering::Greater,
1713 })
1714 } else if outdent_to_row < prev_row {
1715 Some(IndentSuggestion {
1716 basis_row: outdent_to_row,
1717 delta: Ordering::Equal,
1718 })
1719 } else if outdent_from_prev_row {
1720 Some(IndentSuggestion {
1721 basis_row: prev_row,
1722 delta: Ordering::Less,
1723 })
1724 } else if config.auto_indent_using_last_non_empty_line || !self.is_line_blank(prev_row)
1725 {
1726 Some(IndentSuggestion {
1727 basis_row: prev_row,
1728 delta: Ordering::Equal,
1729 })
1730 } else {
1731 None
1732 };
1733
1734 prev_row = row;
1735 prev_row_start = row_start;
1736 suggestion
1737 }))
1738 }
1739
1740 fn prev_non_blank_row(&self, mut row: u32) -> Option<u32> {
1741 while row > 0 {
1742 row -= 1;
1743 if !self.is_line_blank(row) {
1744 return Some(row);
1745 }
1746 }
1747 None
1748 }
1749
1750 pub fn chunks<'a, T: ToOffset>(
1751 &'a self,
1752 range: Range<T>,
1753 language_aware: bool,
1754 ) -> BufferChunks<'a> {
1755 let range = range.start.to_offset(self)..range.end.to_offset(self);
1756
1757 let mut tree = None;
1758 let mut diagnostic_endpoints = Vec::new();
1759 if language_aware {
1760 tree = self.tree.as_ref();
1761 for entry in self.diagnostics_in_range::<_, usize>(range.clone(), false) {
1762 diagnostic_endpoints.push(DiagnosticEndpoint {
1763 offset: entry.range.start,
1764 is_start: true,
1765 severity: entry.diagnostic.severity,
1766 is_unnecessary: entry.diagnostic.is_unnecessary,
1767 });
1768 diagnostic_endpoints.push(DiagnosticEndpoint {
1769 offset: entry.range.end,
1770 is_start: false,
1771 severity: entry.diagnostic.severity,
1772 is_unnecessary: entry.diagnostic.is_unnecessary,
1773 });
1774 }
1775 diagnostic_endpoints
1776 .sort_unstable_by_key(|endpoint| (endpoint.offset, !endpoint.is_start));
1777 }
1778
1779 BufferChunks::new(
1780 self.text.as_rope(),
1781 range,
1782 tree,
1783 self.grammar(),
1784 diagnostic_endpoints,
1785 )
1786 }
1787
1788 pub fn for_each_line<'a>(&'a self, range: Range<Point>, mut callback: impl FnMut(u32, &str)) {
1789 let mut line = String::new();
1790 let mut row = range.start.row;
1791 for chunk in self
1792 .as_rope()
1793 .chunks_in_range(range.to_offset(self))
1794 .chain(["\n"])
1795 {
1796 for (newline_ix, text) in chunk.split('\n').enumerate() {
1797 if newline_ix > 0 {
1798 callback(row, &line);
1799 row += 1;
1800 line.clear();
1801 }
1802 line.push_str(text);
1803 }
1804 }
1805 }
1806
1807 pub fn language(&self) -> Option<&Arc<Language>> {
1808 self.language.as_ref()
1809 }
1810
1811 fn grammar(&self) -> Option<&Arc<Grammar>> {
1812 self.language
1813 .as_ref()
1814 .and_then(|language| language.grammar.as_ref())
1815 }
1816
1817 pub fn surrounding_word<T: ToOffset>(&self, start: T) -> (Range<usize>, Option<CharKind>) {
1818 let mut start = start.to_offset(self);
1819 let mut end = start;
1820 let mut next_chars = self.chars_at(start).peekable();
1821 let mut prev_chars = self.reversed_chars_at(start).peekable();
1822 let word_kind = cmp::max(
1823 prev_chars.peek().copied().map(char_kind),
1824 next_chars.peek().copied().map(char_kind),
1825 );
1826
1827 for ch in prev_chars {
1828 if Some(char_kind(ch)) == word_kind && ch != '\n' {
1829 start -= ch.len_utf8();
1830 } else {
1831 break;
1832 }
1833 }
1834
1835 for ch in next_chars {
1836 if Some(char_kind(ch)) == word_kind && ch != '\n' {
1837 end += ch.len_utf8();
1838 } else {
1839 break;
1840 }
1841 }
1842
1843 (start..end, word_kind)
1844 }
1845
1846 pub fn range_for_syntax_ancestor<T: ToOffset>(&self, range: Range<T>) -> Option<Range<usize>> {
1847 let tree = self.tree.as_ref()?;
1848 let range = range.start.to_offset(self)..range.end.to_offset(self);
1849 let mut cursor = tree.root_node().walk();
1850
1851 // Descend to the first leaf that touches the start of the range,
1852 // and if the range is non-empty, extends beyond the start.
1853 while cursor.goto_first_child_for_byte(range.start).is_some() {
1854 if !range.is_empty() && cursor.node().end_byte() == range.start {
1855 cursor.goto_next_sibling();
1856 }
1857 }
1858
1859 // Ascend to the smallest ancestor that strictly contains the range.
1860 loop {
1861 let node_range = cursor.node().byte_range();
1862 if node_range.start <= range.start
1863 && node_range.end >= range.end
1864 && node_range.len() > range.len()
1865 {
1866 break;
1867 }
1868 if !cursor.goto_parent() {
1869 break;
1870 }
1871 }
1872
1873 let left_node = cursor.node();
1874
1875 // For an empty range, try to find another node immediately to the right of the range.
1876 if left_node.end_byte() == range.start {
1877 let mut right_node = None;
1878 while !cursor.goto_next_sibling() {
1879 if !cursor.goto_parent() {
1880 break;
1881 }
1882 }
1883
1884 while cursor.node().start_byte() == range.start {
1885 right_node = Some(cursor.node());
1886 if !cursor.goto_first_child() {
1887 break;
1888 }
1889 }
1890
1891 // If there is a candidate node on both sides of the (empty) range, then
1892 // decide between the two by favoring a named node over an anonymous token.
1893 // If both nodes are the same in that regard, favor the right one.
1894 if let Some(right_node) = right_node {
1895 if right_node.is_named() || !left_node.is_named() {
1896 return Some(right_node.byte_range());
1897 }
1898 }
1899 }
1900
1901 Some(left_node.byte_range())
1902 }
1903
1904 pub fn outline(&self, theme: Option<&SyntaxTheme>) -> Option<Outline<Anchor>> {
1905 self.outline_items_containing(0..self.len(), theme)
1906 .map(Outline::new)
1907 }
1908
1909 pub fn symbols_containing<T: ToOffset>(
1910 &self,
1911 position: T,
1912 theme: Option<&SyntaxTheme>,
1913 ) -> Option<Vec<OutlineItem<Anchor>>> {
1914 let position = position.to_offset(&self);
1915 let mut items =
1916 self.outline_items_containing(position.saturating_sub(1)..position + 1, theme)?;
1917 let mut prev_depth = None;
1918 items.retain(|item| {
1919 let result = prev_depth.map_or(true, |prev_depth| item.depth > prev_depth);
1920 prev_depth = Some(item.depth);
1921 result
1922 });
1923 Some(items)
1924 }
1925
1926 fn outline_items_containing(
1927 &self,
1928 range: Range<usize>,
1929 theme: Option<&SyntaxTheme>,
1930 ) -> Option<Vec<OutlineItem<Anchor>>> {
1931 let tree = self.tree.as_ref()?;
1932 let grammar = self
1933 .language
1934 .as_ref()
1935 .and_then(|language| language.grammar.as_ref())?;
1936
1937 let outline_query = grammar.outline_query.as_ref()?;
1938 let mut cursor = QueryCursorHandle::new();
1939 cursor.set_byte_range(range.clone());
1940 let matches = cursor.matches(
1941 outline_query,
1942 tree.root_node(),
1943 TextProvider(self.as_rope()),
1944 );
1945
1946 let mut chunks = self.chunks(0..self.len(), true);
1947
1948 let item_capture_ix = outline_query.capture_index_for_name("item")?;
1949 let name_capture_ix = outline_query.capture_index_for_name("name")?;
1950 let context_capture_ix = outline_query
1951 .capture_index_for_name("context")
1952 .unwrap_or(u32::MAX);
1953
1954 let mut stack = Vec::<Range<usize>>::new();
1955 let items = matches
1956 .filter_map(|mat| {
1957 let item_node = mat.nodes_for_capture_index(item_capture_ix).next()?;
1958 let item_range = item_node.start_byte()..item_node.end_byte();
1959 if item_range.end < range.start || item_range.start > range.end {
1960 return None;
1961 }
1962 let mut text = String::new();
1963 let mut name_ranges = Vec::new();
1964 let mut highlight_ranges = Vec::new();
1965
1966 for capture in mat.captures {
1967 let node_is_name;
1968 if capture.index == name_capture_ix {
1969 node_is_name = true;
1970 } else if capture.index == context_capture_ix {
1971 node_is_name = false;
1972 } else {
1973 continue;
1974 }
1975
1976 let range = capture.node.start_byte()..capture.node.end_byte();
1977 if !text.is_empty() {
1978 text.push(' ');
1979 }
1980 if node_is_name {
1981 let mut start = text.len();
1982 let end = start + range.len();
1983
1984 // When multiple names are captured, then the matcheable text
1985 // includes the whitespace in between the names.
1986 if !name_ranges.is_empty() {
1987 start -= 1;
1988 }
1989
1990 name_ranges.push(start..end);
1991 }
1992
1993 let mut offset = range.start;
1994 chunks.seek(offset);
1995 while let Some(mut chunk) = chunks.next() {
1996 if chunk.text.len() > range.end - offset {
1997 chunk.text = &chunk.text[0..(range.end - offset)];
1998 offset = range.end;
1999 } else {
2000 offset += chunk.text.len();
2001 }
2002 let style = chunk
2003 .syntax_highlight_id
2004 .zip(theme)
2005 .and_then(|(highlight, theme)| highlight.style(theme));
2006 if let Some(style) = style {
2007 let start = text.len();
2008 let end = start + chunk.text.len();
2009 highlight_ranges.push((start..end, style));
2010 }
2011 text.push_str(chunk.text);
2012 if offset >= range.end {
2013 break;
2014 }
2015 }
2016 }
2017
2018 while stack.last().map_or(false, |prev_range| {
2019 prev_range.start > item_range.start || prev_range.end < item_range.end
2020 }) {
2021 stack.pop();
2022 }
2023 stack.push(item_range.clone());
2024
2025 Some(OutlineItem {
2026 depth: stack.len() - 1,
2027 range: self.anchor_after(item_range.start)..self.anchor_before(item_range.end),
2028 text,
2029 highlight_ranges,
2030 name_ranges,
2031 })
2032 })
2033 .collect::<Vec<_>>();
2034 Some(items)
2035 }
2036
2037 pub fn enclosing_bracket_ranges<T: ToOffset>(
2038 &self,
2039 range: Range<T>,
2040 ) -> Option<(Range<usize>, Range<usize>)> {
2041 let (grammar, tree) = self.grammar().zip(self.tree.as_ref())?;
2042 let brackets_query = grammar.brackets_query.as_ref()?;
2043 let open_capture_ix = brackets_query.capture_index_for_name("open")?;
2044 let close_capture_ix = brackets_query.capture_index_for_name("close")?;
2045
2046 // Find bracket pairs that *inclusively* contain the given range.
2047 let range = range.start.to_offset(self).saturating_sub(1)..range.end.to_offset(self) + 1;
2048 let mut cursor = QueryCursorHandle::new();
2049 let matches = cursor.set_byte_range(range).matches(
2050 &brackets_query,
2051 tree.root_node(),
2052 TextProvider(self.as_rope()),
2053 );
2054
2055 // Get the ranges of the innermost pair of brackets.
2056 matches
2057 .filter_map(|mat| {
2058 let open = mat.nodes_for_capture_index(open_capture_ix).next()?;
2059 let close = mat.nodes_for_capture_index(close_capture_ix).next()?;
2060 Some((open.byte_range(), close.byte_range()))
2061 })
2062 .min_by_key(|(open_range, close_range)| close_range.end - open_range.start)
2063 }
2064
2065 pub fn remote_selections_in_range<'a>(
2066 &'a self,
2067 range: Range<Anchor>,
2068 ) -> impl 'a
2069 + Iterator<
2070 Item = (
2071 ReplicaId,
2072 bool,
2073 impl 'a + Iterator<Item = &'a Selection<Anchor>>,
2074 ),
2075 > {
2076 self.remote_selections
2077 .iter()
2078 .filter(|(replica_id, set)| {
2079 **replica_id != self.text.replica_id() && !set.selections.is_empty()
2080 })
2081 .map(move |(replica_id, set)| {
2082 let start_ix = match set.selections.binary_search_by(|probe| {
2083 probe.end.cmp(&range.start, self).then(Ordering::Greater)
2084 }) {
2085 Ok(ix) | Err(ix) => ix,
2086 };
2087 let end_ix = match set.selections.binary_search_by(|probe| {
2088 probe.start.cmp(&range.end, self).then(Ordering::Less)
2089 }) {
2090 Ok(ix) | Err(ix) => ix,
2091 };
2092
2093 (
2094 *replica_id,
2095 set.line_mode,
2096 set.selections[start_ix..end_ix].iter(),
2097 )
2098 })
2099 }
2100
2101 pub fn diagnostics_in_range<'a, T, O>(
2102 &'a self,
2103 search_range: Range<T>,
2104 reversed: bool,
2105 ) -> impl 'a + Iterator<Item = DiagnosticEntry<O>>
2106 where
2107 T: 'a + Clone + ToOffset,
2108 O: 'a + FromAnchor,
2109 {
2110 self.diagnostics
2111 .range(search_range.clone(), self, true, reversed)
2112 }
2113
2114 pub fn diagnostic_groups(&self) -> Vec<DiagnosticGroup<Anchor>> {
2115 let mut groups = Vec::new();
2116 self.diagnostics.groups(&mut groups, self);
2117 groups
2118 }
2119
2120 pub fn diagnostic_group<'a, O>(
2121 &'a self,
2122 group_id: usize,
2123 ) -> impl 'a + Iterator<Item = DiagnosticEntry<O>>
2124 where
2125 O: 'a + FromAnchor,
2126 {
2127 self.diagnostics.group(group_id, self)
2128 }
2129
2130 pub fn diagnostics_update_count(&self) -> usize {
2131 self.diagnostics_update_count
2132 }
2133
2134 pub fn parse_count(&self) -> usize {
2135 self.parse_count
2136 }
2137
2138 pub fn selections_update_count(&self) -> usize {
2139 self.selections_update_count
2140 }
2141
2142 pub fn file(&self) -> Option<&dyn File> {
2143 self.file.as_deref()
2144 }
2145
2146 pub fn file_update_count(&self) -> usize {
2147 self.file_update_count
2148 }
2149}
2150
2151pub fn indent_size_for_line(text: &text::BufferSnapshot, row: u32) -> IndentSize {
2152 let mut result = IndentSize::spaces(0);
2153 for c in text.chars_at(Point::new(row, 0)) {
2154 let kind = match c {
2155 ' ' => IndentKind::Space,
2156 '\t' => IndentKind::Tab,
2157 _ => break,
2158 };
2159 if result.len == 0 {
2160 result.kind = kind;
2161 }
2162 result.len += 1;
2163 }
2164 result
2165}
2166
2167impl Clone for BufferSnapshot {
2168 fn clone(&self) -> Self {
2169 Self {
2170 text: self.text.clone(),
2171 tree: self.tree.clone(),
2172 file: self.file.clone(),
2173 remote_selections: self.remote_selections.clone(),
2174 diagnostics: self.diagnostics.clone(),
2175 selections_update_count: self.selections_update_count,
2176 diagnostics_update_count: self.diagnostics_update_count,
2177 file_update_count: self.file_update_count,
2178 language: self.language.clone(),
2179 parse_count: self.parse_count,
2180 }
2181 }
2182}
2183
2184impl Deref for BufferSnapshot {
2185 type Target = text::BufferSnapshot;
2186
2187 fn deref(&self) -> &Self::Target {
2188 &self.text
2189 }
2190}
2191
2192impl<'a> tree_sitter::TextProvider<'a> for TextProvider<'a> {
2193 type I = ByteChunks<'a>;
2194
2195 fn text(&mut self, node: tree_sitter::Node) -> Self::I {
2196 ByteChunks(self.0.chunks_in_range(node.byte_range()))
2197 }
2198}
2199
2200pub(crate) struct ByteChunks<'a>(rope::Chunks<'a>);
2201
2202impl<'a> Iterator for ByteChunks<'a> {
2203 type Item = &'a [u8];
2204
2205 fn next(&mut self) -> Option<Self::Item> {
2206 self.0.next().map(str::as_bytes)
2207 }
2208}
2209
2210unsafe impl<'a> Send for BufferChunks<'a> {}
2211
2212impl<'a> BufferChunks<'a> {
2213 pub(crate) fn new(
2214 text: &'a Rope,
2215 range: Range<usize>,
2216 tree: Option<&'a Tree>,
2217 grammar: Option<&'a Arc<Grammar>>,
2218 diagnostic_endpoints: Vec<DiagnosticEndpoint>,
2219 ) -> Self {
2220 let mut highlights = None;
2221 if let Some((grammar, tree)) = grammar.zip(tree) {
2222 if let Some(highlights_query) = grammar.highlights_query.as_ref() {
2223 let mut query_cursor = QueryCursorHandle::new();
2224
2225 // TODO - add a Tree-sitter API to remove the need for this.
2226 let cursor = unsafe {
2227 std::mem::transmute::<_, &'static mut QueryCursor>(query_cursor.deref_mut())
2228 };
2229 let captures = cursor.set_byte_range(range.clone()).captures(
2230 highlights_query,
2231 tree.root_node(),
2232 TextProvider(text),
2233 );
2234 highlights = Some(BufferChunkHighlights {
2235 captures,
2236 next_capture: None,
2237 stack: Default::default(),
2238 highlight_map: grammar.highlight_map(),
2239 _query_cursor: query_cursor,
2240 })
2241 }
2242 }
2243
2244 let diagnostic_endpoints = diagnostic_endpoints.into_iter().peekable();
2245 let chunks = text.chunks_in_range(range.clone());
2246
2247 BufferChunks {
2248 range,
2249 chunks,
2250 diagnostic_endpoints,
2251 error_depth: 0,
2252 warning_depth: 0,
2253 information_depth: 0,
2254 hint_depth: 0,
2255 unnecessary_depth: 0,
2256 highlights,
2257 }
2258 }
2259
2260 pub fn seek(&mut self, offset: usize) {
2261 self.range.start = offset;
2262 self.chunks.seek(self.range.start);
2263 if let Some(highlights) = self.highlights.as_mut() {
2264 highlights
2265 .stack
2266 .retain(|(end_offset, _)| *end_offset > offset);
2267 if let Some((mat, capture_ix)) = &highlights.next_capture {
2268 let capture = mat.captures[*capture_ix as usize];
2269 if offset >= capture.node.start_byte() {
2270 let next_capture_end = capture.node.end_byte();
2271 if offset < next_capture_end {
2272 highlights.stack.push((
2273 next_capture_end,
2274 highlights.highlight_map.get(capture.index),
2275 ));
2276 }
2277 highlights.next_capture.take();
2278 }
2279 }
2280 highlights.captures.set_byte_range(self.range.clone());
2281 }
2282 }
2283
2284 pub fn offset(&self) -> usize {
2285 self.range.start
2286 }
2287
2288 fn update_diagnostic_depths(&mut self, endpoint: DiagnosticEndpoint) {
2289 let depth = match endpoint.severity {
2290 DiagnosticSeverity::ERROR => &mut self.error_depth,
2291 DiagnosticSeverity::WARNING => &mut self.warning_depth,
2292 DiagnosticSeverity::INFORMATION => &mut self.information_depth,
2293 DiagnosticSeverity::HINT => &mut self.hint_depth,
2294 _ => return,
2295 };
2296 if endpoint.is_start {
2297 *depth += 1;
2298 } else {
2299 *depth -= 1;
2300 }
2301
2302 if endpoint.is_unnecessary {
2303 if endpoint.is_start {
2304 self.unnecessary_depth += 1;
2305 } else {
2306 self.unnecessary_depth -= 1;
2307 }
2308 }
2309 }
2310
2311 fn current_diagnostic_severity(&self) -> Option<DiagnosticSeverity> {
2312 if self.error_depth > 0 {
2313 Some(DiagnosticSeverity::ERROR)
2314 } else if self.warning_depth > 0 {
2315 Some(DiagnosticSeverity::WARNING)
2316 } else if self.information_depth > 0 {
2317 Some(DiagnosticSeverity::INFORMATION)
2318 } else if self.hint_depth > 0 {
2319 Some(DiagnosticSeverity::HINT)
2320 } else {
2321 None
2322 }
2323 }
2324
2325 fn current_code_is_unnecessary(&self) -> bool {
2326 self.unnecessary_depth > 0
2327 }
2328}
2329
2330impl<'a> Iterator for BufferChunks<'a> {
2331 type Item = Chunk<'a>;
2332
2333 fn next(&mut self) -> Option<Self::Item> {
2334 let mut next_capture_start = usize::MAX;
2335 let mut next_diagnostic_endpoint = usize::MAX;
2336
2337 if let Some(highlights) = self.highlights.as_mut() {
2338 while let Some((parent_capture_end, _)) = highlights.stack.last() {
2339 if *parent_capture_end <= self.range.start {
2340 highlights.stack.pop();
2341 } else {
2342 break;
2343 }
2344 }
2345
2346 if highlights.next_capture.is_none() {
2347 highlights.next_capture = highlights.captures.next();
2348 }
2349
2350 while let Some((mat, capture_ix)) = highlights.next_capture.as_ref() {
2351 let capture = mat.captures[*capture_ix as usize];
2352 if self.range.start < capture.node.start_byte() {
2353 next_capture_start = capture.node.start_byte();
2354 break;
2355 } else {
2356 let highlight_id = highlights.highlight_map.get(capture.index);
2357 highlights
2358 .stack
2359 .push((capture.node.end_byte(), highlight_id));
2360 highlights.next_capture = highlights.captures.next();
2361 }
2362 }
2363 }
2364
2365 while let Some(endpoint) = self.diagnostic_endpoints.peek().copied() {
2366 if endpoint.offset <= self.range.start {
2367 self.update_diagnostic_depths(endpoint);
2368 self.diagnostic_endpoints.next();
2369 } else {
2370 next_diagnostic_endpoint = endpoint.offset;
2371 break;
2372 }
2373 }
2374
2375 if let Some(chunk) = self.chunks.peek() {
2376 let chunk_start = self.range.start;
2377 let mut chunk_end = (self.chunks.offset() + chunk.len())
2378 .min(next_capture_start)
2379 .min(next_diagnostic_endpoint);
2380 let mut highlight_id = None;
2381 if let Some(highlights) = self.highlights.as_ref() {
2382 if let Some((parent_capture_end, parent_highlight_id)) = highlights.stack.last() {
2383 chunk_end = chunk_end.min(*parent_capture_end);
2384 highlight_id = Some(*parent_highlight_id);
2385 }
2386 }
2387
2388 let slice =
2389 &chunk[chunk_start - self.chunks.offset()..chunk_end - self.chunks.offset()];
2390 self.range.start = chunk_end;
2391 if self.range.start == self.chunks.offset() + chunk.len() {
2392 self.chunks.next().unwrap();
2393 }
2394
2395 Some(Chunk {
2396 text: slice,
2397 syntax_highlight_id: highlight_id,
2398 highlight_style: None,
2399 diagnostic_severity: self.current_diagnostic_severity(),
2400 is_unnecessary: self.current_code_is_unnecessary(),
2401 })
2402 } else {
2403 None
2404 }
2405 }
2406}
2407
2408impl QueryCursorHandle {
2409 pub(crate) fn new() -> Self {
2410 QueryCursorHandle(Some(
2411 QUERY_CURSORS
2412 .lock()
2413 .pop()
2414 .unwrap_or_else(|| QueryCursor::new()),
2415 ))
2416 }
2417}
2418
2419impl Deref for QueryCursorHandle {
2420 type Target = QueryCursor;
2421
2422 fn deref(&self) -> &Self::Target {
2423 self.0.as_ref().unwrap()
2424 }
2425}
2426
2427impl DerefMut for QueryCursorHandle {
2428 fn deref_mut(&mut self) -> &mut Self::Target {
2429 self.0.as_mut().unwrap()
2430 }
2431}
2432
2433impl Drop for QueryCursorHandle {
2434 fn drop(&mut self) {
2435 let mut cursor = self.0.take().unwrap();
2436 cursor.set_byte_range(0..usize::MAX);
2437 cursor.set_point_range(Point::zero().to_ts_point()..Point::MAX.to_ts_point());
2438 QUERY_CURSORS.lock().push(cursor)
2439 }
2440}
2441
2442trait ToTreeSitterPoint {
2443 fn to_ts_point(self) -> tree_sitter::Point;
2444 fn from_ts_point(point: tree_sitter::Point) -> Self;
2445}
2446
2447impl ToTreeSitterPoint for Point {
2448 fn to_ts_point(self) -> tree_sitter::Point {
2449 tree_sitter::Point::new(self.row as usize, self.column as usize)
2450 }
2451
2452 fn from_ts_point(point: tree_sitter::Point) -> Self {
2453 Point::new(point.row as u32, point.column as u32)
2454 }
2455}
2456
2457impl operation_queue::Operation for Operation {
2458 fn lamport_timestamp(&self) -> clock::Lamport {
2459 match self {
2460 Operation::Buffer(_) => {
2461 unreachable!("buffer operations should never be deferred at this layer")
2462 }
2463 Operation::UpdateDiagnostics {
2464 lamport_timestamp, ..
2465 }
2466 | Operation::UpdateSelections {
2467 lamport_timestamp, ..
2468 }
2469 | Operation::UpdateCompletionTriggers {
2470 lamport_timestamp, ..
2471 } => *lamport_timestamp,
2472 }
2473 }
2474}
2475
2476impl Default for Diagnostic {
2477 fn default() -> Self {
2478 Self {
2479 code: Default::default(),
2480 severity: DiagnosticSeverity::ERROR,
2481 message: Default::default(),
2482 group_id: Default::default(),
2483 is_primary: Default::default(),
2484 is_valid: true,
2485 is_disk_based: false,
2486 is_unnecessary: false,
2487 }
2488 }
2489}
2490
2491impl IndentSize {
2492 pub fn spaces(len: u32) -> Self {
2493 Self {
2494 len,
2495 kind: IndentKind::Space,
2496 }
2497 }
2498
2499 pub fn tab() -> Self {
2500 Self {
2501 len: 1,
2502 kind: IndentKind::Tab,
2503 }
2504 }
2505
2506 pub fn chars(&self) -> impl Iterator<Item = char> {
2507 iter::repeat(self.char()).take(self.len as usize)
2508 }
2509
2510 pub fn char(&self) -> char {
2511 match self.kind {
2512 IndentKind::Space => ' ',
2513 IndentKind::Tab => '\t',
2514 }
2515 }
2516}
2517
2518impl std::ops::AddAssign for IndentSize {
2519 fn add_assign(&mut self, other: IndentSize) {
2520 if self.len == 0 {
2521 *self = other;
2522 } else if self.kind == other.kind {
2523 self.len += other.len;
2524 }
2525 }
2526}
2527
2528impl std::ops::SubAssign for IndentSize {
2529 fn sub_assign(&mut self, other: IndentSize) {
2530 if self.kind == other.kind && self.len >= other.len {
2531 self.len -= other.len;
2532 }
2533 }
2534}
2535
2536impl NewlineStyle {
2537 fn from_proto(style: proto::NewlineStyle) -> Self {
2538 match style {
2539 proto::NewlineStyle::Unix => Self::Unix,
2540 proto::NewlineStyle::Windows => Self::Windows,
2541 }
2542 }
2543
2544 fn detect(text: &str) -> Self {
2545 let text = &text[..cmp::min(text.len(), 1000)];
2546 if let Some(ix) = text.find('\n') {
2547 if ix == 0 || text.as_bytes()[ix - 1] != b'\r' {
2548 Self::Unix
2549 } else {
2550 Self::Windows
2551 }
2552 } else {
2553 Default::default()
2554 }
2555 }
2556
2557 pub fn as_str(self) -> &'static str {
2558 match self {
2559 NewlineStyle::Unix => "\n",
2560 NewlineStyle::Windows => "\r\n",
2561 }
2562 }
2563
2564 fn to_proto(self) -> proto::NewlineStyle {
2565 match self {
2566 NewlineStyle::Unix => proto::NewlineStyle::Unix,
2567 NewlineStyle::Windows => proto::NewlineStyle::Windows,
2568 }
2569 }
2570}
2571
2572impl Default for NewlineStyle {
2573 fn default() -> Self {
2574 #[cfg(unix)]
2575 return Self::Unix;
2576
2577 #[cfg(not(unix))]
2578 return Self::Windows;
2579 }
2580}
2581
2582impl Completion {
2583 pub fn sort_key(&self) -> (usize, &str) {
2584 let kind_key = match self.lsp_completion.kind {
2585 Some(lsp::CompletionItemKind::VARIABLE) => 0,
2586 _ => 1,
2587 };
2588 (kind_key, &self.label.text[self.label.filter_range.clone()])
2589 }
2590
2591 pub fn is_snippet(&self) -> bool {
2592 self.lsp_completion.insert_text_format == Some(lsp::InsertTextFormat::SNIPPET)
2593 }
2594}
2595
2596pub fn contiguous_ranges(
2597 values: impl Iterator<Item = u32>,
2598 max_len: usize,
2599) -> impl Iterator<Item = Range<u32>> {
2600 let mut values = values.into_iter();
2601 let mut current_range: Option<Range<u32>> = None;
2602 std::iter::from_fn(move || loop {
2603 if let Some(value) = values.next() {
2604 if let Some(range) = &mut current_range {
2605 if value == range.end && range.len() < max_len {
2606 range.end += 1;
2607 continue;
2608 }
2609 }
2610
2611 let prev_range = current_range.clone();
2612 current_range = Some(value..(value + 1));
2613 if prev_range.is_some() {
2614 return prev_range;
2615 }
2616 } else {
2617 return current_range.take();
2618 }
2619 })
2620}
2621
2622pub fn char_kind(c: char) -> CharKind {
2623 if c.is_whitespace() {
2624 CharKind::Whitespace
2625 } else if c.is_alphanumeric() || c == '_' {
2626 CharKind::Word
2627 } else {
2628 CharKind::Punctuation
2629 }
2630}