1 //! Parser recognizes special macro syntax, `$var` and `$(repeat)*`, in token
4 use smallvec::SmallVec;
7 use crate::{tt_iter::TtIter, ExpandError, MetaTemplate};
9 #[derive(Clone, Debug, PartialEq, Eq)]
11 Var { name: SmolStr, kind: Option<SmolStr> },
12 Repeat { subtree: MetaTemplate, kind: RepeatKind, separator: Option<Separator> },
14 Subtree(MetaTemplate),
17 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
18 pub(crate) enum RepeatKind {
24 #[derive(Clone, Debug, Eq)]
25 pub(crate) enum Separator {
28 Puncts(SmallVec<[tt::Punct; 3]>),
31 // Note that when we compare a Separator, we just care about its textual value.
32 impl PartialEq for Separator {
33 fn eq(&self, other: &Separator) -> bool {
37 (Ident(ref a), Ident(ref b)) => a.text == b.text,
38 (Literal(ref a), Literal(ref b)) => a.text == b.text,
39 (Puncts(ref a), Puncts(ref b)) if a.len() == b.len() => {
40 let a_iter = a.iter().map(|a| a.char);
41 let b_iter = b.iter().map(|b| b.char);
49 pub(crate) fn parse_template(template: &tt::Subtree) -> Vec<Result<Op, ExpandError>> {
50 parse_inner(&template, Mode::Template)
53 pub(crate) fn parse_pattern(pattern: &tt::Subtree) -> Vec<Result<Op, ExpandError>> {
54 parse_inner(&pattern, Mode::Pattern)
57 #[derive(Clone, Copy)]
63 fn parse_inner(tt: &tt::Subtree, mode: Mode) -> Vec<Result<Op, ExpandError>> {
64 let mut src = TtIter::new(&tt);
65 std::iter::from_fn(move || {
66 let first = src.next()?;
67 Some(next_op(first, &mut src, mode))
74 ExpandError::UnexpectedToken
80 return Err(err!($($tt)*))
84 fn next_op<'a>(first: &tt::TokenTree, src: &mut TtIter<'a>, mode: Mode) -> Result<Op, ExpandError> {
85 let res = match first {
86 tt::TokenTree::Leaf(leaf @ tt::Leaf::Punct(tt::Punct { char: '$', .. })) => {
87 // Note that the '$' itself is a valid token inside macro_rules.
88 let second = match src.next() {
89 None => return Ok(Op::Leaf(leaf.clone())),
93 tt::TokenTree::Subtree(subtree) => {
94 let (separator, kind) = parse_repeat(src)?;
95 let delimiter = subtree.delimiter;
96 let tokens = parse_inner(&subtree, mode);
97 let subtree = MetaTemplate { tokens, delimiter };
98 Op::Repeat { subtree, separator, kind }
100 tt::TokenTree::Leaf(leaf) => match leaf {
101 tt::Leaf::Punct(punct) => {
102 static UNDERSCORE: SmolStr = SmolStr::new_inline("_");
104 if punct.char != '_' {
105 return Err(ExpandError::UnexpectedToken);
107 let name = UNDERSCORE.clone();
108 let kind = eat_fragment_kind(src, mode)?;
109 Op::Var { name, kind }
111 tt::Leaf::Ident(ident) => {
112 let name = ident.text.clone();
113 let kind = eat_fragment_kind(src, mode)?;
114 Op::Var { name, kind }
116 tt::Leaf::Literal(lit) => {
117 if is_boolean_literal(&lit) {
118 let name = lit.text.clone();
119 let kind = eat_fragment_kind(src, mode)?;
120 Op::Var { name, kind }
128 tt::TokenTree::Leaf(tt) => Op::Leaf(tt.clone()),
129 tt::TokenTree::Subtree(subtree) => {
130 let delimiter = subtree.delimiter;
131 let tokens = parse_inner(&subtree, mode);
132 let subtree = MetaTemplate { tokens, delimiter };
139 fn eat_fragment_kind<'a>(src: &mut TtIter<'a>, mode: Mode) -> Result<Option<SmolStr>, ExpandError> {
140 if let Mode::Pattern = mode {
141 src.expect_char(':').map_err(|()| err!("bad fragment specifier 1"))?;
142 let ident = src.expect_ident().map_err(|()| err!("bad fragment specifier 1"))?;
143 return Ok(Some(ident.text.clone()));
148 fn is_boolean_literal(lit: &tt::Literal) -> bool {
149 matches!(lit.text.as_str(), "true" | "false")
152 fn parse_repeat(src: &mut TtIter) -> Result<(Option<Separator>, RepeatKind), ExpandError> {
153 let mut separator = Separator::Puncts(SmallVec::new());
156 tt::TokenTree::Leaf(leaf) => leaf,
157 tt::TokenTree::Subtree(_) => return Err(ExpandError::InvalidRepeat),
159 let has_sep = match &separator {
160 Separator::Puncts(puncts) => !puncts.is_empty(),
164 tt::Leaf::Ident(_) | tt::Leaf::Literal(_) if has_sep => {
165 return Err(ExpandError::InvalidRepeat)
167 tt::Leaf::Ident(ident) => separator = Separator::Ident(ident.clone()),
168 tt::Leaf::Literal(lit) => separator = Separator::Literal(lit.clone()),
169 tt::Leaf::Punct(punct) => {
170 let repeat_kind = match punct.char {
171 '*' => RepeatKind::ZeroOrMore,
172 '+' => RepeatKind::OneOrMore,
173 '?' => RepeatKind::ZeroOrOne,
175 match &mut separator {
176 Separator::Puncts(puncts) => {
177 if puncts.len() == 3 {
178 return Err(ExpandError::InvalidRepeat);
180 puncts.push(punct.clone())
182 _ => return Err(ExpandError::InvalidRepeat),
187 let separator = if has_sep { Some(separator) } else { None };
188 return Ok((separator, repeat_kind));
192 Err(ExpandError::InvalidRepeat)