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