1mod highlight_map;
2mod language;
3#[cfg(test)]
4mod tests;
5
6pub use self::{
7 highlight_map::{HighlightId, HighlightMap},
8 language::{BracketPair, Language, LanguageConfig, LanguageRegistry},
9};
10use anyhow::{anyhow, Result};
11pub use buffer::{Buffer as TextBuffer, *};
12use clock::ReplicaId;
13use futures::FutureExt as _;
14use gpui::{AppContext, Entity, ModelContext, MutableAppContext, Task};
15use lazy_static::lazy_static;
16use parking_lot::Mutex;
17use rpc::proto;
18use similar::{ChangeTag, TextDiff};
19use smol::future::yield_now;
20use std::{
21 any::Any,
22 cell::RefCell,
23 cmp,
24 collections::{BTreeMap, HashMap, HashSet},
25 ffi::OsString,
26 future::Future,
27 iter::Iterator,
28 ops::{Deref, DerefMut, Range},
29 path::{Path, PathBuf},
30 str,
31 sync::Arc,
32 time::{Duration, Instant, SystemTime, UNIX_EPOCH},
33};
34use tree_sitter::{InputEdit, Parser, QueryCursor, Tree};
35use util::TryFutureExt as _;
36
37thread_local! {
38 static PARSER: RefCell<Parser> = RefCell::new(Parser::new());
39}
40
41lazy_static! {
42 static ref QUERY_CURSORS: Mutex<Vec<QueryCursor>> = Default::default();
43}
44
45// TODO - Make this configurable
46const INDENT_SIZE: u32 = 4;
47
48pub struct Buffer {
49 text: TextBuffer,
50 file: Option<Box<dyn File>>,
51 saved_version: clock::Global,
52 saved_mtime: SystemTime,
53 language: Option<Arc<Language>>,
54 autoindent_requests: Vec<Arc<AutoindentRequest>>,
55 pending_autoindent: Option<Task<()>>,
56 sync_parse_timeout: Duration,
57 syntax_tree: Mutex<Option<SyntaxTree>>,
58 parsing_in_background: bool,
59 parse_count: usize,
60 #[cfg(test)]
61 operations: Vec<Operation>,
62}
63
64pub struct Snapshot {
65 text: buffer::Snapshot,
66 tree: Option<Tree>,
67 is_parsing: bool,
68 language: Option<Arc<Language>>,
69 query_cursor: QueryCursorHandle,
70}
71
72#[derive(Clone, Debug, Eq, PartialEq)]
73pub enum Event {
74 Edited,
75 Dirtied,
76 Saved,
77 FileHandleChanged,
78 Reloaded,
79 Reparsed,
80 Closed,
81}
82
83pub trait File {
84 fn worktree_id(&self) -> usize;
85
86 fn entry_id(&self) -> Option<usize>;
87
88 fn mtime(&self) -> SystemTime;
89
90 fn path(&self) -> &Arc<Path>;
91
92 fn full_path(&self, cx: &AppContext) -> PathBuf;
93
94 /// Returns the last component of this handle's absolute path. If this handle refers to the root
95 /// of its worktree, then this method will return the name of the worktree itself.
96 fn file_name<'a>(&'a self, cx: &'a AppContext) -> Option<OsString>;
97
98 fn is_deleted(&self) -> bool;
99
100 fn save(
101 &self,
102 buffer_id: u64,
103 text: Rope,
104 version: clock::Global,
105 cx: &mut MutableAppContext,
106 ) -> Task<Result<(clock::Global, SystemTime)>>;
107
108 fn load_local(&self, cx: &AppContext) -> Option<Task<Result<String>>>;
109
110 fn buffer_updated(&self, buffer_id: u64, operation: Operation, cx: &mut MutableAppContext);
111
112 fn buffer_removed(&self, buffer_id: u64, cx: &mut MutableAppContext);
113
114 fn boxed_clone(&self) -> Box<dyn File>;
115
116 fn as_any(&self) -> &dyn Any;
117}
118
119struct QueryCursorHandle(Option<QueryCursor>);
120
121#[derive(Clone)]
122struct SyntaxTree {
123 tree: Tree,
124 version: clock::Global,
125}
126
127#[derive(Clone)]
128struct AutoindentRequest {
129 selection_set_ids: HashSet<SelectionSetId>,
130 before_edit: Snapshot,
131 edited: AnchorSet,
132 inserted: Option<AnchorRangeSet>,
133}
134
135#[derive(Debug)]
136struct IndentSuggestion {
137 basis_row: u32,
138 indent: bool,
139}
140
141struct TextProvider<'a>(&'a Rope);
142
143struct Highlights<'a> {
144 captures: tree_sitter::QueryCaptures<'a, 'a, TextProvider<'a>>,
145 next_capture: Option<(tree_sitter::QueryMatch<'a, 'a>, usize)>,
146 stack: Vec<(usize, HighlightId)>,
147 highlight_map: HighlightMap,
148}
149
150pub struct HighlightedChunks<'a> {
151 range: Range<usize>,
152 chunks: Chunks<'a>,
153 highlights: Option<Highlights<'a>>,
154}
155
156struct Diff {
157 base_version: clock::Global,
158 new_text: Arc<str>,
159 changes: Vec<(ChangeTag, usize)>,
160}
161
162impl Buffer {
163 pub fn new<T: Into<Arc<str>>>(
164 replica_id: ReplicaId,
165 base_text: T,
166 cx: &mut ModelContext<Self>,
167 ) -> Self {
168 Self::build(
169 TextBuffer::new(
170 replica_id,
171 cx.model_id() as u64,
172 History::new(base_text.into()),
173 ),
174 None,
175 None,
176 cx,
177 )
178 }
179
180 pub fn from_history(
181 replica_id: ReplicaId,
182 history: History,
183 file: Option<Box<dyn File>>,
184 language: Option<Arc<Language>>,
185 cx: &mut ModelContext<Self>,
186 ) -> Self {
187 Self::build(
188 TextBuffer::new(replica_id, cx.model_id() as u64, history),
189 file,
190 language,
191 cx,
192 )
193 }
194
195 pub fn from_proto(
196 replica_id: ReplicaId,
197 message: proto::Buffer,
198 file: Option<Box<dyn File>>,
199 language: Option<Arc<Language>>,
200 cx: &mut ModelContext<Self>,
201 ) -> Result<Self> {
202 Ok(Self::build(
203 TextBuffer::from_proto(replica_id, message)?,
204 file,
205 language,
206 cx,
207 ))
208 }
209
210 fn build(
211 buffer: TextBuffer,
212 file: Option<Box<dyn File>>,
213 language: Option<Arc<Language>>,
214 cx: &mut ModelContext<Self>,
215 ) -> Self {
216 let saved_mtime;
217 if let Some(file) = file.as_ref() {
218 saved_mtime = file.mtime();
219 } else {
220 saved_mtime = UNIX_EPOCH;
221 }
222
223 let mut result = Self {
224 text: buffer,
225 saved_mtime,
226 saved_version: clock::Global::new(),
227 file,
228 syntax_tree: Mutex::new(None),
229 parsing_in_background: false,
230 parse_count: 0,
231 sync_parse_timeout: Duration::from_millis(1),
232 autoindent_requests: Default::default(),
233 pending_autoindent: Default::default(),
234 language,
235
236 #[cfg(test)]
237 operations: Default::default(),
238 };
239 result.reparse(cx);
240 result
241 }
242
243 pub fn snapshot(&self) -> Snapshot {
244 Snapshot {
245 text: self.text.snapshot(),
246 tree: self.syntax_tree(),
247 is_parsing: self.parsing_in_background,
248 language: self.language.clone(),
249 query_cursor: QueryCursorHandle::new(),
250 }
251 }
252
253 pub fn file(&self) -> Option<&dyn File> {
254 self.file.as_deref()
255 }
256
257 pub fn save(
258 &mut self,
259 cx: &mut ModelContext<Self>,
260 ) -> Result<Task<Result<(clock::Global, SystemTime)>>> {
261 let file = self
262 .file
263 .as_ref()
264 .ok_or_else(|| anyhow!("buffer has no file"))?;
265 let text = self.as_rope().clone();
266 let version = self.version.clone();
267 let save = file.save(self.remote_id(), text, version, cx.as_mut());
268 Ok(cx.spawn(|this, mut cx| async move {
269 let (version, mtime) = save.await?;
270 this.update(&mut cx, |this, cx| {
271 this.did_save(version.clone(), mtime, None, cx);
272 });
273 Ok((version, mtime))
274 }))
275 }
276
277 pub fn set_language(&mut self, language: Option<Arc<Language>>, cx: &mut ModelContext<Self>) {
278 self.language = language;
279 self.reparse(cx);
280 }
281
282 pub fn did_save(
283 &mut self,
284 version: clock::Global,
285 mtime: SystemTime,
286 new_file: Option<Box<dyn File>>,
287 cx: &mut ModelContext<Self>,
288 ) {
289 self.saved_mtime = mtime;
290 self.saved_version = version;
291 if let Some(new_file) = new_file {
292 self.file = Some(new_file);
293 }
294 cx.emit(Event::Saved);
295 }
296
297 pub fn file_updated(
298 &mut self,
299 new_file: Box<dyn File>,
300 cx: &mut ModelContext<Self>,
301 ) -> Option<Task<()>> {
302 let old_file = self.file.as_ref()?;
303 let mut file_changed = false;
304 let mut task = None;
305
306 if new_file.path() != old_file.path() {
307 file_changed = true;
308 }
309
310 if new_file.is_deleted() {
311 if !old_file.is_deleted() {
312 file_changed = true;
313 if !self.is_dirty() {
314 cx.emit(Event::Dirtied);
315 }
316 }
317 } else {
318 let new_mtime = new_file.mtime();
319 if new_mtime != old_file.mtime() {
320 file_changed = true;
321
322 if !self.is_dirty() {
323 task = Some(cx.spawn(|this, mut cx| {
324 async move {
325 let new_text = this.read_with(&cx, |this, cx| {
326 this.file.as_ref().and_then(|file| file.load_local(cx))
327 });
328 if let Some(new_text) = new_text {
329 let new_text = new_text.await?;
330 let diff = this
331 .read_with(&cx, |this, cx| this.diff(new_text.into(), cx))
332 .await;
333 this.update(&mut cx, |this, cx| {
334 if this.apply_diff(diff, cx) {
335 this.saved_version = this.version.clone();
336 this.saved_mtime = new_mtime;
337 cx.emit(Event::Reloaded);
338 }
339 });
340 }
341 Ok(())
342 }
343 .log_err()
344 .map(drop)
345 }));
346 }
347 }
348 }
349
350 if file_changed {
351 cx.emit(Event::FileHandleChanged);
352 }
353 self.file = Some(new_file);
354 task
355 }
356
357 pub fn close(&mut self, cx: &mut ModelContext<Self>) {
358 cx.emit(Event::Closed);
359 }
360
361 pub fn language(&self) -> Option<&Arc<Language>> {
362 self.language.as_ref()
363 }
364
365 pub fn parse_count(&self) -> usize {
366 self.parse_count
367 }
368
369 fn syntax_tree(&self) -> Option<Tree> {
370 if let Some(syntax_tree) = self.syntax_tree.lock().as_mut() {
371 self.interpolate_tree(syntax_tree);
372 Some(syntax_tree.tree.clone())
373 } else {
374 None
375 }
376 }
377
378 #[cfg(any(test, feature = "test-support"))]
379 pub fn is_parsing(&self) -> bool {
380 self.parsing_in_background
381 }
382
383 #[cfg(test)]
384 pub fn set_sync_parse_timeout(&mut self, timeout: Duration) {
385 self.sync_parse_timeout = timeout;
386 }
387
388 fn reparse(&mut self, cx: &mut ModelContext<Self>) -> bool {
389 if self.parsing_in_background {
390 return false;
391 }
392
393 if let Some(language) = self.language.clone() {
394 let old_tree = self.syntax_tree();
395 let text = self.as_rope().clone();
396 let parsed_version = self.version();
397 let parse_task = cx.background().spawn({
398 let language = language.clone();
399 async move { Self::parse_text(&text, old_tree, &language) }
400 });
401
402 match cx
403 .background()
404 .block_with_timeout(self.sync_parse_timeout, parse_task)
405 {
406 Ok(new_tree) => {
407 self.did_finish_parsing(new_tree, parsed_version, cx);
408 return true;
409 }
410 Err(parse_task) => {
411 self.parsing_in_background = true;
412 cx.spawn(move |this, mut cx| async move {
413 let new_tree = parse_task.await;
414 this.update(&mut cx, move |this, cx| {
415 let language_changed =
416 this.language.as_ref().map_or(true, |curr_language| {
417 !Arc::ptr_eq(curr_language, &language)
418 });
419 let parse_again = this.version > parsed_version || language_changed;
420 this.parsing_in_background = false;
421 this.did_finish_parsing(new_tree, parsed_version, cx);
422
423 if parse_again && this.reparse(cx) {
424 return;
425 }
426 });
427 })
428 .detach();
429 }
430 }
431 }
432 false
433 }
434
435 fn parse_text(text: &Rope, old_tree: Option<Tree>, language: &Language) -> Tree {
436 PARSER.with(|parser| {
437 let mut parser = parser.borrow_mut();
438 parser
439 .set_language(language.grammar)
440 .expect("incompatible grammar");
441 let mut chunks = text.chunks_in_range(0..text.len());
442 let tree = parser
443 .parse_with(
444 &mut move |offset, _| {
445 chunks.seek(offset);
446 chunks.next().unwrap_or("").as_bytes()
447 },
448 old_tree.as_ref(),
449 )
450 .unwrap();
451 tree
452 })
453 }
454
455 fn interpolate_tree(&self, tree: &mut SyntaxTree) {
456 let mut delta = 0_isize;
457 for edit in self.edits_since(tree.version.clone()) {
458 let start_offset = (edit.old_bytes.start as isize + delta) as usize;
459 let start_point = self.as_rope().to_point(start_offset);
460 tree.tree.edit(&InputEdit {
461 start_byte: start_offset,
462 old_end_byte: start_offset + edit.deleted_bytes(),
463 new_end_byte: start_offset + edit.inserted_bytes(),
464 start_position: start_point.to_ts_point(),
465 old_end_position: (start_point + edit.deleted_lines()).to_ts_point(),
466 new_end_position: self
467 .as_rope()
468 .to_point(start_offset + edit.inserted_bytes())
469 .to_ts_point(),
470 });
471 delta += edit.inserted_bytes() as isize - edit.deleted_bytes() as isize;
472 }
473 tree.version = self.version();
474 }
475
476 fn did_finish_parsing(
477 &mut self,
478 tree: Tree,
479 version: clock::Global,
480 cx: &mut ModelContext<Self>,
481 ) {
482 self.parse_count += 1;
483 *self.syntax_tree.lock() = Some(SyntaxTree { tree, version });
484 self.request_autoindent(cx);
485 cx.emit(Event::Reparsed);
486 cx.notify();
487 }
488
489 fn request_autoindent(&mut self, cx: &mut ModelContext<Self>) {
490 if let Some(indent_columns) = self.compute_autoindents() {
491 let indent_columns = cx.background().spawn(indent_columns);
492 match cx
493 .background()
494 .block_with_timeout(Duration::from_micros(500), indent_columns)
495 {
496 Ok(indent_columns) => self.apply_autoindents(indent_columns, cx),
497 Err(indent_columns) => {
498 self.pending_autoindent = Some(cx.spawn(|this, mut cx| async move {
499 let indent_columns = indent_columns.await;
500 this.update(&mut cx, |this, cx| {
501 this.apply_autoindents(indent_columns, cx);
502 });
503 }));
504 }
505 }
506 }
507 }
508
509 fn compute_autoindents(&self) -> Option<impl Future<Output = BTreeMap<u32, u32>>> {
510 let max_rows_between_yields = 100;
511 let snapshot = self.snapshot();
512 if snapshot.language.is_none()
513 || snapshot.tree.is_none()
514 || self.autoindent_requests.is_empty()
515 {
516 return None;
517 }
518
519 let autoindent_requests = self.autoindent_requests.clone();
520 Some(async move {
521 let mut indent_columns = BTreeMap::new();
522 for request in autoindent_requests {
523 let old_to_new_rows = request
524 .edited
525 .points(&request.before_edit)
526 .map(|point| point.row)
527 .zip(request.edited.points(&snapshot).map(|point| point.row))
528 .collect::<BTreeMap<u32, u32>>();
529
530 let mut old_suggestions = HashMap::<u32, u32>::default();
531 let old_edited_ranges =
532 contiguous_ranges(old_to_new_rows.keys().copied(), max_rows_between_yields);
533 for old_edited_range in old_edited_ranges {
534 let suggestions = request
535 .before_edit
536 .suggest_autoindents(old_edited_range.clone())
537 .into_iter()
538 .flatten();
539 for (old_row, suggestion) in old_edited_range.zip(suggestions) {
540 let indentation_basis = old_to_new_rows
541 .get(&suggestion.basis_row)
542 .and_then(|from_row| old_suggestions.get(from_row).copied())
543 .unwrap_or_else(|| {
544 request
545 .before_edit
546 .indent_column_for_line(suggestion.basis_row)
547 });
548 let delta = if suggestion.indent { INDENT_SIZE } else { 0 };
549 old_suggestions.insert(
550 *old_to_new_rows.get(&old_row).unwrap(),
551 indentation_basis + delta,
552 );
553 }
554 yield_now().await;
555 }
556
557 // At this point, old_suggestions contains the suggested indentation for all edited lines with respect to the state of the
558 // buffer before the edit, but keyed by the row for these lines after the edits were applied.
559 let new_edited_row_ranges =
560 contiguous_ranges(old_to_new_rows.values().copied(), max_rows_between_yields);
561 for new_edited_row_range in new_edited_row_ranges {
562 let suggestions = snapshot
563 .suggest_autoindents(new_edited_row_range.clone())
564 .into_iter()
565 .flatten();
566 for (new_row, suggestion) in new_edited_row_range.zip(suggestions) {
567 let delta = if suggestion.indent { INDENT_SIZE } else { 0 };
568 let new_indentation = indent_columns
569 .get(&suggestion.basis_row)
570 .copied()
571 .unwrap_or_else(|| {
572 snapshot.indent_column_for_line(suggestion.basis_row)
573 })
574 + delta;
575 if old_suggestions
576 .get(&new_row)
577 .map_or(true, |old_indentation| new_indentation != *old_indentation)
578 {
579 indent_columns.insert(new_row, new_indentation);
580 }
581 }
582 yield_now().await;
583 }
584
585 if let Some(inserted) = request.inserted.as_ref() {
586 let inserted_row_ranges = contiguous_ranges(
587 inserted
588 .point_ranges(&snapshot)
589 .flat_map(|range| range.start.row..range.end.row + 1),
590 max_rows_between_yields,
591 );
592 for inserted_row_range in inserted_row_ranges {
593 let suggestions = snapshot
594 .suggest_autoindents(inserted_row_range.clone())
595 .into_iter()
596 .flatten();
597 for (row, suggestion) in inserted_row_range.zip(suggestions) {
598 let delta = if suggestion.indent { INDENT_SIZE } else { 0 };
599 let new_indentation = indent_columns
600 .get(&suggestion.basis_row)
601 .copied()
602 .unwrap_or_else(|| {
603 snapshot.indent_column_for_line(suggestion.basis_row)
604 })
605 + delta;
606 indent_columns.insert(row, new_indentation);
607 }
608 yield_now().await;
609 }
610 }
611 }
612 indent_columns
613 })
614 }
615
616 fn apply_autoindents(
617 &mut self,
618 indent_columns: BTreeMap<u32, u32>,
619 cx: &mut ModelContext<Self>,
620 ) {
621 let selection_set_ids = self
622 .autoindent_requests
623 .drain(..)
624 .flat_map(|req| req.selection_set_ids.clone())
625 .collect::<HashSet<_>>();
626
627 self.start_transaction(selection_set_ids.iter().copied())
628 .unwrap();
629 for (row, indent_column) in &indent_columns {
630 self.set_indent_column_for_line(*row, *indent_column, cx);
631 }
632
633 for selection_set_id in &selection_set_ids {
634 if let Ok(set) = self.selection_set(*selection_set_id) {
635 let new_selections = set
636 .point_selections(&*self)
637 .map(|selection| {
638 if selection.start.column == 0 {
639 let delta = Point::new(
640 0,
641 indent_columns
642 .get(&selection.start.row)
643 .copied()
644 .unwrap_or(0),
645 );
646 if delta.column > 0 {
647 return Selection {
648 id: selection.id,
649 goal: selection.goal,
650 reversed: selection.reversed,
651 start: selection.start + delta,
652 end: selection.end + delta,
653 };
654 }
655 }
656 selection
657 })
658 .collect::<Vec<_>>();
659 self.update_selection_set(*selection_set_id, &new_selections, cx)
660 .unwrap();
661 }
662 }
663
664 self.end_transaction(selection_set_ids.iter().copied(), cx)
665 .unwrap();
666 }
667
668 pub fn indent_column_for_line(&self, row: u32) -> u32 {
669 self.content().indent_column_for_line(row)
670 }
671
672 fn set_indent_column_for_line(&mut self, row: u32, column: u32, cx: &mut ModelContext<Self>) {
673 let current_column = self.indent_column_for_line(row);
674 if column > current_column {
675 let offset = Point::new(row, 0).to_offset(&*self);
676 self.edit(
677 [offset..offset],
678 " ".repeat((column - current_column) as usize),
679 cx,
680 );
681 } else if column < current_column {
682 self.edit(
683 [Point::new(row, 0)..Point::new(row, current_column - column)],
684 "",
685 cx,
686 );
687 }
688 }
689
690 pub fn range_for_syntax_ancestor<T: ToOffset>(&self, range: Range<T>) -> Option<Range<usize>> {
691 if let Some(tree) = self.syntax_tree() {
692 let root = tree.root_node();
693 let range = range.start.to_offset(self)..range.end.to_offset(self);
694 let mut node = root.descendant_for_byte_range(range.start, range.end);
695 while node.map_or(false, |n| n.byte_range() == range) {
696 node = node.unwrap().parent();
697 }
698 node.map(|n| n.byte_range())
699 } else {
700 None
701 }
702 }
703
704 pub fn enclosing_bracket_ranges<T: ToOffset>(
705 &self,
706 range: Range<T>,
707 ) -> Option<(Range<usize>, Range<usize>)> {
708 let (lang, tree) = self.language.as_ref().zip(self.syntax_tree())?;
709 let open_capture_ix = lang.brackets_query.capture_index_for_name("open")?;
710 let close_capture_ix = lang.brackets_query.capture_index_for_name("close")?;
711
712 // Find bracket pairs that *inclusively* contain the given range.
713 let range = range.start.to_offset(self).saturating_sub(1)..range.end.to_offset(self) + 1;
714 let mut cursor = QueryCursorHandle::new();
715 let matches = cursor.set_byte_range(range).matches(
716 &lang.brackets_query,
717 tree.root_node(),
718 TextProvider(self.as_rope()),
719 );
720
721 // Get the ranges of the innermost pair of brackets.
722 matches
723 .filter_map(|mat| {
724 let open = mat.nodes_for_capture_index(open_capture_ix).next()?;
725 let close = mat.nodes_for_capture_index(close_capture_ix).next()?;
726 Some((open.byte_range(), close.byte_range()))
727 })
728 .min_by_key(|(open_range, close_range)| close_range.end - open_range.start)
729 }
730
731 fn diff(&self, new_text: Arc<str>, cx: &AppContext) -> Task<Diff> {
732 // TODO: it would be nice to not allocate here.
733 let old_text = self.text();
734 let base_version = self.version();
735 cx.background().spawn(async move {
736 let changes = TextDiff::from_lines(old_text.as_str(), new_text.as_ref())
737 .iter_all_changes()
738 .map(|c| (c.tag(), c.value().len()))
739 .collect::<Vec<_>>();
740 Diff {
741 base_version,
742 new_text,
743 changes,
744 }
745 })
746 }
747
748 fn apply_diff(&mut self, diff: Diff, cx: &mut ModelContext<Self>) -> bool {
749 if self.version == diff.base_version {
750 self.start_transaction(None).unwrap();
751 let mut offset = 0;
752 for (tag, len) in diff.changes {
753 let range = offset..(offset + len);
754 match tag {
755 ChangeTag::Equal => offset += len,
756 ChangeTag::Delete => self.edit(Some(range), "", cx),
757 ChangeTag::Insert => {
758 self.edit(Some(offset..offset), &diff.new_text[range], cx);
759 offset += len;
760 }
761 }
762 }
763 self.end_transaction(None, cx).unwrap();
764 true
765 } else {
766 false
767 }
768 }
769
770 pub fn is_dirty(&self) -> bool {
771 self.version > self.saved_version
772 || self.file.as_ref().map_or(false, |file| file.is_deleted())
773 }
774
775 pub fn has_conflict(&self) -> bool {
776 self.version > self.saved_version
777 && self
778 .file
779 .as_ref()
780 .map_or(false, |file| file.mtime() > self.saved_mtime)
781 }
782
783 pub fn start_transaction(
784 &mut self,
785 selection_set_ids: impl IntoIterator<Item = SelectionSetId>,
786 ) -> Result<()> {
787 self.start_transaction_at(selection_set_ids, Instant::now())
788 }
789
790 fn start_transaction_at(
791 &mut self,
792 selection_set_ids: impl IntoIterator<Item = SelectionSetId>,
793 now: Instant,
794 ) -> Result<()> {
795 self.text.start_transaction_at(selection_set_ids, now)
796 }
797
798 pub fn end_transaction(
799 &mut self,
800 selection_set_ids: impl IntoIterator<Item = SelectionSetId>,
801 cx: &mut ModelContext<Self>,
802 ) -> Result<()> {
803 self.end_transaction_at(selection_set_ids, Instant::now(), cx)
804 }
805
806 fn end_transaction_at(
807 &mut self,
808 selection_set_ids: impl IntoIterator<Item = SelectionSetId>,
809 now: Instant,
810 cx: &mut ModelContext<Self>,
811 ) -> Result<()> {
812 if let Some(start_version) = self.text.end_transaction_at(selection_set_ids, now) {
813 cx.notify();
814 let was_dirty = start_version != self.saved_version;
815 let edited = self.edits_since(start_version).next().is_some();
816 if edited {
817 self.did_edit(was_dirty, cx);
818 self.reparse(cx);
819 }
820 }
821 Ok(())
822 }
823
824 pub fn edit<I, S, T>(&mut self, ranges_iter: I, new_text: T, cx: &mut ModelContext<Self>)
825 where
826 I: IntoIterator<Item = Range<S>>,
827 S: ToOffset,
828 T: Into<String>,
829 {
830 self.edit_internal(ranges_iter, new_text, false, cx)
831 }
832
833 pub fn edit_with_autoindent<I, S, T>(
834 &mut self,
835 ranges_iter: I,
836 new_text: T,
837 cx: &mut ModelContext<Self>,
838 ) where
839 I: IntoIterator<Item = Range<S>>,
840 S: ToOffset,
841 T: Into<String>,
842 {
843 self.edit_internal(ranges_iter, new_text, true, cx)
844 }
845
846 pub fn edit_internal<I, S, T>(
847 &mut self,
848 ranges_iter: I,
849 new_text: T,
850 autoindent: bool,
851 cx: &mut ModelContext<Self>,
852 ) where
853 I: IntoIterator<Item = Range<S>>,
854 S: ToOffset,
855 T: Into<String>,
856 {
857 let new_text = new_text.into();
858
859 // Skip invalid ranges and coalesce contiguous ones.
860 let mut ranges: Vec<Range<usize>> = Vec::new();
861 for range in ranges_iter {
862 let range = range.start.to_offset(&*self)..range.end.to_offset(&*self);
863 if !new_text.is_empty() || !range.is_empty() {
864 if let Some(prev_range) = ranges.last_mut() {
865 if prev_range.end >= range.start {
866 prev_range.end = cmp::max(prev_range.end, range.end);
867 } else {
868 ranges.push(range);
869 }
870 } else {
871 ranges.push(range);
872 }
873 }
874 }
875 if ranges.is_empty() {
876 return;
877 }
878
879 self.start_transaction(None).unwrap();
880 self.pending_autoindent.take();
881 let autoindent_request = if autoindent && self.language.is_some() {
882 let before_edit = self.snapshot();
883 let edited = self.content().anchor_set(ranges.iter().filter_map(|range| {
884 let start = range.start.to_point(&*self);
885 if new_text.starts_with('\n') && start.column == self.line_len(start.row) {
886 None
887 } else {
888 Some((range.start, Bias::Left))
889 }
890 }));
891 Some((before_edit, edited))
892 } else {
893 None
894 };
895
896 let first_newline_ix = new_text.find('\n');
897 let new_text_len = new_text.len();
898
899 let edit = self.text.edit(ranges.iter().cloned(), new_text);
900
901 if let Some((before_edit, edited)) = autoindent_request {
902 let mut inserted = None;
903 if let Some(first_newline_ix) = first_newline_ix {
904 let mut delta = 0isize;
905 inserted = Some(self.content().anchor_range_set(ranges.iter().map(|range| {
906 let start = (delta + range.start as isize) as usize + first_newline_ix + 1;
907 let end = (delta + range.start as isize) as usize + new_text_len;
908 delta += (range.end as isize - range.start as isize) + new_text_len as isize;
909 (start, Bias::Left)..(end, Bias::Right)
910 })));
911 }
912
913 let selection_set_ids = self
914 .text
915 .peek_undo_stack()
916 .unwrap()
917 .starting_selection_set_ids()
918 .collect();
919 self.autoindent_requests.push(Arc::new(AutoindentRequest {
920 selection_set_ids,
921 before_edit,
922 edited,
923 inserted,
924 }));
925 }
926
927 self.end_transaction(None, cx).unwrap();
928 self.send_operation(Operation::Edit(edit), cx);
929 }
930
931 fn did_edit(&self, was_dirty: bool, cx: &mut ModelContext<Self>) {
932 cx.emit(Event::Edited);
933 if !was_dirty {
934 cx.emit(Event::Dirtied);
935 }
936 }
937
938 pub fn add_selection_set<T: ToOffset>(
939 &mut self,
940 selections: &[Selection<T>],
941 cx: &mut ModelContext<Self>,
942 ) -> SelectionSetId {
943 let operation = self.text.add_selection_set(selections);
944 if let Operation::UpdateSelections { set_id, .. } = &operation {
945 let set_id = *set_id;
946 cx.notify();
947 self.send_operation(operation, cx);
948 set_id
949 } else {
950 unreachable!()
951 }
952 }
953
954 pub fn update_selection_set<T: ToOffset>(
955 &mut self,
956 set_id: SelectionSetId,
957 selections: &[Selection<T>],
958 cx: &mut ModelContext<Self>,
959 ) -> Result<()> {
960 let operation = self.text.update_selection_set(set_id, selections)?;
961 cx.notify();
962 self.send_operation(operation, cx);
963 Ok(())
964 }
965
966 pub fn set_active_selection_set(
967 &mut self,
968 set_id: Option<SelectionSetId>,
969 cx: &mut ModelContext<Self>,
970 ) -> Result<()> {
971 let operation = self.text.set_active_selection_set(set_id)?;
972 self.send_operation(operation, cx);
973 Ok(())
974 }
975
976 pub fn remove_selection_set(
977 &mut self,
978 set_id: SelectionSetId,
979 cx: &mut ModelContext<Self>,
980 ) -> Result<()> {
981 let operation = self.text.remove_selection_set(set_id)?;
982 cx.notify();
983 self.send_operation(operation, cx);
984 Ok(())
985 }
986
987 pub fn apply_ops<I: IntoIterator<Item = Operation>>(
988 &mut self,
989 ops: I,
990 cx: &mut ModelContext<Self>,
991 ) -> Result<()> {
992 self.pending_autoindent.take();
993
994 let was_dirty = self.is_dirty();
995 let old_version = self.version.clone();
996
997 self.text.apply_ops(ops)?;
998
999 cx.notify();
1000 if self.edits_since(old_version).next().is_some() {
1001 self.did_edit(was_dirty, cx);
1002 self.reparse(cx);
1003 }
1004
1005 Ok(())
1006 }
1007
1008 #[cfg(not(test))]
1009 pub fn send_operation(&mut self, operation: Operation, cx: &mut ModelContext<Self>) {
1010 if let Some(file) = &self.file {
1011 file.buffer_updated(self.remote_id(), operation, cx.as_mut());
1012 }
1013 }
1014
1015 #[cfg(test)]
1016 pub fn send_operation(&mut self, operation: Operation, _: &mut ModelContext<Self>) {
1017 self.operations.push(operation);
1018 }
1019
1020 pub fn remove_peer(&mut self, replica_id: ReplicaId, cx: &mut ModelContext<Self>) {
1021 self.text.remove_peer(replica_id);
1022 cx.notify();
1023 }
1024
1025 pub fn undo(&mut self, cx: &mut ModelContext<Self>) {
1026 let was_dirty = self.is_dirty();
1027 let old_version = self.version.clone();
1028
1029 for operation in self.text.undo() {
1030 self.send_operation(operation, cx);
1031 }
1032
1033 cx.notify();
1034 if self.edits_since(old_version).next().is_some() {
1035 self.did_edit(was_dirty, cx);
1036 self.reparse(cx);
1037 }
1038 }
1039
1040 pub fn redo(&mut self, cx: &mut ModelContext<Self>) {
1041 let was_dirty = self.is_dirty();
1042 let old_version = self.version.clone();
1043
1044 for operation in self.text.redo() {
1045 self.send_operation(operation, cx);
1046 }
1047
1048 cx.notify();
1049 if self.edits_since(old_version).next().is_some() {
1050 self.did_edit(was_dirty, cx);
1051 self.reparse(cx);
1052 }
1053 }
1054}
1055
1056#[cfg(any(test, feature = "test-support"))]
1057impl Buffer {
1058 pub fn randomly_edit<T>(&mut self, rng: &mut T, old_range_count: usize)
1059 where
1060 T: rand::Rng,
1061 {
1062 self.text.randomly_edit(rng, old_range_count);
1063 }
1064
1065 pub fn randomly_mutate<T>(&mut self, rng: &mut T)
1066 where
1067 T: rand::Rng,
1068 {
1069 self.text.randomly_mutate(rng);
1070 }
1071}
1072
1073impl Entity for Buffer {
1074 type Event = Event;
1075
1076 fn release(&mut self, cx: &mut gpui::MutableAppContext) {
1077 if let Some(file) = self.file.as_ref() {
1078 file.buffer_removed(self.remote_id(), cx);
1079 }
1080 }
1081}
1082
1083impl Clone for Buffer {
1084 fn clone(&self) -> Self {
1085 Self {
1086 text: self.text.clone(),
1087 saved_version: self.saved_version.clone(),
1088 saved_mtime: self.saved_mtime,
1089 file: self.file.as_ref().map(|f| f.boxed_clone()),
1090 language: self.language.clone(),
1091 syntax_tree: Mutex::new(self.syntax_tree.lock().clone()),
1092 parsing_in_background: false,
1093 sync_parse_timeout: self.sync_parse_timeout,
1094 parse_count: self.parse_count,
1095 autoindent_requests: Default::default(),
1096 pending_autoindent: Default::default(),
1097
1098 #[cfg(test)]
1099 operations: self.operations.clone(),
1100 }
1101 }
1102}
1103
1104impl Deref for Buffer {
1105 type Target = TextBuffer;
1106
1107 fn deref(&self) -> &Self::Target {
1108 &self.text
1109 }
1110}
1111
1112impl<'a> From<&'a Buffer> for Content<'a> {
1113 fn from(buffer: &'a Buffer) -> Self {
1114 Self::from(&buffer.text)
1115 }
1116}
1117
1118impl<'a> From<&'a mut Buffer> for Content<'a> {
1119 fn from(buffer: &'a mut Buffer) -> Self {
1120 Self::from(&buffer.text)
1121 }
1122}
1123
1124impl<'a> From<&'a Snapshot> for Content<'a> {
1125 fn from(snapshot: &'a Snapshot) -> Self {
1126 Self::from(&snapshot.text)
1127 }
1128}
1129
1130impl Snapshot {
1131 fn suggest_autoindents<'a>(
1132 &'a self,
1133 row_range: Range<u32>,
1134 ) -> Option<impl Iterator<Item = IndentSuggestion> + 'a> {
1135 let mut query_cursor = QueryCursorHandle::new();
1136 if let Some((language, tree)) = self.language.as_ref().zip(self.tree.as_ref()) {
1137 let prev_non_blank_row = self.prev_non_blank_row(row_range.start);
1138
1139 // Get the "indentation ranges" that intersect this row range.
1140 let indent_capture_ix = language.indents_query.capture_index_for_name("indent");
1141 let end_capture_ix = language.indents_query.capture_index_for_name("end");
1142 query_cursor.set_point_range(
1143 Point::new(prev_non_blank_row.unwrap_or(row_range.start), 0).to_ts_point()
1144 ..Point::new(row_range.end, 0).to_ts_point(),
1145 );
1146 let mut indentation_ranges = Vec::<(Range<Point>, &'static str)>::new();
1147 for mat in query_cursor.matches(
1148 &language.indents_query,
1149 tree.root_node(),
1150 TextProvider(self.as_rope()),
1151 ) {
1152 let mut node_kind = "";
1153 let mut start: Option<Point> = None;
1154 let mut end: Option<Point> = None;
1155 for capture in mat.captures {
1156 if Some(capture.index) == indent_capture_ix {
1157 node_kind = capture.node.kind();
1158 start.get_or_insert(Point::from_ts_point(capture.node.start_position()));
1159 end.get_or_insert(Point::from_ts_point(capture.node.end_position()));
1160 } else if Some(capture.index) == end_capture_ix {
1161 end = Some(Point::from_ts_point(capture.node.start_position().into()));
1162 }
1163 }
1164
1165 if let Some((start, end)) = start.zip(end) {
1166 if start.row == end.row {
1167 continue;
1168 }
1169
1170 let range = start..end;
1171 match indentation_ranges.binary_search_by_key(&range.start, |r| r.0.start) {
1172 Err(ix) => indentation_ranges.insert(ix, (range, node_kind)),
1173 Ok(ix) => {
1174 let prev_range = &mut indentation_ranges[ix];
1175 prev_range.0.end = prev_range.0.end.max(range.end);
1176 }
1177 }
1178 }
1179 }
1180
1181 let mut prev_row = prev_non_blank_row.unwrap_or(0);
1182 Some(row_range.map(move |row| {
1183 let row_start = Point::new(row, self.indent_column_for_line(row));
1184
1185 let mut indent_from_prev_row = false;
1186 let mut outdent_to_row = u32::MAX;
1187 for (range, _node_kind) in &indentation_ranges {
1188 if range.start.row >= row {
1189 break;
1190 }
1191
1192 if range.start.row == prev_row && range.end > row_start {
1193 indent_from_prev_row = true;
1194 }
1195 if range.end.row >= prev_row && range.end <= row_start {
1196 outdent_to_row = outdent_to_row.min(range.start.row);
1197 }
1198 }
1199
1200 let suggestion = if outdent_to_row == prev_row {
1201 IndentSuggestion {
1202 basis_row: prev_row,
1203 indent: false,
1204 }
1205 } else if indent_from_prev_row {
1206 IndentSuggestion {
1207 basis_row: prev_row,
1208 indent: true,
1209 }
1210 } else if outdent_to_row < prev_row {
1211 IndentSuggestion {
1212 basis_row: outdent_to_row,
1213 indent: false,
1214 }
1215 } else {
1216 IndentSuggestion {
1217 basis_row: prev_row,
1218 indent: false,
1219 }
1220 };
1221
1222 prev_row = row;
1223 suggestion
1224 }))
1225 } else {
1226 None
1227 }
1228 }
1229
1230 fn prev_non_blank_row(&self, mut row: u32) -> Option<u32> {
1231 while row > 0 {
1232 row -= 1;
1233 if !self.is_line_blank(row) {
1234 return Some(row);
1235 }
1236 }
1237 None
1238 }
1239
1240 fn is_line_blank(&self, row: u32) -> bool {
1241 self.text_for_range(Point::new(row, 0)..Point::new(row, self.line_len(row)))
1242 .all(|chunk| chunk.matches(|c: char| !c.is_whitespace()).next().is_none())
1243 }
1244
1245 pub fn highlighted_text_for_range<T: ToOffset>(
1246 &mut self,
1247 range: Range<T>,
1248 ) -> HighlightedChunks {
1249 let range = range.start.to_offset(&*self)..range.end.to_offset(&*self);
1250 let chunks = self.text.as_rope().chunks_in_range(range.clone());
1251 if let Some((language, tree)) = self.language.as_ref().zip(self.tree.as_ref()) {
1252 let captures = self.query_cursor.set_byte_range(range.clone()).captures(
1253 &language.highlights_query,
1254 tree.root_node(),
1255 TextProvider(self.text.as_rope()),
1256 );
1257
1258 HighlightedChunks {
1259 range,
1260 chunks,
1261 highlights: Some(Highlights {
1262 captures,
1263 next_capture: None,
1264 stack: Default::default(),
1265 highlight_map: language.highlight_map(),
1266 }),
1267 }
1268 } else {
1269 HighlightedChunks {
1270 range,
1271 chunks,
1272 highlights: None,
1273 }
1274 }
1275 }
1276}
1277
1278impl Clone for Snapshot {
1279 fn clone(&self) -> Self {
1280 Self {
1281 text: self.text.clone(),
1282 tree: self.tree.clone(),
1283 is_parsing: self.is_parsing,
1284 language: self.language.clone(),
1285 query_cursor: QueryCursorHandle::new(),
1286 }
1287 }
1288}
1289
1290impl Deref for Snapshot {
1291 type Target = buffer::Snapshot;
1292
1293 fn deref(&self) -> &Self::Target {
1294 &self.text
1295 }
1296}
1297
1298impl<'a> tree_sitter::TextProvider<'a> for TextProvider<'a> {
1299 type I = ByteChunks<'a>;
1300
1301 fn text(&mut self, node: tree_sitter::Node) -> Self::I {
1302 ByteChunks(self.0.chunks_in_range(node.byte_range()))
1303 }
1304}
1305
1306struct ByteChunks<'a>(rope::Chunks<'a>);
1307
1308impl<'a> Iterator for ByteChunks<'a> {
1309 type Item = &'a [u8];
1310
1311 fn next(&mut self) -> Option<Self::Item> {
1312 self.0.next().map(str::as_bytes)
1313 }
1314}
1315
1316impl<'a> HighlightedChunks<'a> {
1317 pub fn seek(&mut self, offset: usize) {
1318 self.range.start = offset;
1319 self.chunks.seek(self.range.start);
1320 if let Some(highlights) = self.highlights.as_mut() {
1321 highlights
1322 .stack
1323 .retain(|(end_offset, _)| *end_offset > offset);
1324 if let Some((mat, capture_ix)) = &highlights.next_capture {
1325 let capture = mat.captures[*capture_ix as usize];
1326 if offset >= capture.node.start_byte() {
1327 let next_capture_end = capture.node.end_byte();
1328 if offset < next_capture_end {
1329 highlights.stack.push((
1330 next_capture_end,
1331 highlights.highlight_map.get(capture.index),
1332 ));
1333 }
1334 highlights.next_capture.take();
1335 }
1336 }
1337 highlights.captures.set_byte_range(self.range.clone());
1338 }
1339 }
1340
1341 pub fn offset(&self) -> usize {
1342 self.range.start
1343 }
1344}
1345
1346impl<'a> Iterator for HighlightedChunks<'a> {
1347 type Item = (&'a str, HighlightId);
1348
1349 fn next(&mut self) -> Option<Self::Item> {
1350 let mut next_capture_start = usize::MAX;
1351
1352 if let Some(highlights) = self.highlights.as_mut() {
1353 while let Some((parent_capture_end, _)) = highlights.stack.last() {
1354 if *parent_capture_end <= self.range.start {
1355 highlights.stack.pop();
1356 } else {
1357 break;
1358 }
1359 }
1360
1361 if highlights.next_capture.is_none() {
1362 highlights.next_capture = highlights.captures.next();
1363 }
1364
1365 while let Some((mat, capture_ix)) = highlights.next_capture.as_ref() {
1366 let capture = mat.captures[*capture_ix as usize];
1367 if self.range.start < capture.node.start_byte() {
1368 next_capture_start = capture.node.start_byte();
1369 break;
1370 } else {
1371 let style_id = highlights.highlight_map.get(capture.index);
1372 highlights.stack.push((capture.node.end_byte(), style_id));
1373 highlights.next_capture = highlights.captures.next();
1374 }
1375 }
1376 }
1377
1378 if let Some(chunk) = self.chunks.peek() {
1379 let chunk_start = self.range.start;
1380 let mut chunk_end = (self.chunks.offset() + chunk.len()).min(next_capture_start);
1381 let mut style_id = HighlightId::default();
1382 if let Some((parent_capture_end, parent_style_id)) =
1383 self.highlights.as_ref().and_then(|h| h.stack.last())
1384 {
1385 chunk_end = chunk_end.min(*parent_capture_end);
1386 style_id = *parent_style_id;
1387 }
1388
1389 let slice =
1390 &chunk[chunk_start - self.chunks.offset()..chunk_end - self.chunks.offset()];
1391 self.range.start = chunk_end;
1392 if self.range.start == self.chunks.offset() + chunk.len() {
1393 self.chunks.next().unwrap();
1394 }
1395
1396 Some((slice, style_id))
1397 } else {
1398 None
1399 }
1400 }
1401}
1402
1403impl QueryCursorHandle {
1404 fn new() -> Self {
1405 QueryCursorHandle(Some(
1406 QUERY_CURSORS
1407 .lock()
1408 .pop()
1409 .unwrap_or_else(|| QueryCursor::new()),
1410 ))
1411 }
1412}
1413
1414impl Deref for QueryCursorHandle {
1415 type Target = QueryCursor;
1416
1417 fn deref(&self) -> &Self::Target {
1418 self.0.as_ref().unwrap()
1419 }
1420}
1421
1422impl DerefMut for QueryCursorHandle {
1423 fn deref_mut(&mut self) -> &mut Self::Target {
1424 self.0.as_mut().unwrap()
1425 }
1426}
1427
1428impl Drop for QueryCursorHandle {
1429 fn drop(&mut self) {
1430 let mut cursor = self.0.take().unwrap();
1431 cursor.set_byte_range(0..usize::MAX);
1432 cursor.set_point_range(Point::zero().to_ts_point()..Point::MAX.to_ts_point());
1433 QUERY_CURSORS.lock().push(cursor)
1434 }
1435}
1436
1437trait ToTreeSitterPoint {
1438 fn to_ts_point(self) -> tree_sitter::Point;
1439 fn from_ts_point(point: tree_sitter::Point) -> Self;
1440}
1441
1442impl ToTreeSitterPoint for Point {
1443 fn to_ts_point(self) -> tree_sitter::Point {
1444 tree_sitter::Point::new(self.row as usize, self.column as usize)
1445 }
1446
1447 fn from_ts_point(point: tree_sitter::Point) -> Self {
1448 Point::new(point.row as u32, point.column as u32)
1449 }
1450}
1451
1452fn contiguous_ranges(
1453 values: impl IntoIterator<Item = u32>,
1454 max_len: usize,
1455) -> impl Iterator<Item = Range<u32>> {
1456 let mut values = values.into_iter();
1457 let mut current_range: Option<Range<u32>> = None;
1458 std::iter::from_fn(move || loop {
1459 if let Some(value) = values.next() {
1460 if let Some(range) = &mut current_range {
1461 if value == range.end && range.len() < max_len {
1462 range.end += 1;
1463 continue;
1464 }
1465 }
1466
1467 let prev_range = current_range.clone();
1468 current_range = Some(value..(value + 1));
1469 if prev_range.is_some() {
1470 return prev_range;
1471 }
1472 } else {
1473 return current_range.take();
1474 }
1475 })
1476}