tt/
iter.rs

1//! A "Parser" structure for token trees. We use this when parsing a declarative
2//! macro definition into a list of patterns and templates.
3
4use std::fmt;
5
6use arrayvec::ArrayVec;
7use intern::sym;
8
9use crate::{Ident, Leaf, MAX_GLUED_PUNCT_LEN, Punct, Spacing, Subtree, TokenTree, TokenTreesView};
10
11#[derive(Clone)]
12pub struct TtIter<'a, S> {
13    inner: std::slice::Iter<'a, TokenTree<S>>,
14}
15
16impl<S: Copy + fmt::Debug> fmt::Debug for TtIter<'_, S> {
17    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
18        f.debug_struct("TtIter").field("remaining", &self.remaining()).finish()
19    }
20}
21
22#[derive(Clone, Copy)]
23pub struct TtIterSavepoint<'a, S>(&'a [TokenTree<S>]);
24
25impl<'a, S: Copy> TtIterSavepoint<'a, S> {
26    pub fn remaining(self) -> TokenTreesView<'a, S> {
27        TokenTreesView::new(self.0)
28    }
29}
30
31impl<'a, S: Copy> TtIter<'a, S> {
32    pub(crate) fn new(tt: &'a [TokenTree<S>]) -> TtIter<'a, S> {
33        TtIter { inner: tt.iter() }
34    }
35
36    pub fn expect_char(&mut self, char: char) -> Result<(), ()> {
37        match self.next() {
38            Some(TtElement::Leaf(&Leaf::Punct(Punct { char: c, .. }))) if c == char => Ok(()),
39            _ => Err(()),
40        }
41    }
42
43    pub fn expect_any_char(&mut self, chars: &[char]) -> Result<(), ()> {
44        match self.next() {
45            Some(TtElement::Leaf(Leaf::Punct(Punct { char: c, .. }))) if chars.contains(c) => {
46                Ok(())
47            }
48            _ => Err(()),
49        }
50    }
51
52    pub fn expect_subtree(&mut self) -> Result<(&'a Subtree<S>, TtIter<'a, S>), ()> {
53        match self.next() {
54            Some(TtElement::Subtree(subtree, iter)) => Ok((subtree, iter)),
55            _ => Err(()),
56        }
57    }
58
59    pub fn expect_leaf(&mut self) -> Result<&'a Leaf<S>, ()> {
60        match self.next() {
61            Some(TtElement::Leaf(it)) => Ok(it),
62            _ => Err(()),
63        }
64    }
65
66    pub fn expect_dollar(&mut self) -> Result<(), ()> {
67        match self.expect_leaf()? {
68            Leaf::Punct(Punct { char: '$', .. }) => Ok(()),
69            _ => Err(()),
70        }
71    }
72
73    pub fn expect_comma(&mut self) -> Result<(), ()> {
74        match self.expect_leaf()? {
75            Leaf::Punct(Punct { char: ',', .. }) => Ok(()),
76            _ => Err(()),
77        }
78    }
79
80    pub fn expect_ident(&mut self) -> Result<&'a Ident<S>, ()> {
81        match self.expect_leaf()? {
82            Leaf::Ident(it) if it.sym != sym::underscore => Ok(it),
83            _ => Err(()),
84        }
85    }
86
87    pub fn expect_ident_or_underscore(&mut self) -> Result<&'a Ident<S>, ()> {
88        match self.expect_leaf()? {
89            Leaf::Ident(it) => Ok(it),
90            _ => Err(()),
91        }
92    }
93
94    pub fn expect_literal(&mut self) -> Result<&'a Leaf<S>, ()> {
95        let it = self.expect_leaf()?;
96        match it {
97            Leaf::Literal(_) => Ok(it),
98            Leaf::Ident(ident) if ident.sym == sym::true_ || ident.sym == sym::false_ => Ok(it),
99            _ => Err(()),
100        }
101    }
102
103    pub fn expect_single_punct(&mut self) -> Result<&'a Punct<S>, ()> {
104        match self.expect_leaf()? {
105            Leaf::Punct(it) => Ok(it),
106            _ => Err(()),
107        }
108    }
109
110    /// Returns consecutive `Punct`s that can be glued together.
111    ///
112    /// This method currently may return a single quotation, which is part of lifetime ident and
113    /// conceptually not a punct in the context of mbe. Callers should handle this.
114    pub fn expect_glued_punct(&mut self) -> Result<ArrayVec<Punct<S>, MAX_GLUED_PUNCT_LEN>, ()> {
115        let TtElement::Leaf(&Leaf::Punct(first)) = self.next().ok_or(())? else {
116            return Err(());
117        };
118
119        let mut res = ArrayVec::new();
120        if first.spacing == Spacing::Alone {
121            res.push(first);
122            return Ok(res);
123        }
124
125        let (second, third) = match (self.peek_n(0), self.peek_n(1)) {
126            (Some(TokenTree::Leaf(Leaf::Punct(p2))), Some(TokenTree::Leaf(Leaf::Punct(p3))))
127                if p2.spacing == Spacing::Joint =>
128            {
129                (p2, Some(p3))
130            }
131            (Some(TokenTree::Leaf(Leaf::Punct(p2))), _) => (p2, None),
132            _ => {
133                res.push(first);
134                return Ok(res);
135            }
136        };
137
138        match (first.char, second.char, third.map(|it| it.char)) {
139            ('.', '.', Some('.' | '=')) | ('<', '<', Some('=')) | ('>', '>', Some('=')) => {
140                let _ = self.next().unwrap();
141                let _ = self.next().unwrap();
142                res.push(first);
143                res.push(*second);
144                res.push(*third.unwrap());
145            }
146            ('-' | '!' | '*' | '/' | '&' | '%' | '^' | '+' | '<' | '=' | '>' | '|', '=', _)
147            | ('-' | '=' | '>', '>', _)
148            | ('<', '-', _)
149            | (':', ':', _)
150            | ('.', '.', _)
151            | ('&', '&', _)
152            | ('<', '<', _)
153            | ('|', '|', _) => {
154                let _ = self.next().unwrap();
155                res.push(first);
156                res.push(*second);
157            }
158            _ => res.push(first),
159        }
160        Ok(res)
161    }
162
163    /// This method won't check for subtrees, so the nth token tree may not be the nth sibling of the current tree.
164    fn peek_n(&self, n: usize) -> Option<&'a TokenTree<S>> {
165        self.inner.as_slice().get(n)
166    }
167
168    pub fn peek(&self) -> Option<TtElement<'a, S>> {
169        match self.inner.as_slice().first()? {
170            TokenTree::Leaf(leaf) => Some(TtElement::Leaf(leaf)),
171            TokenTree::Subtree(subtree) => {
172                let nested_iter =
173                    TtIter { inner: self.inner.as_slice()[1..][..subtree.usize_len()].iter() };
174                Some(TtElement::Subtree(subtree, nested_iter))
175            }
176        }
177    }
178
179    /// Equivalent to `peek().is_none()`, but a bit faster.
180    pub fn is_empty(&self) -> bool {
181        self.inner.len() == 0
182    }
183
184    pub fn next_span(&self) -> Option<S> {
185        Some(self.inner.as_slice().first()?.first_span())
186    }
187
188    pub fn remaining(&self) -> TokenTreesView<'a, S> {
189        TokenTreesView::new(self.inner.as_slice())
190    }
191
192    /// **Warning**: This advances `skip` **flat** token trees, subtrees account for children+1!
193    pub fn flat_advance(&mut self, skip: usize) {
194        self.inner = self.inner.as_slice()[skip..].iter();
195    }
196
197    pub fn savepoint(&self) -> TtIterSavepoint<'a, S> {
198        TtIterSavepoint(self.inner.as_slice())
199    }
200
201    pub fn from_savepoint(&self, savepoint: TtIterSavepoint<'a, S>) -> TokenTreesView<'a, S> {
202        let len = (self.inner.as_slice().as_ptr() as usize - savepoint.0.as_ptr() as usize)
203            / size_of::<TokenTree<S>>();
204        TokenTreesView::new(&savepoint.0[..len])
205    }
206
207    pub fn next_as_view(&mut self) -> Option<TokenTreesView<'a, S>> {
208        let savepoint = self.savepoint();
209        self.next()?;
210        Some(self.from_savepoint(savepoint))
211    }
212}
213
214#[derive(Clone)]
215pub enum TtElement<'a, S> {
216    Leaf(&'a Leaf<S>),
217    Subtree(&'a Subtree<S>, TtIter<'a, S>),
218}
219
220impl<S: Copy + fmt::Debug> fmt::Debug for TtElement<'_, S> {
221    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
222        match self {
223            Self::Leaf(leaf) => f.debug_tuple("Leaf").field(leaf).finish(),
224            Self::Subtree(subtree, inner) => {
225                f.debug_tuple("Subtree").field(subtree).field(inner).finish()
226            }
227        }
228    }
229}
230
231impl<S: Copy> TtElement<'_, S> {
232    #[inline]
233    pub fn first_span(&self) -> S {
234        match self {
235            TtElement::Leaf(it) => *it.span(),
236            TtElement::Subtree(it, _) => it.delimiter.open,
237        }
238    }
239}
240
241impl<'a, S> Iterator for TtIter<'a, S> {
242    type Item = TtElement<'a, S>;
243    fn next(&mut self) -> Option<Self::Item> {
244        match self.inner.next()? {
245            TokenTree::Leaf(leaf) => Some(TtElement::Leaf(leaf)),
246            TokenTree::Subtree(subtree) => {
247                let nested_iter =
248                    TtIter { inner: self.inner.as_slice()[..subtree.usize_len()].iter() };
249                self.inner = self.inner.as_slice()[subtree.usize_len()..].iter();
250                Some(TtElement::Subtree(subtree, nested_iter))
251            }
252        }
253    }
254}
tt/iter.rs

tt/
iter.rs
