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 .to_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.get(&selection.start.row).copied().unwrap_or(0),
642 );
643 if delta.column > 0 {
644 return Selection {
645 id: selection.id,
646 goal: selection.goal,
647 reversed: selection.reversed,
648 start: selection.start + delta,
649 end: selection.end + delta,
650 };
651 }
652 }
653 selection
654 })
655 .collect::<Vec<_>>();
656 self.update_selection_set(*selection_set_id, &new_selections, cx)
657 .unwrap();
658 }
659 }
660
661 self.end_transaction(selection_set_ids.iter().copied(), cx)
662 .unwrap();
663 }
664
665 pub fn indent_column_for_line(&self, row: u32) -> u32 {
666 self.content().indent_column_for_line(row)
667 }
668
669 fn set_indent_column_for_line(&mut self, row: u32, column: u32, cx: &mut ModelContext<Self>) {
670 let current_column = self.indent_column_for_line(row);
671 if column > current_column {
672 let offset = Point::new(row, 0).to_offset(&*self);
673 self.edit(
674 [offset..offset],
675 " ".repeat((column - current_column) as usize),
676 cx,
677 );
678 } else if column < current_column {
679 self.edit(
680 [Point::new(row, 0)..Point::new(row, current_column - column)],
681 "",
682 cx,
683 );
684 }
685 }
686
687 pub fn range_for_syntax_ancestor<T: ToOffset>(&self, range: Range<T>) -> Option<Range<usize>> {
688 if let Some(tree) = self.syntax_tree() {
689 let root = tree.root_node();
690 let range = range.start.to_offset(self)..range.end.to_offset(self);
691 let mut node = root.descendant_for_byte_range(range.start, range.end);
692 while node.map_or(false, |n| n.byte_range() == range) {
693 node = node.unwrap().parent();
694 }
695 node.map(|n| n.byte_range())
696 } else {
697 None
698 }
699 }
700
701 pub fn enclosing_bracket_ranges<T: ToOffset>(
702 &self,
703 range: Range<T>,
704 ) -> Option<(Range<usize>, Range<usize>)> {
705 let (lang, tree) = self.language.as_ref().zip(self.syntax_tree())?;
706 let open_capture_ix = lang.brackets_query.capture_index_for_name("open")?;
707 let close_capture_ix = lang.brackets_query.capture_index_for_name("close")?;
708
709 // Find bracket pairs that *inclusively* contain the given range.
710 let range = range.start.to_offset(self).saturating_sub(1)..range.end.to_offset(self) + 1;
711 let mut cursor = QueryCursorHandle::new();
712 let matches = cursor.set_byte_range(range).matches(
713 &lang.brackets_query,
714 tree.root_node(),
715 TextProvider(self.as_rope()),
716 );
717
718 // Get the ranges of the innermost pair of brackets.
719 matches
720 .filter_map(|mat| {
721 let open = mat.nodes_for_capture_index(open_capture_ix).next()?;
722 let close = mat.nodes_for_capture_index(close_capture_ix).next()?;
723 Some((open.byte_range(), close.byte_range()))
724 })
725 .min_by_key(|(open_range, close_range)| close_range.end - open_range.start)
726 }
727
728 fn diff(&self, new_text: Arc<str>, cx: &AppContext) -> Task<Diff> {
729 // TODO: it would be nice to not allocate here.
730 let old_text = self.text();
731 let base_version = self.version();
732 cx.background().spawn(async move {
733 let changes = TextDiff::from_lines(old_text.as_str(), new_text.as_ref())
734 .iter_all_changes()
735 .map(|c| (c.tag(), c.value().len()))
736 .collect::<Vec<_>>();
737 Diff {
738 base_version,
739 new_text,
740 changes,
741 }
742 })
743 }
744
745 fn apply_diff(&mut self, diff: Diff, cx: &mut ModelContext<Self>) -> bool {
746 if self.version == diff.base_version {
747 self.start_transaction(None).unwrap();
748 let mut offset = 0;
749 for (tag, len) in diff.changes {
750 let range = offset..(offset + len);
751 match tag {
752 ChangeTag::Equal => offset += len,
753 ChangeTag::Delete => self.edit(Some(range), "", cx),
754 ChangeTag::Insert => {
755 self.edit(Some(offset..offset), &diff.new_text[range], cx);
756 offset += len;
757 }
758 }
759 }
760 self.end_transaction(None, cx).unwrap();
761 true
762 } else {
763 false
764 }
765 }
766
767 pub fn is_dirty(&self) -> bool {
768 self.version > self.saved_version
769 || self.file.as_ref().map_or(false, |file| file.is_deleted())
770 }
771
772 pub fn has_conflict(&self) -> bool {
773 self.version > self.saved_version
774 && self
775 .file
776 .as_ref()
777 .map_or(false, |file| file.mtime() > self.saved_mtime)
778 }
779
780 pub fn start_transaction(
781 &mut self,
782 selection_set_ids: impl IntoIterator<Item = SelectionSetId>,
783 ) -> Result<()> {
784 self.start_transaction_at(selection_set_ids, Instant::now())
785 }
786
787 fn start_transaction_at(
788 &mut self,
789 selection_set_ids: impl IntoIterator<Item = SelectionSetId>,
790 now: Instant,
791 ) -> Result<()> {
792 self.text.start_transaction_at(selection_set_ids, now)
793 }
794
795 pub fn end_transaction(
796 &mut self,
797 selection_set_ids: impl IntoIterator<Item = SelectionSetId>,
798 cx: &mut ModelContext<Self>,
799 ) -> Result<()> {
800 self.end_transaction_at(selection_set_ids, Instant::now(), cx)
801 }
802
803 fn end_transaction_at(
804 &mut self,
805 selection_set_ids: impl IntoIterator<Item = SelectionSetId>,
806 now: Instant,
807 cx: &mut ModelContext<Self>,
808 ) -> Result<()> {
809 if let Some(start_version) = self.text.end_transaction_at(selection_set_ids, now) {
810 cx.notify();
811 let was_dirty = start_version != self.saved_version;
812 let edited = self.edits_since(start_version).next().is_some();
813 if edited {
814 self.did_edit(was_dirty, cx);
815 self.reparse(cx);
816 }
817 }
818 Ok(())
819 }
820
821 pub fn edit<I, S, T>(&mut self, ranges_iter: I, new_text: T, cx: &mut ModelContext<Self>)
822 where
823 I: IntoIterator<Item = Range<S>>,
824 S: ToOffset,
825 T: Into<String>,
826 {
827 self.edit_internal(ranges_iter, new_text, false, cx)
828 }
829
830 pub fn edit_with_autoindent<I, S, T>(
831 &mut self,
832 ranges_iter: I,
833 new_text: T,
834 cx: &mut ModelContext<Self>,
835 ) where
836 I: IntoIterator<Item = Range<S>>,
837 S: ToOffset,
838 T: Into<String>,
839 {
840 self.edit_internal(ranges_iter, new_text, true, cx)
841 }
842
843 pub fn edit_internal<I, S, T>(
844 &mut self,
845 ranges_iter: I,
846 new_text: T,
847 autoindent: bool,
848 cx: &mut ModelContext<Self>,
849 ) where
850 I: IntoIterator<Item = Range<S>>,
851 S: ToOffset,
852 T: Into<String>,
853 {
854 let new_text = new_text.into();
855
856 // Skip invalid ranges and coalesce contiguous ones.
857 let mut ranges: Vec<Range<usize>> = Vec::new();
858 for range in ranges_iter {
859 let range = range.start.to_offset(&*self)..range.end.to_offset(&*self);
860 if !new_text.is_empty() || !range.is_empty() {
861 if let Some(prev_range) = ranges.last_mut() {
862 if prev_range.end >= range.start {
863 prev_range.end = cmp::max(prev_range.end, range.end);
864 } else {
865 ranges.push(range);
866 }
867 } else {
868 ranges.push(range);
869 }
870 }
871 }
872 if ranges.is_empty() {
873 return;
874 }
875
876 self.start_transaction(None).unwrap();
877 self.pending_autoindent.take();
878 let autoindent_request = if autoindent && self.language.is_some() {
879 let before_edit = self.snapshot();
880 let edited = self.content().anchor_set(ranges.iter().filter_map(|range| {
881 let start = range.start.to_point(&*self);
882 if new_text.starts_with('\n') && start.column == self.line_len(start.row) {
883 None
884 } else {
885 Some((range.start, Bias::Left))
886 }
887 }));
888 Some((before_edit, edited))
889 } else {
890 None
891 };
892
893 let first_newline_ix = new_text.find('\n');
894 let new_text_len = new_text.len();
895
896 let edit = self.text.edit(ranges.iter().cloned(), new_text);
897
898 if let Some((before_edit, edited)) = autoindent_request {
899 let mut inserted = None;
900 if let Some(first_newline_ix) = first_newline_ix {
901 let mut delta = 0isize;
902 inserted = Some(self.content().anchor_range_set(ranges.iter().map(|range| {
903 let start = (delta + range.start as isize) as usize + first_newline_ix + 1;
904 let end = (delta + range.start as isize) as usize + new_text_len;
905 delta += (range.end as isize - range.start as isize) + new_text_len as isize;
906 (start, Bias::Left)..(end, Bias::Right)
907 })));
908 }
909
910 let selection_set_ids = self
911 .text
912 .peek_undo_stack()
913 .unwrap()
914 .starting_selection_set_ids()
915 .collect();
916 self.autoindent_requests.push(Arc::new(AutoindentRequest {
917 selection_set_ids,
918 before_edit,
919 edited,
920 inserted,
921 }));
922 }
923
924 self.end_transaction(None, cx).unwrap();
925 self.send_operation(Operation::Edit(edit), cx);
926 }
927
928 fn did_edit(&self, was_dirty: bool, cx: &mut ModelContext<Self>) {
929 cx.emit(Event::Edited);
930 if !was_dirty {
931 cx.emit(Event::Dirtied);
932 }
933 }
934
935 pub fn add_selection_set<T: ToOffset>(
936 &mut self,
937 selections: &[Selection<T>],
938 cx: &mut ModelContext<Self>,
939 ) -> SelectionSetId {
940 let operation = self.text.add_selection_set(selections);
941 if let Operation::UpdateSelections { set_id, .. } = &operation {
942 let set_id = *set_id;
943 cx.notify();
944 self.send_operation(operation, cx);
945 set_id
946 } else {
947 unreachable!()
948 }
949 }
950
951 pub fn update_selection_set<T: ToOffset>(
952 &mut self,
953 set_id: SelectionSetId,
954 selections: &[Selection<T>],
955 cx: &mut ModelContext<Self>,
956 ) -> Result<()> {
957 let operation = self.text.update_selection_set(set_id, selections)?;
958 cx.notify();
959 self.send_operation(operation, cx);
960 Ok(())
961 }
962
963 pub fn set_active_selection_set(
964 &mut self,
965 set_id: Option<SelectionSetId>,
966 cx: &mut ModelContext<Self>,
967 ) -> Result<()> {
968 let operation = self.text.set_active_selection_set(set_id)?;
969 self.send_operation(operation, cx);
970 Ok(())
971 }
972
973 pub fn remove_selection_set(
974 &mut self,
975 set_id: SelectionSetId,
976 cx: &mut ModelContext<Self>,
977 ) -> Result<()> {
978 let operation = self.text.remove_selection_set(set_id)?;
979 cx.notify();
980 self.send_operation(operation, cx);
981 Ok(())
982 }
983
984 pub fn apply_ops<I: IntoIterator<Item = Operation>>(
985 &mut self,
986 ops: I,
987 cx: &mut ModelContext<Self>,
988 ) -> Result<()> {
989 self.pending_autoindent.take();
990
991 let was_dirty = self.is_dirty();
992 let old_version = self.version.clone();
993
994 self.text.apply_ops(ops)?;
995
996 cx.notify();
997 if self.edits_since(old_version).next().is_some() {
998 self.did_edit(was_dirty, cx);
999 self.reparse(cx);
1000 }
1001
1002 Ok(())
1003 }
1004
1005 #[cfg(not(test))]
1006 pub fn send_operation(&mut self, operation: Operation, cx: &mut ModelContext<Self>) {
1007 if let Some(file) = &self.file {
1008 file.buffer_updated(self.remote_id(), operation, cx.as_mut());
1009 }
1010 }
1011
1012 #[cfg(test)]
1013 pub fn send_operation(&mut self, operation: Operation, _: &mut ModelContext<Self>) {
1014 self.operations.push(operation);
1015 }
1016
1017 pub fn remove_peer(&mut self, replica_id: ReplicaId, cx: &mut ModelContext<Self>) {
1018 self.text.remove_peer(replica_id);
1019 cx.notify();
1020 }
1021
1022 pub fn undo(&mut self, cx: &mut ModelContext<Self>) {
1023 let was_dirty = self.is_dirty();
1024 let old_version = self.version.clone();
1025
1026 for operation in self.text.undo() {
1027 self.send_operation(operation, cx);
1028 }
1029
1030 cx.notify();
1031 if self.edits_since(old_version).next().is_some() {
1032 self.did_edit(was_dirty, cx);
1033 self.reparse(cx);
1034 }
1035 }
1036
1037 pub fn redo(&mut self, cx: &mut ModelContext<Self>) {
1038 let was_dirty = self.is_dirty();
1039 let old_version = self.version.clone();
1040
1041 for operation in self.text.redo() {
1042 self.send_operation(operation, cx);
1043 }
1044
1045 cx.notify();
1046 if self.edits_since(old_version).next().is_some() {
1047 self.did_edit(was_dirty, cx);
1048 self.reparse(cx);
1049 }
1050 }
1051}
1052
1053#[cfg(any(test, feature = "test-support"))]
1054impl Buffer {
1055 pub fn randomly_edit<T>(&mut self, rng: &mut T, old_range_count: usize)
1056 where
1057 T: rand::Rng,
1058 {
1059 self.text.randomly_edit(rng, old_range_count);
1060 }
1061
1062 pub fn randomly_mutate<T>(&mut self, rng: &mut T)
1063 where
1064 T: rand::Rng,
1065 {
1066 self.text.randomly_mutate(rng);
1067 }
1068}
1069
1070impl Entity for Buffer {
1071 type Event = Event;
1072
1073 fn release(&mut self, cx: &mut gpui::MutableAppContext) {
1074 if let Some(file) = self.file.as_ref() {
1075 file.buffer_removed(self.remote_id(), cx);
1076 }
1077 }
1078}
1079
1080impl Clone for Buffer {
1081 fn clone(&self) -> Self {
1082 Self {
1083 text: self.text.clone(),
1084 saved_version: self.saved_version.clone(),
1085 saved_mtime: self.saved_mtime,
1086 file: self.file.as_ref().map(|f| f.boxed_clone()),
1087 language: self.language.clone(),
1088 syntax_tree: Mutex::new(self.syntax_tree.lock().clone()),
1089 parsing_in_background: false,
1090 sync_parse_timeout: self.sync_parse_timeout,
1091 parse_count: self.parse_count,
1092 autoindent_requests: Default::default(),
1093 pending_autoindent: Default::default(),
1094
1095 #[cfg(test)]
1096 operations: self.operations.clone(),
1097 }
1098 }
1099}
1100
1101impl Deref for Buffer {
1102 type Target = TextBuffer;
1103
1104 fn deref(&self) -> &Self::Target {
1105 &self.text
1106 }
1107}
1108
1109impl<'a> From<&'a Buffer> for Content<'a> {
1110 fn from(buffer: &'a Buffer) -> Self {
1111 Self::from(&buffer.text)
1112 }
1113}
1114
1115impl<'a> From<&'a mut Buffer> for Content<'a> {
1116 fn from(buffer: &'a mut Buffer) -> Self {
1117 Self::from(&buffer.text)
1118 }
1119}
1120
1121impl<'a> From<&'a Snapshot> for Content<'a> {
1122 fn from(snapshot: &'a Snapshot) -> Self {
1123 Self::from(&snapshot.text)
1124 }
1125}
1126
1127impl Snapshot {
1128 fn suggest_autoindents<'a>(
1129 &'a self,
1130 row_range: Range<u32>,
1131 ) -> Option<impl Iterator<Item = IndentSuggestion> + 'a> {
1132 let mut query_cursor = QueryCursorHandle::new();
1133 if let Some((language, tree)) = self.language.as_ref().zip(self.tree.as_ref()) {
1134 let prev_non_blank_row = self.prev_non_blank_row(row_range.start);
1135
1136 // Get the "indentation ranges" that intersect this row range.
1137 let indent_capture_ix = language.indents_query.capture_index_for_name("indent");
1138 let end_capture_ix = language.indents_query.capture_index_for_name("end");
1139 query_cursor.set_point_range(
1140 Point::new(prev_non_blank_row.unwrap_or(row_range.start), 0).to_ts_point()
1141 ..Point::new(row_range.end, 0).to_ts_point(),
1142 );
1143 let mut indentation_ranges = Vec::<(Range<Point>, &'static str)>::new();
1144 for mat in query_cursor.matches(
1145 &language.indents_query,
1146 tree.root_node(),
1147 TextProvider(self.as_rope()),
1148 ) {
1149 let mut node_kind = "";
1150 let mut start: Option<Point> = None;
1151 let mut end: Option<Point> = None;
1152 for capture in mat.captures {
1153 if Some(capture.index) == indent_capture_ix {
1154 node_kind = capture.node.kind();
1155 start.get_or_insert(Point::from_ts_point(capture.node.start_position()));
1156 end.get_or_insert(Point::from_ts_point(capture.node.end_position()));
1157 } else if Some(capture.index) == end_capture_ix {
1158 end = Some(Point::from_ts_point(capture.node.start_position().into()));
1159 }
1160 }
1161
1162 if let Some((start, end)) = start.zip(end) {
1163 if start.row == end.row {
1164 continue;
1165 }
1166
1167 let range = start..end;
1168 match indentation_ranges.binary_search_by_key(&range.start, |r| r.0.start) {
1169 Err(ix) => indentation_ranges.insert(ix, (range, node_kind)),
1170 Ok(ix) => {
1171 let prev_range = &mut indentation_ranges[ix];
1172 prev_range.0.end = prev_range.0.end.max(range.end);
1173 }
1174 }
1175 }
1176 }
1177
1178 let mut prev_row = prev_non_blank_row.unwrap_or(0);
1179 Some(row_range.map(move |row| {
1180 let row_start = Point::new(row, self.indent_column_for_line(row));
1181
1182 let mut indent_from_prev_row = false;
1183 let mut outdent_to_row = u32::MAX;
1184 for (range, _node_kind) in &indentation_ranges {
1185 if range.start.row >= row {
1186 break;
1187 }
1188
1189 if range.start.row == prev_row && range.end > row_start {
1190 indent_from_prev_row = true;
1191 }
1192 if range.end.row >= prev_row && range.end <= row_start {
1193 outdent_to_row = outdent_to_row.min(range.start.row);
1194 }
1195 }
1196
1197 let suggestion = if outdent_to_row == prev_row {
1198 IndentSuggestion {
1199 basis_row: prev_row,
1200 indent: false,
1201 }
1202 } else if indent_from_prev_row {
1203 IndentSuggestion {
1204 basis_row: prev_row,
1205 indent: true,
1206 }
1207 } else if outdent_to_row < prev_row {
1208 IndentSuggestion {
1209 basis_row: outdent_to_row,
1210 indent: false,
1211 }
1212 } else {
1213 IndentSuggestion {
1214 basis_row: prev_row,
1215 indent: false,
1216 }
1217 };
1218
1219 prev_row = row;
1220 suggestion
1221 }))
1222 } else {
1223 None
1224 }
1225 }
1226
1227 fn prev_non_blank_row(&self, mut row: u32) -> Option<u32> {
1228 while row > 0 {
1229 row -= 1;
1230 if !self.is_line_blank(row) {
1231 return Some(row);
1232 }
1233 }
1234 None
1235 }
1236
1237 fn is_line_blank(&self, row: u32) -> bool {
1238 self.text_for_range(Point::new(row, 0)..Point::new(row, self.line_len(row)))
1239 .all(|chunk| chunk.matches(|c: char| !c.is_whitespace()).next().is_none())
1240 }
1241
1242 pub fn highlighted_text_for_range<T: ToOffset>(
1243 &mut self,
1244 range: Range<T>,
1245 ) -> HighlightedChunks {
1246 let range = range.start.to_offset(&*self)..range.end.to_offset(&*self);
1247 let chunks = self.text.as_rope().chunks_in_range(range.clone());
1248 if let Some((language, tree)) = self.language.as_ref().zip(self.tree.as_ref()) {
1249 let captures = self.query_cursor.set_byte_range(range.clone()).captures(
1250 &language.highlights_query,
1251 tree.root_node(),
1252 TextProvider(self.text.as_rope()),
1253 );
1254
1255 HighlightedChunks {
1256 range,
1257 chunks,
1258 highlights: Some(Highlights {
1259 captures,
1260 next_capture: None,
1261 stack: Default::default(),
1262 highlight_map: language.highlight_map(),
1263 }),
1264 }
1265 } else {
1266 HighlightedChunks {
1267 range,
1268 chunks,
1269 highlights: None,
1270 }
1271 }
1272 }
1273}
1274
1275impl Clone for Snapshot {
1276 fn clone(&self) -> Self {
1277 Self {
1278 text: self.text.clone(),
1279 tree: self.tree.clone(),
1280 is_parsing: self.is_parsing,
1281 language: self.language.clone(),
1282 query_cursor: QueryCursorHandle::new(),
1283 }
1284 }
1285}
1286
1287impl Deref for Snapshot {
1288 type Target = buffer::Snapshot;
1289
1290 fn deref(&self) -> &Self::Target {
1291 &self.text
1292 }
1293}
1294
1295impl<'a> tree_sitter::TextProvider<'a> for TextProvider<'a> {
1296 type I = ByteChunks<'a>;
1297
1298 fn text(&mut self, node: tree_sitter::Node) -> Self::I {
1299 ByteChunks(self.0.chunks_in_range(node.byte_range()))
1300 }
1301}
1302
1303struct ByteChunks<'a>(rope::Chunks<'a>);
1304
1305impl<'a> Iterator for ByteChunks<'a> {
1306 type Item = &'a [u8];
1307
1308 fn next(&mut self) -> Option<Self::Item> {
1309 self.0.next().map(str::as_bytes)
1310 }
1311}
1312
1313impl<'a> HighlightedChunks<'a> {
1314 pub fn seek(&mut self, offset: usize) {
1315 self.range.start = offset;
1316 self.chunks.seek(self.range.start);
1317 if let Some(highlights) = self.highlights.as_mut() {
1318 highlights
1319 .stack
1320 .retain(|(end_offset, _)| *end_offset > offset);
1321 if let Some((mat, capture_ix)) = &highlights.next_capture {
1322 let capture = mat.captures[*capture_ix as usize];
1323 if offset >= capture.node.start_byte() {
1324 let next_capture_end = capture.node.end_byte();
1325 if offset < next_capture_end {
1326 highlights.stack.push((
1327 next_capture_end,
1328 highlights.highlight_map.get(capture.index),
1329 ));
1330 }
1331 highlights.next_capture.take();
1332 }
1333 }
1334 highlights.captures.set_byte_range(self.range.clone());
1335 }
1336 }
1337
1338 pub fn offset(&self) -> usize {
1339 self.range.start
1340 }
1341}
1342
1343impl<'a> Iterator for HighlightedChunks<'a> {
1344 type Item = (&'a str, HighlightId);
1345
1346 fn next(&mut self) -> Option<Self::Item> {
1347 let mut next_capture_start = usize::MAX;
1348
1349 if let Some(highlights) = self.highlights.as_mut() {
1350 while let Some((parent_capture_end, _)) = highlights.stack.last() {
1351 if *parent_capture_end <= self.range.start {
1352 highlights.stack.pop();
1353 } else {
1354 break;
1355 }
1356 }
1357
1358 if highlights.next_capture.is_none() {
1359 highlights.next_capture = highlights.captures.next();
1360 }
1361
1362 while let Some((mat, capture_ix)) = highlights.next_capture.as_ref() {
1363 let capture = mat.captures[*capture_ix as usize];
1364 if self.range.start < capture.node.start_byte() {
1365 next_capture_start = capture.node.start_byte();
1366 break;
1367 } else {
1368 let style_id = highlights.highlight_map.get(capture.index);
1369 highlights.stack.push((capture.node.end_byte(), style_id));
1370 highlights.next_capture = highlights.captures.next();
1371 }
1372 }
1373 }
1374
1375 if let Some(chunk) = self.chunks.peek() {
1376 let chunk_start = self.range.start;
1377 let mut chunk_end = (self.chunks.offset() + chunk.len()).min(next_capture_start);
1378 let mut style_id = HighlightId::default();
1379 if let Some((parent_capture_end, parent_style_id)) =
1380 self.highlights.as_ref().and_then(|h| h.stack.last())
1381 {
1382 chunk_end = chunk_end.min(*parent_capture_end);
1383 style_id = *parent_style_id;
1384 }
1385
1386 let slice =
1387 &chunk[chunk_start - self.chunks.offset()..chunk_end - self.chunks.offset()];
1388 self.range.start = chunk_end;
1389 if self.range.start == self.chunks.offset() + chunk.len() {
1390 self.chunks.next().unwrap();
1391 }
1392
1393 Some((slice, style_id))
1394 } else {
1395 None
1396 }
1397 }
1398}
1399
1400impl QueryCursorHandle {
1401 fn new() -> Self {
1402 QueryCursorHandle(Some(
1403 QUERY_CURSORS
1404 .lock()
1405 .pop()
1406 .unwrap_or_else(|| QueryCursor::new()),
1407 ))
1408 }
1409}
1410
1411impl Deref for QueryCursorHandle {
1412 type Target = QueryCursor;
1413
1414 fn deref(&self) -> &Self::Target {
1415 self.0.as_ref().unwrap()
1416 }
1417}
1418
1419impl DerefMut for QueryCursorHandle {
1420 fn deref_mut(&mut self) -> &mut Self::Target {
1421 self.0.as_mut().unwrap()
1422 }
1423}
1424
1425impl Drop for QueryCursorHandle {
1426 fn drop(&mut self) {
1427 let mut cursor = self.0.take().unwrap();
1428 cursor.set_byte_range(0..usize::MAX);
1429 cursor.set_point_range(Point::zero().to_ts_point()..Point::MAX.to_ts_point());
1430 QUERY_CURSORS.lock().push(cursor)
1431 }
1432}
1433
1434trait ToTreeSitterPoint {
1435 fn to_ts_point(self) -> tree_sitter::Point;
1436 fn from_ts_point(point: tree_sitter::Point) -> Self;
1437}
1438
1439impl ToTreeSitterPoint for Point {
1440 fn to_ts_point(self) -> tree_sitter::Point {
1441 tree_sitter::Point::new(self.row as usize, self.column as usize)
1442 }
1443
1444 fn from_ts_point(point: tree_sitter::Point) -> Self {
1445 Point::new(point.row as u32, point.column as u32)
1446 }
1447}
1448
1449fn contiguous_ranges(
1450 values: impl IntoIterator<Item = u32>,
1451 max_len: usize,
1452) -> impl Iterator<Item = Range<u32>> {
1453 let mut values = values.into_iter();
1454 let mut current_range: Option<Range<u32>> = None;
1455 std::iter::from_fn(move || loop {
1456 if let Some(value) = values.next() {
1457 if let Some(range) = &mut current_range {
1458 if value == range.end && range.len() < max_len {
1459 range.end += 1;
1460 continue;
1461 }
1462 }
1463
1464 let prev_range = current_range.clone();
1465 current_range = Some(value..(value + 1));
1466 if prev_range.is_some() {
1467 return prev_range;
1468 }
1469 } else {
1470 return current_range.take();
1471 }
1472 })
1473}