Use new in-crate TreeCursor

helix-core/src/object.rs

@@ -1,5 +1,4 @@
-use crate::{movement::Direction, syntax::TreeCursor, Range, RopeSlice, Selection, Syntax};
-use tree_sitter::{Node, Tree};
+use crate::{syntax::TreeCursor, Range, RopeSlice, Selection, Syntax};
 
 pub fn expand_selection(syntax: &Syntax, text: RopeSlice, selection: Selection) -> Selection {
     let cursor = &mut syntax.walk();
@@ -41,85 +40,46 @@ pub fn select_next_sibling(syntax: &Syntax, text: RopeSlice, selection: Selectio
     })
 }
 
-fn find_parent_with_more_children(mut node: Node) -> Option<Node> {
-    while let Some(parent) = node.parent() {
-        if parent.child_count() > 1 {
-            return Some(parent);
-        }
-
-        node = parent;
-    }
-
-    None
-}
-
-pub fn select_all_siblings(tree: &Tree, text: RopeSlice, selection: Selection) -> Selection {
-    let root_node = &tree.root_node();
-
+pub fn select_all_siblings(syntax: &Syntax, text: RopeSlice, selection: Selection) -> Selection {
     selection.transform_iter(|range| {
-        let from = text.char_to_byte(range.from());
-        let to = text.char_to_byte(range.to());
+        let mut cursor = syntax.walk();
+        let (from, to) = range.into_byte_range(text);
+        cursor.reset_to_byte_range(from, to);
+
+        if !cursor.goto_parent_with(|parent| parent.child_count() > 1) {
+            return vec![range].into_iter();
+        }
 
-        root_node
-            .descendant_for_byte_range(from, to)
-            .and_then(find_parent_with_more_children)
-            .and_then(|parent| select_children(parent, text, range.direction()))
-            .unwrap_or_else(|| vec![range].into_iter())
+        select_children(&mut cursor, text, range).into_iter()
     })
 }
 
-pub fn select_all_children(tree: &Tree, text: RopeSlice, selection: Selection) -> Selection {
-    let root_node = &tree.root_node();
-
+pub fn select_all_children(syntax: &Syntax, text: RopeSlice, selection: Selection) -> Selection {
     selection.transform_iter(|range| {
-        let from = text.char_to_byte(range.from());
-        let to = text.char_to_byte(range.to());
-
-        root_node
-            .descendant_for_byte_range(from, to)
-            .and_then(|parent| select_children(parent, text, range.direction()))
-            .unwrap_or_else(|| vec![range].into_iter())
+        let mut cursor = syntax.walk();
+        let (from, to) = range.into_byte_range(text);
+        cursor.reset_to_byte_range(from, to);
+        select_children(&mut cursor, text, range).into_iter()
     })
 }
 
-fn select_children(
-    node: Node,
+fn select_children<'n>(
+    cursor: &'n mut TreeCursor<'n>,
     text: RopeSlice,
-    direction: Direction,
-) -> Option<<Vec<Range> as std::iter::IntoIterator>::IntoIter> {
-    let mut cursor = node.walk();
-
-    let children = node
-        .named_children(&mut cursor)
-        .map(|child| {
-            let from = text.byte_to_char(child.start_byte());
-            let to = text.byte_to_char(child.end_byte());
-
-            if direction == Direction::Backward {
-                Range::new(to, from)
-            } else {
-                Range::new(from, to)
-            }
-        })
+    range: Range,
+) -> Vec<Range> {
+    let children = cursor
+        .named_children()
+        .map(|child| Range::from_node(child, text, range.direction()))
         .collect::<Vec<_>>();
 
     if !children.is_empty() {
-        Some(children.into_iter())
+        children
     } else {
-        None
+        vec![range]
     }
 }
 
-fn find_sibling_recursive<F>(node: Node, sibling_fn: F) -> Option<Node>
-where
-    F: Fn(Node) -> Option<Node>,
-{
-    sibling_fn(node).or_else(|| {
-        node.parent()
-            .and_then(|node| find_sibling_recursive(node, sibling_fn))
-    })
-}
-
 pub fn select_prev_sibling(syntax: &Syntax, text: RopeSlice, selection: Selection) -> Selection {
     select_node_impl(syntax, text, selection, |cursor| {
         while !cursor.goto_prev_sibling() {

helix-core/src/syntax/tree_cursor.rs

@@ -90,6 +90,19 @@ impl<'a> TreeCursor<'a> {
         true
     }
 
+    pub fn goto_parent_with<P>(&mut self, predicate: P) -> bool
+    where
+        P: Fn(&Node) -> bool,
+    {
+        while self.goto_parent() {
+            if predicate(&self.node()) {
+                return true;
+            }
+        }
+
+        false
+    }
+
     /// Finds the injection layer that has exactly the same range as the given `range`.
     fn layer_id_of_byte_range(&self, search_range: Range<usize>) -> Option<LayerId> {
         let start_idx = self
@@ -102,7 +115,7 @@ impl<'a> TreeCursor<'a> {
             .find_map(|range| (range.start == search_range.start).then_some(range.layer_id))
     }
 
-    pub fn goto_first_child(&mut self) -> bool {
+    fn goto_first_child_impl(&mut self, named: bool) -> bool {
         // Check if the current node's range is an exact injection layer range.
         if let Some(layer_id) = self
             .layer_id_of_byte_range(self.node().byte_range())
@@ -111,8 +124,16 @@ impl<'a> TreeCursor<'a> {
             // Switch to the child layer.
             self.current = layer_id;
             self.cursor = self.layers[self.current].tree().root_node();
-            true
-        } else if let Some(child) = self.cursor.child(0) {
+            return true;
+        }
+
+        let child = if named {
+            self.cursor.named_child(0)
+        } else {
+            self.cursor.child(0)
+        };
+
+        if let Some(child) = child {
             // Otherwise descend in the current tree.
             self.cursor = child;
             true
@@ -121,24 +142,60 @@ impl<'a> TreeCursor<'a> {
         }
     }
 
-    pub fn goto_next_sibling(&mut self) -> bool {
-        if let Some(sibling) = self.cursor.next_sibling() {
+    pub fn goto_first_child(&mut self) -> bool {
+        self.goto_first_child_impl(false)
+    }
+
+    pub fn goto_first_named_child(&mut self) -> bool {
+        self.goto_first_child_impl(true)
+    }
+
+    fn goto_next_sibling_impl(&mut self, named: bool) -> bool {
+        let sibling = if named {
+            self.cursor.next_named_sibling()
+        } else {
+            self.cursor.next_sibling()
+        };
+
+        if let Some(sibling) = sibling {
             self.cursor = sibling;
             true
         } else {
             false
         }
     }
 
-    pub fn goto_prev_sibling(&mut self) -> bool {
-        if let Some(sibling) = self.cursor.prev_sibling() {
+    pub fn goto_next_sibling(&mut self) -> bool {
+        self.goto_next_sibling_impl(false)
+    }
+
+    pub fn goto_next_named_sibling(&mut self) -> bool {
+        self.goto_next_sibling_impl(true)
+    }
+
+    fn goto_prev_sibling_impl(&mut self, named: bool) -> bool {
+        let sibling = if named {
+            self.cursor.prev_named_sibling()
+        } else {
+            self.cursor.prev_sibling()
+        };
+
+        if let Some(sibling) = sibling {
             self.cursor = sibling;
             true
         } else {
             false
         }
     }
 
+    pub fn goto_prev_sibling(&mut self) -> bool {
+        self.goto_prev_sibling_impl(false)
+    }
+
+    pub fn goto_prev_named_sibling(&mut self) -> bool {
+        self.goto_prev_sibling_impl(true)
+    }
+
     /// Finds the injection layer that contains the given start-end range.
     fn layer_id_containing_byte_range(&self, start: usize, end: usize) -> LayerId {
         let start_idx = self
@@ -157,4 +214,51 @@ impl<'a> TreeCursor<'a> {
         let root = self.layers[self.current].tree().root_node();
         self.cursor = root.descendant_for_byte_range(start, end).unwrap_or(root);
     }
+
+    /// Returns an iterator over the children of the node the TreeCursor is on
+    /// at the time this is called.
+    pub fn children(&'a mut self) -> ChildIter {
+        let parent = self.node();
+
+        ChildIter {
+            cursor: self,
+            parent,
+            named: false,
+        }
+    }
+
+    /// Returns an iterator over the named children of the node the TreeCursor is on
+    /// at the time this is called.
+    pub fn named_children(&'a mut self) -> ChildIter {
+        let parent = self.node();
+
+        ChildIter {
+            cursor: self,
+            parent,
+            named: true,
+        }
+    }
+}
+
+pub struct ChildIter<'n> {
+    cursor: &'n mut TreeCursor<'n>,
+    parent: Node<'n>,
+    named: bool,
+}
+
+impl<'n> Iterator for ChildIter<'n> {
+    type Item = Node<'n>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        // first iteration, just visit the first child
+        if self.cursor.node() == self.parent {
+            self.cursor
+                .goto_first_child_impl(self.named)
+                .then(|| self.cursor.node())
+        } else {
+            self.cursor
+                .goto_next_sibling_impl(self.named)
+                .then(|| self.cursor.node())
+        }
+    }
 }

helix-term/src/commands.rs

@@ -38,7 +38,7 @@ use helix_core::{
     textobject,
     unicode::width::UnicodeWidthChar,
     visual_offset_from_block, Deletion, LineEnding, Position, Range, Rope, RopeGraphemes,
-    RopeReader, RopeSlice, Selection, SmallVec, Tendril, Transaction,
+    RopeReader, RopeSlice, Selection, SmallVec, Syntax, Tendril, Transaction,
 };
 use helix_view::{
     document::{FormatterError, Mode, SCRATCH_BUFFER_NAME},
@@ -4976,37 +4976,34 @@ pub fn extend_parent_node_start(cx: &mut Context) {
     move_node_bound_impl(cx, Direction::Backward, Movement::Extend)
 }
 
+fn select_all_impl<F>(editor: &mut Editor, select_fn: F)
+where
+    F: Fn(&Syntax, RopeSlice, Selection) -> Selection,
+{
+    let (view, doc) = current!(editor);
+
+    if let Some(syntax) = doc.syntax() {
+        let text = doc.text().slice(..);
+        let current_selection = doc.selection(view.id);
+        let selection = select_fn(syntax, text, current_selection.clone());
+        doc.set_selection(view.id, selection);
+    }
+}
+
 fn select_all_siblings(cx: &mut Context) {
     let motion = |editor: &mut Editor| {
-        let (view, doc) = current!(editor);
-
-        if let Some(syntax) = doc.syntax() {
-            let text = doc.text().slice(..);
-            let current_selection = doc.selection(view.id);
-            let selection =
-                object::select_all_siblings(syntax.tree(), text, current_selection.clone());
-            doc.set_selection(view.id, selection);
-        }
+        select_all_impl(editor, object::select_all_siblings);
     };
 
     cx.editor.apply_motion(motion);
 }
 
 fn select_all_children(cx: &mut Context) {
     let motion = |editor: &mut Editor| {
-        let (view, doc) = current!(editor);
-
-        if let Some(syntax) = doc.syntax() {
-            let text = doc.text().slice(..);
-            let current_selection = doc.selection(view.id);
-            let selection =
-                object::select_all_children(syntax.tree(), text, current_selection.clone());
-            doc.set_selection(view.id, selection);
-        }
+        select_all_impl(editor, object::select_all_children);
     };
 
-    motion(cx.editor);
-    cx.editor.last_motion = Some(Motion(Box::new(motion)));
+    cx.editor.apply_motion(motion);
 }
 
 fn match_brackets(cx: &mut Context) {
@@ -6048,7 +6045,10 @@ fn jump_to_label(cx: &mut Context, labels: Vec<Range>, behaviour: Movement) {
     let doc = doc.id();
     cx.on_next_key(move |cx, event| {
         let alphabet = &cx.editor.config().jump_label_alphabet;
-        let Some(i ) = event.char().and_then(|ch| alphabet.iter().position(|&it| it == ch)) else {
+        let Some(i) = event
+            .char()
+            .and_then(|ch| alphabet.iter().position(|&it| it == ch))
+        else {
             doc_mut!(cx.editor, &doc).remove_jump_labels(view);
             return;
         };
@@ -6061,7 +6061,10 @@ fn jump_to_label(cx: &mut Context, labels: Vec<Range>, behaviour: Movement) {
         cx.on_next_key(move |cx, event| {
             doc_mut!(cx.editor, &doc).remove_jump_labels(view);
             let alphabet = &cx.editor.config().jump_label_alphabet;
-            let Some(inner ) = event.char().and_then(|ch| alphabet.iter().position(|&it| it == ch)) else {
+            let Some(inner) = event
+                .char()
+                .and_then(|ch| alphabet.iter().position(|&it| it == ch))
+            else {
                 return;
             };
             if let Some(mut range) = labels.get(outer + inner).copied() {
@@ -6081,8 +6084,8 @@ fn jump_to_label(cx: &mut Context, labels: Vec<Range>, behaviour: Movement) {
                             to
                         }
                     };
-                     Range::new(anchor, range.head)
-                }else{
+                    Range::new(anchor, range.head)
+                } else {
                     range.with_direction(Direction::Forward)
                 };
                 doc_mut!(cx.editor, &doc).set_selection(view, range.into());