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