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(crate) 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(crate) 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::strip_carriage_returns(&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(crate) fn apply_diff(
983 &mut self,
984 diff: Diff,
985 cx: &mut ModelContext<Self>,
986 ) -> Option<&Transaction> {
987 if self.version == diff.base_version {
988 self.finalize_last_transaction();
989 self.start_transaction();
990 self.text.set_line_ending(diff.line_ending);
991 let mut offset = diff.start_offset;
992 for (tag, len) in diff.changes {
993 let range = offset..(offset + len);
994 match tag {
995 ChangeTag::Equal => offset += len,
996 ChangeTag::Delete => {
997 self.edit([(range, "")], cx);
998 }
999 ChangeTag::Insert => {
1000 self.edit(
1001 [(
1002 offset..offset,
1003 &diff.new_text[range.start - diff.start_offset
1004 ..range.end - diff.start_offset],
1005 )],
1006 cx,
1007 );
1008 offset += len;
1009 }
1010 }
1011 }
1012 if self.end_transaction(cx).is_some() {
1013 self.finalize_last_transaction()
1014 } else {
1015 None
1016 }
1017 } else {
1018 None
1019 }
1020 }
1021
1022 pub fn is_dirty(&self) -> bool {
1023 self.saved_version_fingerprint != self.as_rope().fingerprint()
1024 || self.file.as_ref().map_or(false, |file| file.is_deleted())
1025 }
1026
1027 pub fn has_conflict(&self) -> bool {
1028 self.saved_version_fingerprint != self.as_rope().fingerprint()
1029 && self
1030 .file
1031 .as_ref()
1032 .map_or(false, |file| file.mtime() > self.saved_mtime)
1033 }
1034
1035 pub fn subscribe(&mut self) -> Subscription {
1036 self.text.subscribe()
1037 }
1038
1039 pub fn start_transaction(&mut self) -> Option<TransactionId> {
1040 self.start_transaction_at(Instant::now())
1041 }
1042
1043 pub fn start_transaction_at(&mut self, now: Instant) -> Option<TransactionId> {
1044 self.transaction_depth += 1;
1045 if self.was_dirty_before_starting_transaction.is_none() {
1046 self.was_dirty_before_starting_transaction = Some(self.is_dirty());
1047 }
1048 self.text.start_transaction_at(now)
1049 }
1050
1051 pub fn end_transaction(&mut self, cx: &mut ModelContext<Self>) -> Option<TransactionId> {
1052 self.end_transaction_at(Instant::now(), cx)
1053 }
1054
1055 pub fn end_transaction_at(
1056 &mut self,
1057 now: Instant,
1058 cx: &mut ModelContext<Self>,
1059 ) -> Option<TransactionId> {
1060 assert!(self.transaction_depth > 0);
1061 self.transaction_depth -= 1;
1062 let was_dirty = if self.transaction_depth == 0 {
1063 self.was_dirty_before_starting_transaction.take().unwrap()
1064 } else {
1065 false
1066 };
1067 if let Some((transaction_id, start_version)) = self.text.end_transaction_at(now) {
1068 self.did_edit(&start_version, was_dirty, cx);
1069 Some(transaction_id)
1070 } else {
1071 None
1072 }
1073 }
1074
1075 pub fn push_transaction(&mut self, transaction: Transaction, now: Instant) {
1076 self.text.push_transaction(transaction, now);
1077 }
1078
1079 pub fn finalize_last_transaction(&mut self) -> Option<&Transaction> {
1080 self.text.finalize_last_transaction()
1081 }
1082
1083 pub fn forget_transaction(&mut self, transaction_id: TransactionId) {
1084 self.text.forget_transaction(transaction_id);
1085 }
1086
1087 pub fn wait_for_edits(
1088 &mut self,
1089 edit_ids: impl IntoIterator<Item = clock::Local>,
1090 ) -> impl Future<Output = ()> {
1091 self.text.wait_for_edits(edit_ids)
1092 }
1093
1094 pub fn wait_for_anchors<'a>(
1095 &mut self,
1096 anchors: impl IntoIterator<Item = &'a Anchor>,
1097 ) -> impl Future<Output = ()> {
1098 self.text.wait_for_anchors(anchors)
1099 }
1100
1101 pub fn wait_for_version(&mut self, version: clock::Global) -> impl Future<Output = ()> {
1102 self.text.wait_for_version(version)
1103 }
1104
1105 pub fn set_active_selections(
1106 &mut self,
1107 selections: Arc<[Selection<Anchor>]>,
1108 line_mode: bool,
1109 cx: &mut ModelContext<Self>,
1110 ) {
1111 let lamport_timestamp = self.text.lamport_clock.tick();
1112 self.remote_selections.insert(
1113 self.text.replica_id(),
1114 SelectionSet {
1115 selections: selections.clone(),
1116 lamport_timestamp,
1117 line_mode,
1118 },
1119 );
1120 self.send_operation(
1121 Operation::UpdateSelections {
1122 selections,
1123 line_mode,
1124 lamport_timestamp,
1125 },
1126 cx,
1127 );
1128 }
1129
1130 pub fn remove_active_selections(&mut self, cx: &mut ModelContext<Self>) {
1131 self.set_active_selections(Arc::from([]), false, cx);
1132 }
1133
1134 pub fn set_text<T>(&mut self, text: T, cx: &mut ModelContext<Self>) -> Option<clock::Local>
1135 where
1136 T: Into<Arc<str>>,
1137 {
1138 self.edit_internal([(0..self.len(), text)], None, cx)
1139 }
1140
1141 pub fn edit<I, S, T>(
1142 &mut self,
1143 edits_iter: I,
1144 cx: &mut ModelContext<Self>,
1145 ) -> Option<clock::Local>
1146 where
1147 I: IntoIterator<Item = (Range<S>, T)>,
1148 S: ToOffset,
1149 T: Into<Arc<str>>,
1150 {
1151 self.edit_internal(edits_iter, None, cx)
1152 }
1153
1154 pub fn edit_with_autoindent<I, S, T>(
1155 &mut self,
1156 edits_iter: I,
1157 indent_size: IndentSize,
1158 cx: &mut ModelContext<Self>,
1159 ) -> Option<clock::Local>
1160 where
1161 I: IntoIterator<Item = (Range<S>, T)>,
1162 S: ToOffset,
1163 T: Into<Arc<str>>,
1164 {
1165 self.edit_internal(edits_iter, Some(indent_size), cx)
1166 }
1167
1168 pub fn edit_internal<I, S, T>(
1169 &mut self,
1170 edits_iter: I,
1171 autoindent_size: Option<IndentSize>,
1172 cx: &mut ModelContext<Self>,
1173 ) -> Option<clock::Local>
1174 where
1175 I: IntoIterator<Item = (Range<S>, T)>,
1176 S: ToOffset,
1177 T: Into<Arc<str>>,
1178 {
1179 // Skip invalid edits and coalesce contiguous ones.
1180 let mut edits: Vec<(Range<usize>, Arc<str>)> = Vec::new();
1181 for (range, new_text) in edits_iter {
1182 let mut range = range.start.to_offset(self)..range.end.to_offset(self);
1183 if range.start > range.end {
1184 mem::swap(&mut range.start, &mut range.end);
1185 }
1186 let new_text = new_text.into();
1187 if !new_text.is_empty() || !range.is_empty() {
1188 if let Some((prev_range, prev_text)) = edits.last_mut() {
1189 if prev_range.end >= range.start {
1190 prev_range.end = cmp::max(prev_range.end, range.end);
1191 *prev_text = format!("{prev_text}{new_text}").into();
1192 } else {
1193 edits.push((range, new_text));
1194 }
1195 } else {
1196 edits.push((range, new_text));
1197 }
1198 }
1199 }
1200 if edits.is_empty() {
1201 return None;
1202 }
1203
1204 self.start_transaction();
1205 self.pending_autoindent.take();
1206 let autoindent_request =
1207 self.language
1208 .as_ref()
1209 .and_then(|_| autoindent_size)
1210 .map(|autoindent_size| {
1211 let before_edit = self.snapshot();
1212 let edited = edits
1213 .iter()
1214 .filter_map(|(range, new_text)| {
1215 let start = range.start.to_point(self);
1216 if new_text.starts_with('\n')
1217 && start.column == self.line_len(start.row)
1218 {
1219 None
1220 } else {
1221 Some(self.anchor_before(range.start))
1222 }
1223 })
1224 .collect();
1225 (before_edit, edited, autoindent_size)
1226 });
1227
1228 let edit_operation = self.text.edit(edits.iter().cloned());
1229 let edit_id = edit_operation.local_timestamp();
1230
1231 if let Some((before_edit, edited, size)) = autoindent_request {
1232 let mut delta = 0isize;
1233
1234 let inserted_ranges = edits
1235 .into_iter()
1236 .filter_map(|(range, new_text)| {
1237 let first_newline_ix = new_text.find('\n')?;
1238 let new_text_len = new_text.len();
1239 let start = (delta + range.start as isize) as usize + first_newline_ix + 1;
1240 let end = (delta + range.start as isize) as usize + new_text_len;
1241 delta += new_text_len as isize - (range.end as isize - range.start as isize);
1242 Some(self.anchor_before(start)..self.anchor_after(end))
1243 })
1244 .collect::<Vec<Range<Anchor>>>();
1245
1246 let inserted = if inserted_ranges.is_empty() {
1247 None
1248 } else {
1249 Some(inserted_ranges)
1250 };
1251
1252 self.autoindent_requests.push(Arc::new(AutoindentRequest {
1253 before_edit,
1254 edited,
1255 inserted,
1256 indent_size: size,
1257 }));
1258 }
1259
1260 self.end_transaction(cx);
1261 self.send_operation(Operation::Buffer(edit_operation), cx);
1262 Some(edit_id)
1263 }
1264
1265 fn did_edit(
1266 &mut self,
1267 old_version: &clock::Global,
1268 was_dirty: bool,
1269 cx: &mut ModelContext<Self>,
1270 ) {
1271 if self.edits_since::<usize>(old_version).next().is_none() {
1272 return;
1273 }
1274
1275 self.reparse(cx);
1276
1277 cx.emit(Event::Edited);
1278 if was_dirty != self.is_dirty() {
1279 cx.emit(Event::DirtyChanged);
1280 }
1281 cx.notify();
1282 }
1283
1284 fn grammar(&self) -> Option<&Arc<Grammar>> {
1285 self.language.as_ref().and_then(|l| l.grammar.as_ref())
1286 }
1287
1288 pub fn apply_ops<I: IntoIterator<Item = Operation>>(
1289 &mut self,
1290 ops: I,
1291 cx: &mut ModelContext<Self>,
1292 ) -> Result<()> {
1293 self.pending_autoindent.take();
1294 let was_dirty = self.is_dirty();
1295 let old_version = self.version.clone();
1296 let mut deferred_ops = Vec::new();
1297 let buffer_ops = ops
1298 .into_iter()
1299 .filter_map(|op| match op {
1300 Operation::Buffer(op) => Some(op),
1301 _ => {
1302 if self.can_apply_op(&op) {
1303 self.apply_op(op, cx);
1304 } else {
1305 deferred_ops.push(op);
1306 }
1307 None
1308 }
1309 })
1310 .collect::<Vec<_>>();
1311 self.text.apply_ops(buffer_ops)?;
1312 self.deferred_ops.insert(deferred_ops);
1313 self.flush_deferred_ops(cx);
1314 self.did_edit(&old_version, was_dirty, cx);
1315 // Notify independently of whether the buffer was edited as the operations could include a
1316 // selection update.
1317 cx.notify();
1318 Ok(())
1319 }
1320
1321 fn flush_deferred_ops(&mut self, cx: &mut ModelContext<Self>) {
1322 let mut deferred_ops = Vec::new();
1323 for op in self.deferred_ops.drain().iter().cloned() {
1324 if self.can_apply_op(&op) {
1325 self.apply_op(op, cx);
1326 } else {
1327 deferred_ops.push(op);
1328 }
1329 }
1330 self.deferred_ops.insert(deferred_ops);
1331 }
1332
1333 fn can_apply_op(&self, operation: &Operation) -> bool {
1334 match operation {
1335 Operation::Buffer(_) => {
1336 unreachable!("buffer operations should never be applied at this layer")
1337 }
1338 Operation::UpdateDiagnostics {
1339 diagnostics: diagnostic_set,
1340 ..
1341 } => diagnostic_set.iter().all(|diagnostic| {
1342 self.text.can_resolve(&diagnostic.range.start)
1343 && self.text.can_resolve(&diagnostic.range.end)
1344 }),
1345 Operation::UpdateSelections { selections, .. } => selections
1346 .iter()
1347 .all(|s| self.can_resolve(&s.start) && self.can_resolve(&s.end)),
1348 Operation::UpdateCompletionTriggers { .. } => true,
1349 }
1350 }
1351
1352 fn apply_op(&mut self, operation: Operation, cx: &mut ModelContext<Self>) {
1353 match operation {
1354 Operation::Buffer(_) => {
1355 unreachable!("buffer operations should never be applied at this layer")
1356 }
1357 Operation::UpdateDiagnostics {
1358 diagnostics: diagnostic_set,
1359 lamport_timestamp,
1360 } => {
1361 let snapshot = self.snapshot();
1362 self.apply_diagnostic_update(
1363 DiagnosticSet::from_sorted_entries(diagnostic_set.iter().cloned(), &snapshot),
1364 lamport_timestamp,
1365 cx,
1366 );
1367 }
1368 Operation::UpdateSelections {
1369 selections,
1370 lamport_timestamp,
1371 line_mode,
1372 } => {
1373 if let Some(set) = self.remote_selections.get(&lamport_timestamp.replica_id) {
1374 if set.lamport_timestamp > lamport_timestamp {
1375 return;
1376 }
1377 }
1378
1379 self.remote_selections.insert(
1380 lamport_timestamp.replica_id,
1381 SelectionSet {
1382 selections,
1383 lamport_timestamp,
1384 line_mode,
1385 },
1386 );
1387 self.text.lamport_clock.observe(lamport_timestamp);
1388 self.selections_update_count += 1;
1389 }
1390 Operation::UpdateCompletionTriggers {
1391 triggers,
1392 lamport_timestamp,
1393 } => {
1394 self.completion_triggers = triggers;
1395 self.text.lamport_clock.observe(lamport_timestamp);
1396 }
1397 }
1398 }
1399
1400 fn apply_diagnostic_update(
1401 &mut self,
1402 diagnostics: DiagnosticSet,
1403 lamport_timestamp: clock::Lamport,
1404 cx: &mut ModelContext<Self>,
1405 ) {
1406 if lamport_timestamp > self.diagnostics_timestamp {
1407 self.diagnostics = diagnostics;
1408 self.diagnostics_timestamp = lamport_timestamp;
1409 self.diagnostics_update_count += 1;
1410 self.text.lamport_clock.observe(lamport_timestamp);
1411 cx.notify();
1412 cx.emit(Event::DiagnosticsUpdated);
1413 }
1414 }
1415
1416 fn send_operation(&mut self, operation: Operation, cx: &mut ModelContext<Self>) {
1417 cx.emit(Event::Operation(operation));
1418 }
1419
1420 pub fn remove_peer(&mut self, replica_id: ReplicaId, cx: &mut ModelContext<Self>) {
1421 self.remote_selections.remove(&replica_id);
1422 cx.notify();
1423 }
1424
1425 pub fn undo(&mut self, cx: &mut ModelContext<Self>) -> Option<TransactionId> {
1426 let was_dirty = self.is_dirty();
1427 let old_version = self.version.clone();
1428
1429 if let Some((transaction_id, operation)) = self.text.undo() {
1430 self.send_operation(Operation::Buffer(operation), cx);
1431 self.did_edit(&old_version, was_dirty, cx);
1432 Some(transaction_id)
1433 } else {
1434 None
1435 }
1436 }
1437
1438 pub fn undo_to_transaction(
1439 &mut self,
1440 transaction_id: TransactionId,
1441 cx: &mut ModelContext<Self>,
1442 ) -> bool {
1443 let was_dirty = self.is_dirty();
1444 let old_version = self.version.clone();
1445
1446 let operations = self.text.undo_to_transaction(transaction_id);
1447 let undone = !operations.is_empty();
1448 for operation in operations {
1449 self.send_operation(Operation::Buffer(operation), cx);
1450 }
1451 if undone {
1452 self.did_edit(&old_version, was_dirty, cx)
1453 }
1454 undone
1455 }
1456
1457 pub fn redo(&mut self, cx: &mut ModelContext<Self>) -> Option<TransactionId> {
1458 let was_dirty = self.is_dirty();
1459 let old_version = self.version.clone();
1460
1461 if let Some((transaction_id, operation)) = self.text.redo() {
1462 self.send_operation(Operation::Buffer(operation), cx);
1463 self.did_edit(&old_version, was_dirty, cx);
1464 Some(transaction_id)
1465 } else {
1466 None
1467 }
1468 }
1469
1470 pub fn redo_to_transaction(
1471 &mut self,
1472 transaction_id: TransactionId,
1473 cx: &mut ModelContext<Self>,
1474 ) -> bool {
1475 let was_dirty = self.is_dirty();
1476 let old_version = self.version.clone();
1477
1478 let operations = self.text.redo_to_transaction(transaction_id);
1479 let redone = !operations.is_empty();
1480 for operation in operations {
1481 self.send_operation(Operation::Buffer(operation), cx);
1482 }
1483 if redone {
1484 self.did_edit(&old_version, was_dirty, cx)
1485 }
1486 redone
1487 }
1488
1489 pub fn set_completion_triggers(&mut self, triggers: Vec<String>, cx: &mut ModelContext<Self>) {
1490 self.completion_triggers = triggers.clone();
1491 let lamport_timestamp = self.text.lamport_clock.tick();
1492 self.send_operation(
1493 Operation::UpdateCompletionTriggers {
1494 triggers,
1495 lamport_timestamp,
1496 },
1497 cx,
1498 );
1499 cx.notify();
1500 }
1501
1502 pub fn completion_triggers(&self) -> &[String] {
1503 &self.completion_triggers
1504 }
1505}
1506
1507#[cfg(any(test, feature = "test-support"))]
1508impl Buffer {
1509 pub fn set_group_interval(&mut self, group_interval: Duration) {
1510 self.text.set_group_interval(group_interval);
1511 }
1512
1513 pub fn randomly_edit<T>(
1514 &mut self,
1515 rng: &mut T,
1516 old_range_count: usize,
1517 cx: &mut ModelContext<Self>,
1518 ) where
1519 T: rand::Rng,
1520 {
1521 let mut edits: Vec<(Range<usize>, String)> = Vec::new();
1522 let mut last_end = None;
1523 for _ in 0..old_range_count {
1524 if last_end.map_or(false, |last_end| last_end >= self.len()) {
1525 break;
1526 }
1527
1528 let new_start = last_end.map_or(0, |last_end| last_end + 1);
1529 let mut range = self.random_byte_range(new_start, rng);
1530 if rng.gen_bool(0.2) {
1531 mem::swap(&mut range.start, &mut range.end);
1532 }
1533 last_end = Some(range.end);
1534
1535 let new_text_len = rng.gen_range(0..10);
1536 let new_text: String = crate::random_char_iter::RandomCharIter::new(&mut *rng)
1537 .take(new_text_len)
1538 .collect();
1539
1540 edits.push((range, new_text));
1541 }
1542 log::info!("mutating buffer {} with {:?}", self.replica_id(), edits);
1543 self.edit(edits, cx);
1544 }
1545
1546 pub fn randomly_undo_redo(&mut self, rng: &mut impl rand::Rng, cx: &mut ModelContext<Self>) {
1547 let was_dirty = self.is_dirty();
1548 let old_version = self.version.clone();
1549
1550 let ops = self.text.randomly_undo_redo(rng);
1551 if !ops.is_empty() {
1552 for op in ops {
1553 self.send_operation(Operation::Buffer(op), cx);
1554 self.did_edit(&old_version, was_dirty, cx);
1555 }
1556 }
1557 }
1558}
1559
1560impl Entity for Buffer {
1561 type Event = Event;
1562}
1563
1564impl Deref for Buffer {
1565 type Target = TextBuffer;
1566
1567 fn deref(&self) -> &Self::Target {
1568 &self.text
1569 }
1570}
1571
1572impl BufferSnapshot {
1573 pub fn indent_size_for_line(&self, row: u32) -> IndentSize {
1574 indent_size_for_line(&self, row)
1575 }
1576
1577 fn suggest_autoindents<'a>(
1578 &'a self,
1579 row_range: Range<u32>,
1580 ) -> Option<impl Iterator<Item = Option<IndentSuggestion>> + 'a> {
1581 let language = self.language.as_ref()?;
1582 let grammar = language.grammar.as_ref()?;
1583 let config = &language.config;
1584 let prev_non_blank_row = self.prev_non_blank_row(row_range.start);
1585
1586 // Find the suggested indentation ranges based on the syntax tree.
1587 let indents_query = grammar.indents_query.as_ref()?;
1588 let mut query_cursor = QueryCursorHandle::new();
1589 let indent_capture_ix = indents_query.capture_index_for_name("indent");
1590 let end_capture_ix = indents_query.capture_index_for_name("end");
1591 query_cursor.set_point_range(
1592 Point::new(prev_non_blank_row.unwrap_or(row_range.start), 0).to_ts_point()
1593 ..Point::new(row_range.end, 0).to_ts_point(),
1594 );
1595
1596 let mut indent_ranges = Vec::<Range<Point>>::new();
1597 for mat in query_cursor.matches(
1598 indents_query,
1599 self.tree.as_ref()?.root_node(),
1600 TextProvider(self.as_rope()),
1601 ) {
1602 let mut start: Option<Point> = None;
1603 let mut end: Option<Point> = None;
1604 for capture in mat.captures {
1605 if Some(capture.index) == indent_capture_ix {
1606 start.get_or_insert(Point::from_ts_point(capture.node.start_position()));
1607 end.get_or_insert(Point::from_ts_point(capture.node.end_position()));
1608 } else if Some(capture.index) == end_capture_ix {
1609 end = Some(Point::from_ts_point(capture.node.start_position().into()));
1610 }
1611 }
1612
1613 if let Some((start, end)) = start.zip(end) {
1614 if start.row == end.row {
1615 continue;
1616 }
1617
1618 let range = start..end;
1619 match indent_ranges.binary_search_by_key(&range.start, |r| r.start) {
1620 Err(ix) => indent_ranges.insert(ix, range),
1621 Ok(ix) => {
1622 let prev_range = &mut indent_ranges[ix];
1623 prev_range.end = prev_range.end.max(range.end);
1624 }
1625 }
1626 }
1627 }
1628
1629 // Find the suggested indentation increases and decreased based on regexes.
1630 let mut indent_change_rows = Vec::<(u32, Ordering)>::new();
1631 self.for_each_line(
1632 Point::new(prev_non_blank_row.unwrap_or(row_range.start), 0)
1633 ..Point::new(row_range.end, 0),
1634 |row, line| {
1635 if config
1636 .decrease_indent_pattern
1637 .as_ref()
1638 .map_or(false, |regex| regex.is_match(line))
1639 {
1640 indent_change_rows.push((row, Ordering::Less));
1641 }
1642 if config
1643 .increase_indent_pattern
1644 .as_ref()
1645 .map_or(false, |regex| regex.is_match(line))
1646 {
1647 indent_change_rows.push((row + 1, Ordering::Greater));
1648 }
1649 },
1650 );
1651
1652 let mut indent_changes = indent_change_rows.into_iter().peekable();
1653 let mut prev_row = if config.auto_indent_using_last_non_empty_line {
1654 prev_non_blank_row.unwrap_or(0)
1655 } else {
1656 row_range.start.saturating_sub(1)
1657 };
1658 let mut prev_row_start = Point::new(prev_row, self.indent_size_for_line(prev_row).len);
1659 Some(row_range.map(move |row| {
1660 let row_start = Point::new(row, self.indent_size_for_line(row).len);
1661
1662 let mut indent_from_prev_row = false;
1663 let mut outdent_from_prev_row = false;
1664 let mut outdent_to_row = u32::MAX;
1665
1666 while let Some((indent_row, delta)) = indent_changes.peek() {
1667 if *indent_row == row {
1668 match delta {
1669 Ordering::Less => outdent_from_prev_row = true,
1670 Ordering::Greater => indent_from_prev_row = true,
1671 _ => {}
1672 }
1673 } else if *indent_row > row {
1674 break;
1675 }
1676 indent_changes.next();
1677 }
1678
1679 for range in &indent_ranges {
1680 if range.start.row >= row {
1681 break;
1682 }
1683 if range.start.row == prev_row && range.end > row_start {
1684 indent_from_prev_row = true;
1685 }
1686 if range.end > prev_row_start && range.end <= row_start {
1687 outdent_to_row = outdent_to_row.min(range.start.row);
1688 }
1689 }
1690
1691 let suggestion = if outdent_to_row == prev_row
1692 || (outdent_from_prev_row && indent_from_prev_row)
1693 {
1694 Some(IndentSuggestion {
1695 basis_row: prev_row,
1696 delta: Ordering::Equal,
1697 })
1698 } else if indent_from_prev_row {
1699 Some(IndentSuggestion {
1700 basis_row: prev_row,
1701 delta: Ordering::Greater,
1702 })
1703 } else if outdent_to_row < prev_row {
1704 Some(IndentSuggestion {
1705 basis_row: outdent_to_row,
1706 delta: Ordering::Equal,
1707 })
1708 } else if outdent_from_prev_row {
1709 Some(IndentSuggestion {
1710 basis_row: prev_row,
1711 delta: Ordering::Less,
1712 })
1713 } else if config.auto_indent_using_last_non_empty_line || !self.is_line_blank(prev_row)
1714 {
1715 Some(IndentSuggestion {
1716 basis_row: prev_row,
1717 delta: Ordering::Equal,
1718 })
1719 } else {
1720 None
1721 };
1722
1723 prev_row = row;
1724 prev_row_start = row_start;
1725 suggestion
1726 }))
1727 }
1728
1729 fn prev_non_blank_row(&self, mut row: u32) -> Option<u32> {
1730 while row > 0 {
1731 row -= 1;
1732 if !self.is_line_blank(row) {
1733 return Some(row);
1734 }
1735 }
1736 None
1737 }
1738
1739 pub fn chunks<'a, T: ToOffset>(
1740 &'a self,
1741 range: Range<T>,
1742 language_aware: bool,
1743 ) -> BufferChunks<'a> {
1744 let range = range.start.to_offset(self)..range.end.to_offset(self);
1745
1746 let mut tree = None;
1747 let mut diagnostic_endpoints = Vec::new();
1748 if language_aware {
1749 tree = self.tree.as_ref();
1750 for entry in self.diagnostics_in_range::<_, usize>(range.clone(), false) {
1751 diagnostic_endpoints.push(DiagnosticEndpoint {
1752 offset: entry.range.start,
1753 is_start: true,
1754 severity: entry.diagnostic.severity,
1755 is_unnecessary: entry.diagnostic.is_unnecessary,
1756 });
1757 diagnostic_endpoints.push(DiagnosticEndpoint {
1758 offset: entry.range.end,
1759 is_start: false,
1760 severity: entry.diagnostic.severity,
1761 is_unnecessary: entry.diagnostic.is_unnecessary,
1762 });
1763 }
1764 diagnostic_endpoints
1765 .sort_unstable_by_key(|endpoint| (endpoint.offset, !endpoint.is_start));
1766 }
1767
1768 BufferChunks::new(
1769 self.text.as_rope(),
1770 range,
1771 tree,
1772 self.grammar(),
1773 diagnostic_endpoints,
1774 )
1775 }
1776
1777 pub fn for_each_line<'a>(&'a self, range: Range<Point>, mut callback: impl FnMut(u32, &str)) {
1778 let mut line = String::new();
1779 let mut row = range.start.row;
1780 for chunk in self
1781 .as_rope()
1782 .chunks_in_range(range.to_offset(self))
1783 .chain(["\n"])
1784 {
1785 for (newline_ix, text) in chunk.split('\n').enumerate() {
1786 if newline_ix > 0 {
1787 callback(row, &line);
1788 row += 1;
1789 line.clear();
1790 }
1791 line.push_str(text);
1792 }
1793 }
1794 }
1795
1796 pub fn language(&self) -> Option<&Arc<Language>> {
1797 self.language.as_ref()
1798 }
1799
1800 fn grammar(&self) -> Option<&Arc<Grammar>> {
1801 self.language
1802 .as_ref()
1803 .and_then(|language| language.grammar.as_ref())
1804 }
1805
1806 pub fn surrounding_word<T: ToOffset>(&self, start: T) -> (Range<usize>, Option<CharKind>) {
1807 let mut start = start.to_offset(self);
1808 let mut end = start;
1809 let mut next_chars = self.chars_at(start).peekable();
1810 let mut prev_chars = self.reversed_chars_at(start).peekable();
1811 let word_kind = cmp::max(
1812 prev_chars.peek().copied().map(char_kind),
1813 next_chars.peek().copied().map(char_kind),
1814 );
1815
1816 for ch in prev_chars {
1817 if Some(char_kind(ch)) == word_kind && ch != '\n' {
1818 start -= ch.len_utf8();
1819 } else {
1820 break;
1821 }
1822 }
1823
1824 for ch in next_chars {
1825 if Some(char_kind(ch)) == word_kind && ch != '\n' {
1826 end += ch.len_utf8();
1827 } else {
1828 break;
1829 }
1830 }
1831
1832 (start..end, word_kind)
1833 }
1834
1835 pub fn range_for_syntax_ancestor<T: ToOffset>(&self, range: Range<T>) -> Option<Range<usize>> {
1836 let tree = self.tree.as_ref()?;
1837 let range = range.start.to_offset(self)..range.end.to_offset(self);
1838 let mut cursor = tree.root_node().walk();
1839
1840 // Descend to the first leaf that touches the start of the range,
1841 // and if the range is non-empty, extends beyond the start.
1842 while cursor.goto_first_child_for_byte(range.start).is_some() {
1843 if !range.is_empty() && cursor.node().end_byte() == range.start {
1844 cursor.goto_next_sibling();
1845 }
1846 }
1847
1848 // Ascend to the smallest ancestor that strictly contains the range.
1849 loop {
1850 let node_range = cursor.node().byte_range();
1851 if node_range.start <= range.start
1852 && node_range.end >= range.end
1853 && node_range.len() > range.len()
1854 {
1855 break;
1856 }
1857 if !cursor.goto_parent() {
1858 break;
1859 }
1860 }
1861
1862 let left_node = cursor.node();
1863
1864 // For an empty range, try to find another node immediately to the right of the range.
1865 if left_node.end_byte() == range.start {
1866 let mut right_node = None;
1867 while !cursor.goto_next_sibling() {
1868 if !cursor.goto_parent() {
1869 break;
1870 }
1871 }
1872
1873 while cursor.node().start_byte() == range.start {
1874 right_node = Some(cursor.node());
1875 if !cursor.goto_first_child() {
1876 break;
1877 }
1878 }
1879
1880 // If there is a candidate node on both sides of the (empty) range, then
1881 // decide between the two by favoring a named node over an anonymous token.
1882 // If both nodes are the same in that regard, favor the right one.
1883 if let Some(right_node) = right_node {
1884 if right_node.is_named() || !left_node.is_named() {
1885 return Some(right_node.byte_range());
1886 }
1887 }
1888 }
1889
1890 Some(left_node.byte_range())
1891 }
1892
1893 pub fn outline(&self, theme: Option<&SyntaxTheme>) -> Option<Outline<Anchor>> {
1894 self.outline_items_containing(0..self.len(), theme)
1895 .map(Outline::new)
1896 }
1897
1898 pub fn symbols_containing<T: ToOffset>(
1899 &self,
1900 position: T,
1901 theme: Option<&SyntaxTheme>,
1902 ) -> Option<Vec<OutlineItem<Anchor>>> {
1903 let position = position.to_offset(&self);
1904 let mut items =
1905 self.outline_items_containing(position.saturating_sub(1)..position + 1, theme)?;
1906 let mut prev_depth = None;
1907 items.retain(|item| {
1908 let result = prev_depth.map_or(true, |prev_depth| item.depth > prev_depth);
1909 prev_depth = Some(item.depth);
1910 result
1911 });
1912 Some(items)
1913 }
1914
1915 fn outline_items_containing(
1916 &self,
1917 range: Range<usize>,
1918 theme: Option<&SyntaxTheme>,
1919 ) -> Option<Vec<OutlineItem<Anchor>>> {
1920 let tree = self.tree.as_ref()?;
1921 let grammar = self
1922 .language
1923 .as_ref()
1924 .and_then(|language| language.grammar.as_ref())?;
1925
1926 let outline_query = grammar.outline_query.as_ref()?;
1927 let mut cursor = QueryCursorHandle::new();
1928 cursor.set_byte_range(range.clone());
1929 let matches = cursor.matches(
1930 outline_query,
1931 tree.root_node(),
1932 TextProvider(self.as_rope()),
1933 );
1934
1935 let mut chunks = self.chunks(0..self.len(), true);
1936
1937 let item_capture_ix = outline_query.capture_index_for_name("item")?;
1938 let name_capture_ix = outline_query.capture_index_for_name("name")?;
1939 let context_capture_ix = outline_query
1940 .capture_index_for_name("context")
1941 .unwrap_or(u32::MAX);
1942
1943 let mut stack = Vec::<Range<usize>>::new();
1944 let items = matches
1945 .filter_map(|mat| {
1946 let item_node = mat.nodes_for_capture_index(item_capture_ix).next()?;
1947 let item_range = item_node.start_byte()..item_node.end_byte();
1948 if item_range.end < range.start || item_range.start > range.end {
1949 return None;
1950 }
1951 let mut text = String::new();
1952 let mut name_ranges = Vec::new();
1953 let mut highlight_ranges = Vec::new();
1954
1955 for capture in mat.captures {
1956 let node_is_name;
1957 if capture.index == name_capture_ix {
1958 node_is_name = true;
1959 } else if capture.index == context_capture_ix {
1960 node_is_name = false;
1961 } else {
1962 continue;
1963 }
1964
1965 let range = capture.node.start_byte()..capture.node.end_byte();
1966 if !text.is_empty() {
1967 text.push(' ');
1968 }
1969 if node_is_name {
1970 let mut start = text.len();
1971 let end = start + range.len();
1972
1973 // When multiple names are captured, then the matcheable text
1974 // includes the whitespace in between the names.
1975 if !name_ranges.is_empty() {
1976 start -= 1;
1977 }
1978
1979 name_ranges.push(start..end);
1980 }
1981
1982 let mut offset = range.start;
1983 chunks.seek(offset);
1984 while let Some(mut chunk) = chunks.next() {
1985 if chunk.text.len() > range.end - offset {
1986 chunk.text = &chunk.text[0..(range.end - offset)];
1987 offset = range.end;
1988 } else {
1989 offset += chunk.text.len();
1990 }
1991 let style = chunk
1992 .syntax_highlight_id
1993 .zip(theme)
1994 .and_then(|(highlight, theme)| highlight.style(theme));
1995 if let Some(style) = style {
1996 let start = text.len();
1997 let end = start + chunk.text.len();
1998 highlight_ranges.push((start..end, style));
1999 }
2000 text.push_str(chunk.text);
2001 if offset >= range.end {
2002 break;
2003 }
2004 }
2005 }
2006
2007 while stack.last().map_or(false, |prev_range| {
2008 prev_range.start > item_range.start || prev_range.end < item_range.end
2009 }) {
2010 stack.pop();
2011 }
2012 stack.push(item_range.clone());
2013
2014 Some(OutlineItem {
2015 depth: stack.len() - 1,
2016 range: self.anchor_after(item_range.start)..self.anchor_before(item_range.end),
2017 text,
2018 highlight_ranges,
2019 name_ranges,
2020 })
2021 })
2022 .collect::<Vec<_>>();
2023 Some(items)
2024 }
2025
2026 pub fn enclosing_bracket_ranges<T: ToOffset>(
2027 &self,
2028 range: Range<T>,
2029 ) -> Option<(Range<usize>, Range<usize>)> {
2030 let (grammar, tree) = self.grammar().zip(self.tree.as_ref())?;
2031 let brackets_query = grammar.brackets_query.as_ref()?;
2032 let open_capture_ix = brackets_query.capture_index_for_name("open")?;
2033 let close_capture_ix = brackets_query.capture_index_for_name("close")?;
2034
2035 // Find bracket pairs that *inclusively* contain the given range.
2036 let range = range.start.to_offset(self).saturating_sub(1)..range.end.to_offset(self) + 1;
2037 let mut cursor = QueryCursorHandle::new();
2038 let matches = cursor.set_byte_range(range).matches(
2039 &brackets_query,
2040 tree.root_node(),
2041 TextProvider(self.as_rope()),
2042 );
2043
2044 // Get the ranges of the innermost pair of brackets.
2045 matches
2046 .filter_map(|mat| {
2047 let open = mat.nodes_for_capture_index(open_capture_ix).next()?;
2048 let close = mat.nodes_for_capture_index(close_capture_ix).next()?;
2049 Some((open.byte_range(), close.byte_range()))
2050 })
2051 .min_by_key(|(open_range, close_range)| close_range.end - open_range.start)
2052 }
2053
2054 pub fn remote_selections_in_range<'a>(
2055 &'a self,
2056 range: Range<Anchor>,
2057 ) -> impl 'a
2058 + Iterator<
2059 Item = (
2060 ReplicaId,
2061 bool,
2062 impl 'a + Iterator<Item = &'a Selection<Anchor>>,
2063 ),
2064 > {
2065 self.remote_selections
2066 .iter()
2067 .filter(|(replica_id, set)| {
2068 **replica_id != self.text.replica_id() && !set.selections.is_empty()
2069 })
2070 .map(move |(replica_id, set)| {
2071 let start_ix = match set.selections.binary_search_by(|probe| {
2072 probe.end.cmp(&range.start, self).then(Ordering::Greater)
2073 }) {
2074 Ok(ix) | Err(ix) => ix,
2075 };
2076 let end_ix = match set.selections.binary_search_by(|probe| {
2077 probe.start.cmp(&range.end, self).then(Ordering::Less)
2078 }) {
2079 Ok(ix) | Err(ix) => ix,
2080 };
2081
2082 (
2083 *replica_id,
2084 set.line_mode,
2085 set.selections[start_ix..end_ix].iter(),
2086 )
2087 })
2088 }
2089
2090 pub fn diagnostics_in_range<'a, T, O>(
2091 &'a self,
2092 search_range: Range<T>,
2093 reversed: bool,
2094 ) -> impl 'a + Iterator<Item = DiagnosticEntry<O>>
2095 where
2096 T: 'a + Clone + ToOffset,
2097 O: 'a + FromAnchor,
2098 {
2099 self.diagnostics
2100 .range(search_range.clone(), self, true, reversed)
2101 }
2102
2103 pub fn diagnostic_groups(&self) -> Vec<DiagnosticGroup<Anchor>> {
2104 let mut groups = Vec::new();
2105 self.diagnostics.groups(&mut groups, self);
2106 groups
2107 }
2108
2109 pub fn diagnostic_group<'a, O>(
2110 &'a self,
2111 group_id: usize,
2112 ) -> impl 'a + Iterator<Item = DiagnosticEntry<O>>
2113 where
2114 O: 'a + FromAnchor,
2115 {
2116 self.diagnostics.group(group_id, self)
2117 }
2118
2119 pub fn diagnostics_update_count(&self) -> usize {
2120 self.diagnostics_update_count
2121 }
2122
2123 pub fn parse_count(&self) -> usize {
2124 self.parse_count
2125 }
2126
2127 pub fn selections_update_count(&self) -> usize {
2128 self.selections_update_count
2129 }
2130
2131 pub fn file(&self) -> Option<&dyn File> {
2132 self.file.as_deref()
2133 }
2134
2135 pub fn file_update_count(&self) -> usize {
2136 self.file_update_count
2137 }
2138}
2139
2140pub fn indent_size_for_line(text: &text::BufferSnapshot, row: u32) -> IndentSize {
2141 let mut result = IndentSize::spaces(0);
2142 for c in text.chars_at(Point::new(row, 0)) {
2143 let kind = match c {
2144 ' ' => IndentKind::Space,
2145 '\t' => IndentKind::Tab,
2146 _ => break,
2147 };
2148 if result.len == 0 {
2149 result.kind = kind;
2150 }
2151 result.len += 1;
2152 }
2153 result
2154}
2155
2156impl Clone for BufferSnapshot {
2157 fn clone(&self) -> Self {
2158 Self {
2159 text: self.text.clone(),
2160 tree: self.tree.clone(),
2161 file: self.file.clone(),
2162 remote_selections: self.remote_selections.clone(),
2163 diagnostics: self.diagnostics.clone(),
2164 selections_update_count: self.selections_update_count,
2165 diagnostics_update_count: self.diagnostics_update_count,
2166 file_update_count: self.file_update_count,
2167 language: self.language.clone(),
2168 parse_count: self.parse_count,
2169 }
2170 }
2171}
2172
2173impl Deref for BufferSnapshot {
2174 type Target = text::BufferSnapshot;
2175
2176 fn deref(&self) -> &Self::Target {
2177 &self.text
2178 }
2179}
2180
2181impl<'a> tree_sitter::TextProvider<'a> for TextProvider<'a> {
2182 type I = ByteChunks<'a>;
2183
2184 fn text(&mut self, node: tree_sitter::Node) -> Self::I {
2185 ByteChunks(self.0.chunks_in_range(node.byte_range()))
2186 }
2187}
2188
2189pub(crate) struct ByteChunks<'a>(rope::Chunks<'a>);
2190
2191impl<'a> Iterator for ByteChunks<'a> {
2192 type Item = &'a [u8];
2193
2194 fn next(&mut self) -> Option<Self::Item> {
2195 self.0.next().map(str::as_bytes)
2196 }
2197}
2198
2199unsafe impl<'a> Send for BufferChunks<'a> {}
2200
2201impl<'a> BufferChunks<'a> {
2202 pub(crate) fn new(
2203 text: &'a Rope,
2204 range: Range<usize>,
2205 tree: Option<&'a Tree>,
2206 grammar: Option<&'a Arc<Grammar>>,
2207 diagnostic_endpoints: Vec<DiagnosticEndpoint>,
2208 ) -> Self {
2209 let mut highlights = None;
2210 if let Some((grammar, tree)) = grammar.zip(tree) {
2211 if let Some(highlights_query) = grammar.highlights_query.as_ref() {
2212 let mut query_cursor = QueryCursorHandle::new();
2213
2214 // TODO - add a Tree-sitter API to remove the need for this.
2215 let cursor = unsafe {
2216 std::mem::transmute::<_, &'static mut QueryCursor>(query_cursor.deref_mut())
2217 };
2218 let captures = cursor.set_byte_range(range.clone()).captures(
2219 highlights_query,
2220 tree.root_node(),
2221 TextProvider(text),
2222 );
2223 highlights = Some(BufferChunkHighlights {
2224 captures,
2225 next_capture: None,
2226 stack: Default::default(),
2227 highlight_map: grammar.highlight_map(),
2228 _query_cursor: query_cursor,
2229 })
2230 }
2231 }
2232
2233 let diagnostic_endpoints = diagnostic_endpoints.into_iter().peekable();
2234 let chunks = text.chunks_in_range(range.clone());
2235
2236 BufferChunks {
2237 range,
2238 chunks,
2239 diagnostic_endpoints,
2240 error_depth: 0,
2241 warning_depth: 0,
2242 information_depth: 0,
2243 hint_depth: 0,
2244 unnecessary_depth: 0,
2245 highlights,
2246 }
2247 }
2248
2249 pub fn seek(&mut self, offset: usize) {
2250 self.range.start = offset;
2251 self.chunks.seek(self.range.start);
2252 if let Some(highlights) = self.highlights.as_mut() {
2253 highlights
2254 .stack
2255 .retain(|(end_offset, _)| *end_offset > offset);
2256 if let Some((mat, capture_ix)) = &highlights.next_capture {
2257 let capture = mat.captures[*capture_ix as usize];
2258 if offset >= capture.node.start_byte() {
2259 let next_capture_end = capture.node.end_byte();
2260 if offset < next_capture_end {
2261 highlights.stack.push((
2262 next_capture_end,
2263 highlights.highlight_map.get(capture.index),
2264 ));
2265 }
2266 highlights.next_capture.take();
2267 }
2268 }
2269 highlights.captures.set_byte_range(self.range.clone());
2270 }
2271 }
2272
2273 pub fn offset(&self) -> usize {
2274 self.range.start
2275 }
2276
2277 fn update_diagnostic_depths(&mut self, endpoint: DiagnosticEndpoint) {
2278 let depth = match endpoint.severity {
2279 DiagnosticSeverity::ERROR => &mut self.error_depth,
2280 DiagnosticSeverity::WARNING => &mut self.warning_depth,
2281 DiagnosticSeverity::INFORMATION => &mut self.information_depth,
2282 DiagnosticSeverity::HINT => &mut self.hint_depth,
2283 _ => return,
2284 };
2285 if endpoint.is_start {
2286 *depth += 1;
2287 } else {
2288 *depth -= 1;
2289 }
2290
2291 if endpoint.is_unnecessary {
2292 if endpoint.is_start {
2293 self.unnecessary_depth += 1;
2294 } else {
2295 self.unnecessary_depth -= 1;
2296 }
2297 }
2298 }
2299
2300 fn current_diagnostic_severity(&self) -> Option<DiagnosticSeverity> {
2301 if self.error_depth > 0 {
2302 Some(DiagnosticSeverity::ERROR)
2303 } else if self.warning_depth > 0 {
2304 Some(DiagnosticSeverity::WARNING)
2305 } else if self.information_depth > 0 {
2306 Some(DiagnosticSeverity::INFORMATION)
2307 } else if self.hint_depth > 0 {
2308 Some(DiagnosticSeverity::HINT)
2309 } else {
2310 None
2311 }
2312 }
2313
2314 fn current_code_is_unnecessary(&self) -> bool {
2315 self.unnecessary_depth > 0
2316 }
2317}
2318
2319impl<'a> Iterator for BufferChunks<'a> {
2320 type Item = Chunk<'a>;
2321
2322 fn next(&mut self) -> Option<Self::Item> {
2323 let mut next_capture_start = usize::MAX;
2324 let mut next_diagnostic_endpoint = usize::MAX;
2325
2326 if let Some(highlights) = self.highlights.as_mut() {
2327 while let Some((parent_capture_end, _)) = highlights.stack.last() {
2328 if *parent_capture_end <= self.range.start {
2329 highlights.stack.pop();
2330 } else {
2331 break;
2332 }
2333 }
2334
2335 if highlights.next_capture.is_none() {
2336 highlights.next_capture = highlights.captures.next();
2337 }
2338
2339 while let Some((mat, capture_ix)) = highlights.next_capture.as_ref() {
2340 let capture = mat.captures[*capture_ix as usize];
2341 if self.range.start < capture.node.start_byte() {
2342 next_capture_start = capture.node.start_byte();
2343 break;
2344 } else {
2345 let highlight_id = highlights.highlight_map.get(capture.index);
2346 highlights
2347 .stack
2348 .push((capture.node.end_byte(), highlight_id));
2349 highlights.next_capture = highlights.captures.next();
2350 }
2351 }
2352 }
2353
2354 while let Some(endpoint) = self.diagnostic_endpoints.peek().copied() {
2355 if endpoint.offset <= self.range.start {
2356 self.update_diagnostic_depths(endpoint);
2357 self.diagnostic_endpoints.next();
2358 } else {
2359 next_diagnostic_endpoint = endpoint.offset;
2360 break;
2361 }
2362 }
2363
2364 if let Some(chunk) = self.chunks.peek() {
2365 let chunk_start = self.range.start;
2366 let mut chunk_end = (self.chunks.offset() + chunk.len())
2367 .min(next_capture_start)
2368 .min(next_diagnostic_endpoint);
2369 let mut highlight_id = None;
2370 if let Some(highlights) = self.highlights.as_ref() {
2371 if let Some((parent_capture_end, parent_highlight_id)) = highlights.stack.last() {
2372 chunk_end = chunk_end.min(*parent_capture_end);
2373 highlight_id = Some(*parent_highlight_id);
2374 }
2375 }
2376
2377 let slice =
2378 &chunk[chunk_start - self.chunks.offset()..chunk_end - self.chunks.offset()];
2379 self.range.start = chunk_end;
2380 if self.range.start == self.chunks.offset() + chunk.len() {
2381 self.chunks.next().unwrap();
2382 }
2383
2384 Some(Chunk {
2385 text: slice,
2386 syntax_highlight_id: highlight_id,
2387 highlight_style: None,
2388 diagnostic_severity: self.current_diagnostic_severity(),
2389 is_unnecessary: self.current_code_is_unnecessary(),
2390 })
2391 } else {
2392 None
2393 }
2394 }
2395}
2396
2397impl QueryCursorHandle {
2398 pub(crate) fn new() -> Self {
2399 QueryCursorHandle(Some(
2400 QUERY_CURSORS
2401 .lock()
2402 .pop()
2403 .unwrap_or_else(|| QueryCursor::new()),
2404 ))
2405 }
2406}
2407
2408impl Deref for QueryCursorHandle {
2409 type Target = QueryCursor;
2410
2411 fn deref(&self) -> &Self::Target {
2412 self.0.as_ref().unwrap()
2413 }
2414}
2415
2416impl DerefMut for QueryCursorHandle {
2417 fn deref_mut(&mut self) -> &mut Self::Target {
2418 self.0.as_mut().unwrap()
2419 }
2420}
2421
2422impl Drop for QueryCursorHandle {
2423 fn drop(&mut self) {
2424 let mut cursor = self.0.take().unwrap();
2425 cursor.set_byte_range(0..usize::MAX);
2426 cursor.set_point_range(Point::zero().to_ts_point()..Point::MAX.to_ts_point());
2427 QUERY_CURSORS.lock().push(cursor)
2428 }
2429}
2430
2431trait ToTreeSitterPoint {
2432 fn to_ts_point(self) -> tree_sitter::Point;
2433 fn from_ts_point(point: tree_sitter::Point) -> Self;
2434}
2435
2436impl ToTreeSitterPoint for Point {
2437 fn to_ts_point(self) -> tree_sitter::Point {
2438 tree_sitter::Point::new(self.row as usize, self.column as usize)
2439 }
2440
2441 fn from_ts_point(point: tree_sitter::Point) -> Self {
2442 Point::new(point.row as u32, point.column as u32)
2443 }
2444}
2445
2446impl operation_queue::Operation for Operation {
2447 fn lamport_timestamp(&self) -> clock::Lamport {
2448 match self {
2449 Operation::Buffer(_) => {
2450 unreachable!("buffer operations should never be deferred at this layer")
2451 }
2452 Operation::UpdateDiagnostics {
2453 lamport_timestamp, ..
2454 }
2455 | Operation::UpdateSelections {
2456 lamport_timestamp, ..
2457 }
2458 | Operation::UpdateCompletionTriggers {
2459 lamport_timestamp, ..
2460 } => *lamport_timestamp,
2461 }
2462 }
2463}
2464
2465impl Default for Diagnostic {
2466 fn default() -> Self {
2467 Self {
2468 code: Default::default(),
2469 severity: DiagnosticSeverity::ERROR,
2470 message: Default::default(),
2471 group_id: Default::default(),
2472 is_primary: Default::default(),
2473 is_valid: true,
2474 is_disk_based: false,
2475 is_unnecessary: false,
2476 }
2477 }
2478}
2479
2480impl IndentSize {
2481 pub fn spaces(len: u32) -> Self {
2482 Self {
2483 len,
2484 kind: IndentKind::Space,
2485 }
2486 }
2487
2488 pub fn tab() -> Self {
2489 Self {
2490 len: 1,
2491 kind: IndentKind::Tab,
2492 }
2493 }
2494
2495 pub fn chars(&self) -> impl Iterator<Item = char> {
2496 iter::repeat(self.char()).take(self.len as usize)
2497 }
2498
2499 pub fn char(&self) -> char {
2500 match self.kind {
2501 IndentKind::Space => ' ',
2502 IndentKind::Tab => '\t',
2503 }
2504 }
2505}
2506
2507impl std::ops::AddAssign for IndentSize {
2508 fn add_assign(&mut self, other: IndentSize) {
2509 if self.len == 0 {
2510 *self = other;
2511 } else if self.kind == other.kind {
2512 self.len += other.len;
2513 }
2514 }
2515}
2516
2517impl std::ops::SubAssign for IndentSize {
2518 fn sub_assign(&mut self, other: IndentSize) {
2519 if self.kind == other.kind && self.len >= other.len {
2520 self.len -= other.len;
2521 }
2522 }
2523}
2524
2525impl Completion {
2526 pub fn sort_key(&self) -> (usize, &str) {
2527 let kind_key = match self.lsp_completion.kind {
2528 Some(lsp::CompletionItemKind::VARIABLE) => 0,
2529 _ => 1,
2530 };
2531 (kind_key, &self.label.text[self.label.filter_range.clone()])
2532 }
2533
2534 pub fn is_snippet(&self) -> bool {
2535 self.lsp_completion.insert_text_format == Some(lsp::InsertTextFormat::SNIPPET)
2536 }
2537}
2538
2539pub fn contiguous_ranges(
2540 values: impl Iterator<Item = u32>,
2541 max_len: usize,
2542) -> impl Iterator<Item = Range<u32>> {
2543 let mut values = values.into_iter();
2544 let mut current_range: Option<Range<u32>> = None;
2545 std::iter::from_fn(move || loop {
2546 if let Some(value) = values.next() {
2547 if let Some(range) = &mut current_range {
2548 if value == range.end && range.len() < max_len {
2549 range.end += 1;
2550 continue;
2551 }
2552 }
2553
2554 let prev_range = current_range.clone();
2555 current_range = Some(value..(value + 1));
2556 if prev_range.is_some() {
2557 return prev_range;
2558 }
2559 } else {
2560 return current_range.take();
2561 }
2562 })
2563}
2564
2565pub fn char_kind(c: char) -> CharKind {
2566 if c.is_whitespace() {
2567 CharKind::Whitespace
2568 } else if c.is_alphanumeric() || c == '_' {
2569 CharKind::Word
2570 } else {
2571 CharKind::Punctuation
2572 }
2573}