Use word boundaries instead of syntax to infer completion edit ranges

Antonio Scandurra created 3 years ago

Change summary

crates/language/src/buffer.rs | 45 ++++++++++++++++++------------------
crates/project/src/project.rs | 17 ++++++++-----
2 files changed, 33 insertions(+), 29 deletions(-)

Detailed changes

crates/language/src/buffer.rs

@@ -1667,32 +1667,33 @@ impl BufferSnapshot {
             .and_then(|language| language.grammar.as_ref())
     }
 
-    pub fn range_for_word_token_at<T: ToOffset + ToPoint>(
-        &self,
-        position: T,
-    ) -> Option<Range<usize>> {
-        let offset = position.to_offset(self);
+    pub fn surrounding_word<T: ToOffset>(&self, start: T) -> (Range<usize>, Option<CharKind>) {
+        let mut start = start.to_offset(self);
+        let mut end = start;
+        let mut next_chars = self.chars_at(start).peekable();
+        let mut prev_chars = self.reversed_chars_at(start).peekable();
+        let word_kind = cmp::max(
+            prev_chars.peek().copied().map(char_kind),
+            next_chars.peek().copied().map(char_kind),
+        );
 
-        // Find the first leaf node that touches the position.
-        let tree = self.tree.as_ref()?;
-        let mut cursor = tree.root_node().walk();
-        while cursor.goto_first_child_for_byte(offset).is_some() {}
-        let node = cursor.node();
-        if node.child_count() > 0 {
-            return None;
+        for ch in prev_chars {
+            if Some(char_kind(ch)) == word_kind && ch != '\n' {
+                start -= ch.len_utf8();
+            } else {
+                break;
+            }
         }
 
-        // Check that the leaf node contains word characters.
-        let range = node.byte_range();
-        if self
-            .text_for_range(range.clone())
-            .flat_map(str::chars)
-            .any(|c| c.is_alphanumeric())
-        {
-            return Some(range);
-        } else {
-            None
+        for ch in next_chars {
+            if Some(char_kind(ch)) == word_kind && ch != '\n' {
+                end += ch.len_utf8();
+            } else {
+                break;
+            }
         }
+
+        (start..end, word_kind)
     }
 
     pub fn range_for_syntax_ancestor<T: ToOffset>(&self, range: Range<T>) -> Option<Range<usize>> {

crates/project/src/project.rs

@@ -18,10 +18,10 @@ use gpui::{
 use language::{
     point_to_lsp,
     proto::{deserialize_anchor, deserialize_version, serialize_anchor, serialize_version},
-    range_from_lsp, range_to_lsp, Anchor, Bias, Buffer, CodeAction, CodeLabel, Completion,
-    Diagnostic, DiagnosticEntry, DiagnosticSet, Event as BufferEvent, File as _, Language,
-    LanguageRegistry, LanguageServerName, LocalFile, LspAdapter, OffsetRangeExt, Operation, Patch,
-    PointUtf16, TextBufferSnapshot, ToOffset, ToPointUtf16, Transaction,
+    range_from_lsp, range_to_lsp, Anchor, Bias, Buffer, CharKind, CodeAction, CodeLabel,
+    Completion, Diagnostic, DiagnosticEntry, DiagnosticSet, Event as BufferEvent, File as _,
+    Language, LanguageRegistry, LanguageServerName, LocalFile, LspAdapter, OffsetRangeExt,
+    Operation, Patch, PointUtf16, TextBufferSnapshot, ToOffset, ToPointUtf16, Transaction,
 };
 use lsp::{
     DiagnosticSeverity, DiagnosticTag, DocumentHighlightKind, LanguageServer, LanguageString,
@@ -3182,9 +3182,12 @@ impl Project {
                                     let Range { start, end } = range_for_token
                                         .get_or_insert_with(|| {
                                             let offset = position.to_offset(&snapshot);
-                                            snapshot
-                                                .range_for_word_token_at(offset)
-                                                .unwrap_or_else(|| offset..offset)
+                                            let (range, kind) = snapshot.surrounding_word(offset);
+                                            if kind == Some(CharKind::Word) {
+                                                range
+                                            } else {
+                                                offset..offset
+                                            }
                                         })
                                         .clone();
                                     let text = lsp_completion