Skip to main content

moxy_ast/parse/
cursor.rs

1use moxy_token::{Delim, Span, ToTokens, TokenStream, TokenTree};
2
3/// Copyable transactional position within a token parser.
4#[derive(Copy, Clone)]
5pub struct Cursor<'a> {
6    index: usize,
7    tokens: &'a TokenStream,
8}
9
10impl<'a> Cursor<'a> {
11    pub fn from_tokens(tokens: &'a TokenStream) -> Self {
12        Self { index: 0, tokens }
13    }
14
15    pub fn is_empty(self) -> bool {
16        self.index >= self.tokens.len()
17    }
18
19    pub fn span(self) -> Span {
20        self.tokens.get(self.index).map(TokenTree::span).unwrap_or_default()
21    }
22
23    pub fn remaining(self) -> usize {
24        self.tokens.len().saturating_sub(self.index)
25    }
26
27    pub fn curr(self) -> Option<&'a TokenTree> {
28        self.nth(0)
29    }
30
31    pub fn next(self) -> Option<&'a TokenTree> {
32        self.nth(1)
33    }
34
35    pub fn nth(self, n: usize) -> Option<&'a TokenTree> {
36        self.tokens.get(self.index.checked_add(n)?)
37    }
38
39    pub fn prev(self) -> Option<&'a TokenTree> {
40        self.tokens.get(self.index.checked_sub(1)?)
41    }
42
43    pub fn is_delimited(self, delim: Delim) -> bool {
44        match self.curr() {
45            Some(TokenTree::Group(v)) => v.delim == delim,
46            _ => false,
47        }
48    }
49
50    pub fn descend(self, delim: Delim) -> Option<Self> {
51        let (_, Some(TokenTree::Group(group))) = self.advance() else {
52            return None;
53        };
54
55        if group.delim != delim {
56            return None;
57        }
58
59        Some(Cursor::from_tokens(&group.tokens))
60    }
61
62    pub fn seek(mut self, i: usize) -> Self {
63        self.index = i;
64        self
65    }
66
67    pub fn offset(mut self, n: usize) -> Self {
68        self.index += n;
69        self
70    }
71
72    pub fn range(self, start: Self) -> &'a [TokenTree] {
73        &self.tokens[start.index..self.index]
74    }
75
76    pub fn advance(mut self) -> (Self, Option<&'a TokenTree>) {
77        let token = self.tokens.get(self.index);
78
79        if token.is_some() {
80            self.index += 1;
81        }
82
83        (self, token)
84    }
85
86    pub fn advance_by(mut self, n: usize) -> (Self, Option<&'a [TokenTree]>) {
87        let Some(end) = self.index.checked_add(n) else {
88            return (self, None);
89        };
90
91        let tokens = self.tokens.get(self.index..end);
92
93        if tokens.is_some() {
94            self.index = end;
95        }
96
97        (self, tokens)
98    }
99
100    pub fn skip_until<F: Fn(Option<&TokenTree>) -> bool>(mut self, pred: F) -> Self {
101        while !self.is_empty() && !pred(self.curr()) {
102            (self, _) = self.advance();
103        }
104
105        self
106    }
107}
108
109impl<'a> ToTokens for Cursor<'a> {
110    fn to_tokens(&self, tokens: &mut TokenStream) {
111        let slice = &self.tokens[self.index..];
112        tokens.extend(slice.to_vec());
113    }
114}