1 //! Parser recognizes special macro syntax, `$var` and `$(repeat)*`, in token
4 use smallvec::SmallVec;
7 use crate::{tt_iter::TtIter, ExpandError};
10 pub(crate) enum Op<'a> {
11 Var { name: &'a SmolStr, kind: Option<&'a SmolStr> },
12 Repeat { subtree: &'a tt::Subtree, kind: RepeatKind, separator: Option<Separator> },
13 TokenTree(&'a tt::TokenTree),
16 #[derive(Clone, Debug, PartialEq, Eq)]
17 pub(crate) enum RepeatKind {
23 #[derive(Clone, Debug, Eq)]
24 pub(crate) enum Separator {
27 Puncts(SmallVec<[tt::Punct; 3]>),
30 // Note that when we compare a Separator, we just care about its textual value.
31 impl PartialEq for Separator {
32 fn eq(&self, other: &Separator) -> bool {
36 (Ident(ref a), Ident(ref b)) => a.text == b.text,
37 (Literal(ref a), Literal(ref b)) => a.text == b.text,
38 (Puncts(ref a), Puncts(ref b)) if a.len() == b.len() => {
39 let a_iter = a.iter().map(|a| a.char);
40 let b_iter = b.iter().map(|b| b.char);
48 pub(crate) fn parse_template(
49 template: &tt::Subtree,
50 ) -> impl Iterator<Item = Result<Op<'_>, ExpandError>> {
51 parse_inner(template, Mode::Template)
54 pub(crate) fn parse_pattern(
55 pattern: &tt::Subtree,
56 ) -> impl Iterator<Item = Result<Op<'_>, ExpandError>> {
57 parse_inner(pattern, Mode::Pattern)
60 #[derive(Clone, Copy)]
66 fn parse_inner(src: &tt::Subtree, mode: Mode) -> impl Iterator<Item = Result<Op<'_>, ExpandError>> {
67 let mut src = TtIter::new(src);
68 std::iter::from_fn(move || {
69 let first = src.next()?;
70 Some(next_op(first, &mut src, mode))
76 ExpandError::UnexpectedToken
82 return Err(err!($($tt)*))
87 first: &'a tt::TokenTree,
90 ) -> Result<Op<'a>, ExpandError> {
91 let res = match first {
92 tt::TokenTree::Leaf(tt::Leaf::Punct(tt::Punct { char: '$', .. })) => {
93 // Note that the '$' itself is a valid token inside macro_rules.
94 let second = match src.next() {
95 None => return Ok(Op::TokenTree(first)),
99 tt::TokenTree::Subtree(subtree) => {
100 let (separator, kind) = parse_repeat(src)?;
101 Op::Repeat { subtree, separator, kind }
103 tt::TokenTree::Leaf(leaf) => match leaf {
104 tt::Leaf::Punct(_) => {
105 return Err(ExpandError::UnexpectedToken);
107 tt::Leaf::Ident(ident) => {
108 let name = &ident.text;
109 let kind = eat_fragment_kind(src, mode)?;
110 Op::Var { name, kind }
112 tt::Leaf::Literal(lit) => {
113 if is_boolean_literal(lit) {
114 let name = &lit.text;
115 let kind = eat_fragment_kind(src, mode)?;
116 Op::Var { name, kind }
124 tt => Op::TokenTree(tt),
129 fn eat_fragment_kind<'a>(
130 src: &mut TtIter<'a>,
132 ) -> Result<Option<&'a SmolStr>, ExpandError> {
133 if let Mode::Pattern = mode {
134 src.expect_char(':').map_err(|()| err!("bad fragment specifier 1"))?;
135 let ident = src.expect_ident().map_err(|()| err!("bad fragment specifier 1"))?;
136 return Ok(Some(&ident.text));
141 fn is_boolean_literal(lit: &tt::Literal) -> bool {
142 matches!(lit.text.as_str(), "true" | "false")
145 fn parse_repeat(src: &mut TtIter) -> Result<(Option<Separator>, RepeatKind), ExpandError> {
146 let mut separator = Separator::Puncts(SmallVec::new());
149 tt::TokenTree::Leaf(leaf) => leaf,
150 tt::TokenTree::Subtree(_) => return Err(ExpandError::InvalidRepeat),
152 let has_sep = match &separator {
153 Separator::Puncts(puncts) => !puncts.is_empty(),
157 tt::Leaf::Ident(_) | tt::Leaf::Literal(_) if has_sep => {
158 return Err(ExpandError::InvalidRepeat)
160 tt::Leaf::Ident(ident) => separator = Separator::Ident(ident.clone()),
161 tt::Leaf::Literal(lit) => separator = Separator::Literal(lit.clone()),
162 tt::Leaf::Punct(punct) => {
163 let repeat_kind = match punct.char {
164 '*' => RepeatKind::ZeroOrMore,
165 '+' => RepeatKind::OneOrMore,
166 '?' => RepeatKind::ZeroOrOne,
168 match &mut separator {
169 Separator::Puncts(puncts) => {
170 if puncts.len() == 3 {
171 return Err(ExpandError::InvalidRepeat);
173 puncts.push(punct.clone())
175 _ => return Err(ExpandError::InvalidRepeat),
180 let separator = if has_sep { Some(separator) } else { None };
181 return Ok((separator, repeat_kind));
185 Err(ExpandError::InvalidRepeat)