rslint_rowan/
cursor.rs

1use std::{
2    cell::RefCell,
3    fmt,
4    hash::{Hash, Hasher},
5    iter, mem, ptr,
6    sync::Arc,
7};
8
9use crate::{
10    green::{GreenElementRef, SyntaxKind},
11    Children, Direction, GreenNode, GreenToken, NodeOrToken, SmolStr, SyntaxText, TextRange,
12    TextSize, TokenAtOffset, WalkEvent,
13};
14
15#[derive(Debug, Clone)]
16pub struct SyntaxNode(Arc<NodeData>);
17
18impl Drop for SyntaxNode {
19    fn drop(&mut self) {
20        NodeData::delete(&mut self.0)
21    }
22}
23
24// Identity semantics for hash & eq
25impl PartialEq for SyntaxNode {
26    fn eq(&self, other: &SyntaxNode) -> bool {
27        self.green().ptr() == other.green().ptr()
28            && self.text_range().start() == other.text_range().start()
29    }
30}
31
32impl Eq for SyntaxNode {}
33
34impl Hash for SyntaxNode {
35    fn hash<H: Hasher>(&self, state: &mut H) {
36        ptr::hash(self.green().ptr(), state);
37        self.text_range().start().hash(state);
38    }
39}
40
41impl fmt::Display for SyntaxNode {
42    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
43        self.preorder_with_tokens()
44            .filter_map(|event| match event {
45                WalkEvent::Enter(NodeOrToken::Token(token)) => Some(token),
46                _ => None,
47            })
48            .try_for_each(|it| fmt::Display::fmt(&it, f))
49    }
50}
51
52#[derive(Debug, Clone, PartialEq, Eq, Hash)]
53pub struct SyntaxToken {
54    parent: SyntaxNode,
55    index: u32,
56    offset: TextSize,
57}
58
59impl fmt::Display for SyntaxToken {
60    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
61        fmt::Display::fmt(self.text(), f)
62    }
63}
64
65pub type SyntaxElement = NodeOrToken<SyntaxNode, SyntaxToken>;
66
67impl From<SyntaxNode> for SyntaxElement {
68    fn from(node: SyntaxNode) -> SyntaxElement {
69        NodeOrToken::Node(node)
70    }
71}
72
73impl From<SyntaxToken> for SyntaxElement {
74    fn from(token: SyntaxToken) -> SyntaxElement {
75        NodeOrToken::Token(token)
76    }
77}
78
79impl fmt::Display for SyntaxElement {
80    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
81        match self {
82            NodeOrToken::Node(it) => fmt::Display::fmt(it, f),
83            NodeOrToken::Token(it) => fmt::Display::fmt(it, f),
84        }
85    }
86}
87
88#[derive(Debug)]
89enum Kind {
90    Root(GreenNode),
91    Child { parent: SyntaxNode, index: u32, offset: TextSize },
92    Free { next_free: Option<Arc<NodeData>> },
93}
94
95impl Kind {
96    fn as_child(&self) -> Option<(&SyntaxNode, u32, TextSize)> {
97        match self {
98            Kind::Child { parent, index, offset } => Some((parent, *index, *offset)),
99            _ => None,
100        }
101    }
102}
103
104#[derive(Debug)]
105struct NodeData {
106    kind: Kind,
107    green: ptr::NonNull<GreenNode>,
108}
109
110unsafe impl Send for NodeData {}
111unsafe impl Sync for NodeData {}
112
113struct FreeList {
114    first_free: Option<Arc<NodeData>>,
115    len: usize,
116}
117
118const FREE_LIST_LEN: usize = 128;
119
120impl FreeList {
121    fn new() -> FreeList {
122        let mut res = FreeList { first_free: None, len: 0 };
123        for _ in 0..FREE_LIST_LEN {
124            res.try_push(&mut Arc::new(NodeData {
125                kind: Kind::Free { next_free: None },
126                green: ptr::NonNull::dangling(),
127            }))
128        }
129        res
130    }
131
132    fn with<T, F: FnOnce(&mut FreeList) -> T>(f: F) -> T {
133        thread_local! {
134            static INSTANCE: RefCell<FreeList> = RefCell::new(FreeList::new());
135        }
136        INSTANCE.with(|it| f(&mut *it.borrow_mut()))
137    }
138
139    fn pop(&mut self) -> Option<Arc<NodeData>> {
140        let mut node = self.first_free.take()?;
141        self.len -= 1;
142        {
143            let node = Arc::get_mut(&mut node).unwrap();
144            self.first_free = match &mut node.kind {
145                Kind::Free { next_free } => next_free.take(),
146                _ => unreachable!(),
147            }
148        }
149        Some(node)
150    }
151
152    fn try_push(&mut self, node: &mut Arc<NodeData>) {
153        if self.len >= FREE_LIST_LEN {
154            return;
155        }
156        Arc::get_mut(node).unwrap().kind = Kind::Free { next_free: self.first_free.take() };
157        self.first_free = Some(Arc::clone(node));
158        self.len += 1;
159    }
160}
161
162impl NodeData {
163    fn new(kind: Kind, green: ptr::NonNull<GreenNode>) -> Arc<NodeData> {
164        let mut node = FreeList::with(|it| it.pop()).unwrap_or_else(|| {
165            Arc::new(NodeData {
166                kind: Kind::Free { next_free: None },
167                green: ptr::NonNull::dangling(),
168            })
169        });
170
171        {
172            let node = Arc::get_mut(&mut node).unwrap();
173            node.kind = kind;
174            node.green = green;
175        }
176        node
177    }
178    fn delete(this: &mut Arc<NodeData>) {
179        if let Some(this_mut) = Arc::get_mut(this) {
180            // NB: this might drop SyntaxNodes
181            this_mut.kind = Kind::Free { next_free: None };
182            FreeList::with(|it| it.try_push(this))
183        }
184    }
185}
186
187impl SyntaxNode {
188    fn new(data: Arc<NodeData>) -> SyntaxNode {
189        SyntaxNode(data)
190    }
191
192    pub fn new_root(green: GreenNode) -> SyntaxNode {
193        let data = NodeData::new(Kind::Root(green), ptr::NonNull::dangling());
194        let mut ret = SyntaxNode::new(data);
195        let green: ptr::NonNull<GreenNode> = match &ret.0.kind {
196            Kind::Root(green) => green.into(),
197            _ => unreachable!(),
198        };
199        Arc::get_mut(&mut ret.0).unwrap().green = green;
200        ret
201    }
202
203    // Technically, unsafe, but private so that's OK.
204    // Safety: `green` must be a descendent of `parent.green()`
205    fn new_child(
206        green: &GreenNode,
207        parent: SyntaxNode,
208        index: u32,
209        offset: TextSize,
210    ) -> SyntaxNode {
211        let data = NodeData::new(Kind::Child { parent, index, offset }, green.into());
212        SyntaxNode::new(data)
213    }
214
215    /// Returns a green tree, equal to the green tree this node
216    /// belongs two, except with this node substitute. The complexity
217    /// of operation is proportional to the depth of the tree
218    pub fn replace_with(&self, replacement: GreenNode) -> GreenNode {
219        assert_eq!(self.kind(), replacement.kind());
220        match self.0.kind.as_child() {
221            None => replacement,
222            Some((parent, me, _offset)) => {
223                let mut replacement = Some(replacement);
224                let children = parent.green().children().enumerate().map(|(i, child)| {
225                    if i as u32 == me {
226                        replacement.take().unwrap().into()
227                    } else {
228                        child.cloned()
229                    }
230                });
231                let new_parent = GreenNode::new(parent.kind(), children);
232                parent.replace_with(new_parent)
233            }
234        }
235    }
236
237    pub fn kind(&self) -> SyntaxKind {
238        self.green().kind()
239    }
240
241    pub fn text_range(&self) -> TextRange {
242        let offset = match self.0.kind.as_child() {
243            Some((_, _, it)) => it,
244            _ => 0.into(),
245        };
246        TextRange::at(offset, self.green().text_len())
247    }
248
249    pub fn text(&self) -> SyntaxText {
250        SyntaxText::new(self.clone())
251    }
252
253    pub fn green(&self) -> &GreenNode {
254        unsafe { self.0.green.as_ref() }
255    }
256
257    pub fn parent(&self) -> Option<SyntaxNode> {
258        match &self.0.kind {
259            Kind::Root(_) => None,
260            Kind::Child { parent, .. } => Some(parent.clone()),
261            Kind::Free { .. } => unreachable!(),
262        }
263    }
264
265    pub fn ancestors(&self) -> impl Iterator<Item = SyntaxNode> {
266        iter::successors(Some(self.clone()), SyntaxNode::parent)
267    }
268
269    pub fn children(&self) -> SyntaxNodeChildren {
270        SyntaxNodeChildren::new(self.clone())
271    }
272
273    pub fn children_with_tokens(&self) -> SyntaxElementChildren {
274        SyntaxElementChildren::new(self.clone())
275    }
276
277    #[inline]
278    pub fn first_child(&self) -> Option<SyntaxNode> {
279        let (node, (index, offset)) =
280            filter_nodes(self.green().children_from(0, self.text_range().start())).next()?;
281
282        Some(SyntaxNode::new_child(node, self.clone(), index as u32, offset))
283    }
284
285    pub fn first_child_or_token(&self) -> Option<SyntaxElement> {
286        let (element, (index, offset)) =
287            self.green().children_from(0, self.text_range().start()).next()?;
288        Some(SyntaxElement::new(element, self.clone(), index as u32, offset))
289    }
290
291    #[inline]
292    pub fn last_child(&self) -> Option<SyntaxNode> {
293        let (node, (index, offset)) = filter_nodes(
294            self.green().children_to(self.green().children().len(), self.text_range().end()),
295        )
296        .next()?;
297
298        Some(SyntaxNode::new_child(node, self.clone(), index as u32, offset))
299    }
300
301    pub fn last_child_or_token(&self) -> Option<SyntaxElement> {
302        let (element, (index, offset)) = self
303            .green()
304            .children_to(self.green().children().len(), self.text_range().end())
305            .next()?;
306        Some(SyntaxElement::new(element, self.clone(), index as u32, offset))
307    }
308
309    pub fn next_sibling(&self) -> Option<SyntaxNode> {
310        let (parent, index, _) = self.0.kind.as_child()?;
311
312        let (node, (index, offset)) = filter_nodes(
313            parent.green().children_from((index + 1) as usize, self.text_range().end()),
314        )
315        .next()?;
316
317        Some(SyntaxNode::new_child(node, parent.clone(), index as u32, offset))
318    }
319
320    pub fn next_sibling_or_token(&self) -> Option<SyntaxElement> {
321        let (parent, index, _) = self.0.kind.as_child()?;
322
323        let (element, (index, offset)) =
324            parent.green().children_from((index + 1) as usize, self.text_range().end()).next()?;
325
326        Some(SyntaxElement::new(element, parent.clone(), index as u32, offset))
327    }
328
329    pub fn prev_sibling(&self) -> Option<SyntaxNode> {
330        let (parent, index, _) = self.0.kind.as_child()?;
331
332        let (node, (index, offset)) =
333            filter_nodes(parent.green().children_to(index as usize, self.text_range().start()))
334                .next()?;
335
336        Some(SyntaxNode::new_child(node, parent.clone(), index as u32, offset))
337    }
338
339    pub fn prev_sibling_or_token(&self) -> Option<SyntaxElement> {
340        let (parent, index, _) = self.0.kind.as_child()?;
341
342        let (element, (index, offset)) =
343            parent.green().children_to(index as usize, self.text_range().start()).next()?;
344
345        Some(SyntaxElement::new(element, parent.clone(), index as u32, offset))
346    }
347
348    /// Return the leftmost token in the subtree of this node
349    #[inline]
350    pub fn first_token(&self) -> Option<SyntaxToken> {
351        self.first_child_or_token()?.first_token()
352    }
353
354    /// Return the rightmost token in the subtree of this node
355    #[inline]
356    pub fn last_token(&self) -> Option<SyntaxToken> {
357        self.last_child_or_token()?.last_token()
358    }
359
360    pub fn siblings(&self, direction: Direction) -> impl Iterator<Item = SyntaxNode> {
361        iter::successors(Some(self.clone()), move |node| match direction {
362            Direction::Next => node.next_sibling(),
363            Direction::Prev => node.prev_sibling(),
364        })
365    }
366
367    pub fn siblings_with_tokens(
368        &self,
369        direction: Direction,
370    ) -> impl Iterator<Item = SyntaxElement> {
371        let me: SyntaxElement = self.clone().into();
372        iter::successors(Some(me), move |el| match direction {
373            Direction::Next => el.next_sibling_or_token(),
374            Direction::Prev => el.prev_sibling_or_token(),
375        })
376    }
377
378    pub fn descendants(&self) -> impl Iterator<Item = SyntaxNode> {
379        self.preorder().filter_map(|event| match event {
380            WalkEvent::Enter(node) => Some(node),
381            WalkEvent::Leave(_) => None,
382        })
383    }
384
385    pub fn descendants_with_tokens(&self) -> impl Iterator<Item = SyntaxElement> {
386        self.preorder_with_tokens().filter_map(|event| match event {
387            WalkEvent::Enter(it) => Some(it),
388            WalkEvent::Leave(_) => None,
389        })
390    }
391
392    /// Traverse the subtree rooted at the current node (including the current
393    /// node) in preorder, excluding tokens.
394    #[inline]
395    pub fn preorder(&self) -> impl Iterator<Item = WalkEvent<SyntaxNode>> {
396        let this = self.clone();
397        iter::successors(Some(WalkEvent::Enter(self.clone())), move |pos| {
398            let next = match pos {
399                WalkEvent::Enter(node) => match node.first_child() {
400                    Some(child) => WalkEvent::Enter(child),
401                    None => WalkEvent::Leave(node.clone()),
402                },
403                WalkEvent::Leave(node) => {
404                    if node == &this {
405                        return None;
406                    }
407                    match node.next_sibling() {
408                        Some(sibling) => WalkEvent::Enter(sibling),
409                        None => WalkEvent::Leave(node.parent().unwrap()),
410                    }
411                }
412            };
413            Some(next)
414        })
415    }
416
417    /// Traverse the subtree rooted at the current node (including the current
418    /// node) in preorder, including tokens.
419    #[inline]
420    pub fn preorder_with_tokens<'a>(&'a self) -> impl Iterator<Item = WalkEvent<SyntaxElement>> {
421        let start: SyntaxElement = self.clone().into();
422        iter::successors(Some(WalkEvent::Enter(start.clone())), move |pos| {
423            let next = match pos {
424                WalkEvent::Enter(el) => match el {
425                    NodeOrToken::Node(node) => match node.first_child_or_token() {
426                        Some(child) => WalkEvent::Enter(child),
427                        None => WalkEvent::Leave(node.clone().into()),
428                    },
429                    NodeOrToken::Token(token) => WalkEvent::Leave(token.clone().into()),
430                },
431                WalkEvent::Leave(el) => {
432                    if el == &start {
433                        return None;
434                    }
435                    match el.next_sibling_or_token() {
436                        Some(sibling) => WalkEvent::Enter(sibling),
437                        None => WalkEvent::Leave(el.parent().unwrap().into()),
438                    }
439                }
440            };
441            Some(next)
442        })
443    }
444
445    /// Find a token in the subtree corresponding to this node, which covers the offset.
446    /// Precondition: offset must be withing node's range.
447    pub fn token_at_offset(&self, offset: TextSize) -> TokenAtOffset<SyntaxToken> {
448        // TODO: this could be faster if we first drill-down to node, and only
449        // then switch to token seaArch. We should also replace explicit
450        // recursion with a loop.
451        let range = self.text_range();
452        assert!(
453            range.start() <= offset && offset <= range.end(),
454            "Bad offset: range {:?} offset {:?}",
455            range,
456            offset
457        );
458        if range.is_empty() {
459            return TokenAtOffset::None;
460        }
461
462        let mut children = self.children_with_tokens().filter(|child| {
463            let child_range = child.text_range();
464            !child_range.is_empty()
465                && (child_range.start() <= offset && offset <= child_range.end())
466        });
467
468        let left = children.next().unwrap();
469        let right = children.next();
470        assert!(children.next().is_none());
471
472        if let Some(right) = right {
473            match (left.token_at_offset(offset), right.token_at_offset(offset)) {
474                (TokenAtOffset::Single(left), TokenAtOffset::Single(right)) => {
475                    TokenAtOffset::Between(left, right)
476                }
477                _ => unreachable!(),
478            }
479        } else {
480            left.token_at_offset(offset)
481        }
482    }
483
484    /// Return the deepest node or token in the current subtree that fully
485    /// contains the range. If the range is empty and is contained in two leaf
486    /// nodes, either one can be returned. Precondition: range must be contained
487    /// withing the current node
488    pub fn covering_element(&self, range: TextRange) -> SyntaxElement {
489        let mut res: SyntaxElement = self.clone().into();
490        loop {
491            assert!(
492                res.text_range().contains_range(range),
493                "Bad range: node range {:?}, range {:?}",
494                res.text_range(),
495                range,
496            );
497            res = match &res {
498                NodeOrToken::Token(_) => return res,
499                NodeOrToken::Node(node) => {
500                    match node
501                        .children_with_tokens()
502                        .find(|child| child.text_range().contains_range(range))
503                    {
504                        Some(child) => child,
505                        None => return res,
506                    }
507                }
508            };
509        }
510    }
511}
512
513impl SyntaxToken {
514    fn new(parent: SyntaxNode, index: u32, offset: TextSize) -> SyntaxToken {
515        SyntaxToken { parent, index, offset }
516    }
517
518    /// Returns a green tree, equal to the green tree this token
519    /// belongs two, except with this token substitute. The complexity
520    /// of operation is proportional to the depth of the tree
521    pub fn replace_with(&self, replacement: GreenToken) -> GreenNode {
522        assert_eq!(self.kind(), replacement.kind());
523        let mut replacement = Some(replacement);
524        let parent = self.parent();
525        let me = self.index;
526
527        let children = parent.green().children().enumerate().map(|(i, child)| {
528            if i as u32 == me {
529                replacement.take().unwrap().into()
530            } else {
531                child.cloned()
532            }
533        });
534        let new_parent = GreenNode::new(parent.kind(), children);
535        parent.replace_with(new_parent)
536    }
537
538    pub fn kind(&self) -> SyntaxKind {
539        self.green().kind()
540    }
541
542    pub fn text_range(&self) -> TextRange {
543        TextRange::at(self.offset, self.green().text_len())
544    }
545
546    pub fn text(&self) -> &SmolStr {
547        self.green().text()
548    }
549
550    pub fn green(&self) -> &GreenToken {
551        self.parent.green().children().nth(self.index as usize).unwrap().as_token().unwrap()
552    }
553
554    pub fn parent(&self) -> SyntaxNode {
555        self.parent.clone()
556    }
557
558    pub fn ancestors(&self) -> impl Iterator<Item = SyntaxNode> {
559        self.parent().ancestors()
560    }
561
562    pub fn next_sibling_or_token(&self) -> Option<SyntaxElement> {
563        let (element, (index, offset)) = self
564            .parent
565            .green()
566            .children_from((self.index + 1) as usize, self.text_range().end())
567            .next()?;
568
569        Some(SyntaxElement::new(element, self.parent(), index as u32, offset))
570    }
571
572    pub fn prev_sibling_or_token(&self) -> Option<SyntaxElement> {
573        let parent = self.parent();
574        let (element, (index, offset)) = self
575            .parent
576            .green()
577            .children_to(self.index as usize, self.text_range().start())
578            .next()?;
579
580        Some(SyntaxElement::new(element, parent, index as u32, offset))
581    }
582
583    pub fn siblings_with_tokens(
584        &self,
585        direction: Direction,
586    ) -> impl Iterator<Item = SyntaxElement> {
587        let me: SyntaxElement = self.clone().into();
588        iter::successors(Some(me), move |el| match direction {
589            Direction::Next => el.next_sibling_or_token(),
590            Direction::Prev => el.prev_sibling_or_token(),
591        })
592    }
593
594    /// Next token in the tree (i.e, not necessary a sibling)
595    pub fn next_token(&self) -> Option<SyntaxToken> {
596        match self.next_sibling_or_token() {
597            Some(element) => element.first_token(),
598            None => self
599                .parent()
600                .ancestors()
601                .find_map(|it| it.next_sibling_or_token())
602                .and_then(|element| element.first_token()),
603        }
604    }
605    /// Previous token in the tree (i.e, not necessary a sibling)
606    pub fn prev_token(&self) -> Option<SyntaxToken> {
607        match self.prev_sibling_or_token() {
608            Some(element) => element.last_token(),
609            None => self
610                .parent()
611                .ancestors()
612                .find_map(|it| it.prev_sibling_or_token())
613                .and_then(|element| element.last_token()),
614        }
615    }
616}
617
618impl SyntaxElement {
619    fn new(
620        element: GreenElementRef<'_>,
621        parent: SyntaxNode,
622        index: u32,
623        offset: TextSize,
624    ) -> SyntaxElement {
625        match element {
626            NodeOrToken::Node(node) => {
627                SyntaxNode::new_child(node, parent, index as u32, offset).into()
628            }
629            NodeOrToken::Token(_) => SyntaxToken::new(parent, index as u32, offset).into(),
630        }
631    }
632
633    pub fn text_range(&self) -> TextRange {
634        match self {
635            NodeOrToken::Node(it) => it.text_range(),
636            NodeOrToken::Token(it) => it.text_range(),
637        }
638    }
639
640    pub fn kind(&self) -> SyntaxKind {
641        match self {
642            NodeOrToken::Node(it) => it.kind(),
643            NodeOrToken::Token(it) => it.kind(),
644        }
645    }
646
647    pub fn parent(&self) -> Option<SyntaxNode> {
648        match self {
649            NodeOrToken::Node(it) => it.parent(),
650            NodeOrToken::Token(it) => Some(it.parent()),
651        }
652    }
653
654    pub fn ancestors(&self) -> impl Iterator<Item = SyntaxNode> {
655        match self {
656            NodeOrToken::Node(it) => it.ancestors(),
657            NodeOrToken::Token(it) => it.parent().ancestors(),
658        }
659    }
660
661    #[inline]
662    pub fn first_token(&self) -> Option<SyntaxToken> {
663        match self {
664            NodeOrToken::Node(it) => it.first_token(),
665            NodeOrToken::Token(it) => Some(it.clone()),
666        }
667    }
668
669    #[inline]
670    pub fn last_token(&self) -> Option<SyntaxToken> {
671        match self {
672            NodeOrToken::Node(it) => it.last_token(),
673            NodeOrToken::Token(it) => Some(it.clone()),
674        }
675    }
676
677    pub fn next_sibling_or_token(&self) -> Option<SyntaxElement> {
678        match self {
679            NodeOrToken::Node(it) => it.next_sibling_or_token(),
680            NodeOrToken::Token(it) => it.next_sibling_or_token(),
681        }
682    }
683
684    pub fn prev_sibling_or_token(&self) -> Option<SyntaxElement> {
685        match self {
686            NodeOrToken::Node(it) => it.prev_sibling_or_token(),
687            NodeOrToken::Token(it) => it.prev_sibling_or_token(),
688        }
689    }
690
691    fn token_at_offset(&self, offset: TextSize) -> TokenAtOffset<SyntaxToken> {
692        assert!(self.text_range().start() <= offset && offset <= self.text_range().end());
693        match self {
694            NodeOrToken::Token(token) => TokenAtOffset::Single(token.clone()),
695            NodeOrToken::Node(node) => node.token_at_offset(offset),
696        }
697    }
698}
699
700#[derive(Clone, Debug)]
701struct Iter {
702    parent: SyntaxNode,
703    green: Children<'static>,
704    offset: TextSize,
705    index: u32,
706}
707
708impl Iter {
709    fn new(parent: SyntaxNode) -> Iter {
710        let offset = parent.text_range().start();
711        let green: Children<'_> = parent.green().children();
712        // Dirty lifetime laundering: the memory for the children is
713        // indirectly owned by parent.
714        let green: Children<'static> =
715            unsafe { mem::transmute::<Children<'_>, Children<'static>>(green) };
716        Iter { parent, green, offset, index: 0 }
717    }
718
719    fn next(&mut self) -> Option<(GreenElementRef, u32, TextSize)> {
720        self.green.next().map(|element| {
721            let offset = self.offset;
722            let index = self.index;
723            self.offset += element.text_len();
724            self.index += 1;
725            (element, index, offset)
726        })
727    }
728}
729
730#[derive(Clone, Debug)]
731pub struct SyntaxNodeChildren(Iter);
732
733impl SyntaxNodeChildren {
734    fn new(parent: SyntaxNode) -> SyntaxNodeChildren {
735        SyntaxNodeChildren(Iter::new(parent))
736    }
737}
738
739impl Iterator for SyntaxNodeChildren {
740    type Item = SyntaxNode;
741    fn next(&mut self) -> Option<Self::Item> {
742        let parent = self.0.parent.clone();
743        while let Some((element, index, offset)) = self.0.next() {
744            if let Some(node) = element.as_node() {
745                return Some(SyntaxNode::new_child(node, parent, index, offset));
746            }
747        }
748        None
749    }
750}
751
752#[derive(Clone, Debug)]
753pub struct SyntaxElementChildren(Iter);
754
755impl SyntaxElementChildren {
756    fn new(parent: SyntaxNode) -> SyntaxElementChildren {
757        SyntaxElementChildren(Iter::new(parent))
758    }
759}
760
761impl Iterator for SyntaxElementChildren {
762    type Item = SyntaxElement;
763    fn next(&mut self) -> Option<Self::Item> {
764        let parent = self.0.parent.clone();
765        self.0.next().map(|(green, index, offset)| SyntaxElement::new(green, parent, index, offset))
766    }
767}
768
769impl GreenNode {
770    fn children_from(
771        &self,
772        start_index: usize,
773        mut offset: TextSize,
774    ) -> impl Iterator<Item = (GreenElementRef, (usize, TextSize))> {
775        self.children().skip(start_index).enumerate().map(move |(index, element)| {
776            let element_offset = offset;
777            offset += element.text_len();
778            (element, (start_index + index, element_offset))
779        })
780    }
781
782    fn children_to(
783        &self,
784        end_index: usize,
785        mut offset: TextSize,
786    ) -> impl Iterator<Item = (GreenElementRef, (usize, TextSize))> {
787        self.children().take(end_index).rev().enumerate().map(move |(index, element)| {
788            offset -= element.text_len();
789            (element, (end_index - index - 1, offset))
790        })
791    }
792}
793
794fn filter_nodes<'a, I: Iterator<Item = (GreenElementRef<'a>, T)>, T>(
795    iter: I,
796) -> impl Iterator<Item = (&'a GreenNode, T)> {
797    iter.filter_map(|(element, data)| match element {
798        NodeOrToken::Node(it) => Some((it, data)),
799        NodeOrToken::Token(_) => None,
800    })
801}
rslint_rowan/cursor.rs

rslint_rowan/
cursor.rs
