crates/mbe/src/parser.rs

   1 //! Parser recognizes special macro syntax, `$var` and `$(repeat)*`, in token
   2 //! trees.
   3
   4 use smallvec::SmallVec;
   5 use syntax::SmolStr;
   6
   7 use crate::{tt_iter::TtIter, ExpandError, MetaTemplate};
   8
   9 #[derive(Clone, Debug, PartialEq, Eq)]
  10 pub(crate) enum Op {
  11     Var { name: SmolStr, kind: Option<SmolStr>, id: tt::TokenId },
  12     Repeat { subtree: MetaTemplate, kind: RepeatKind, separator: Option<Separator> },
  13     Leaf(tt::Leaf),
  14     Subtree(MetaTemplate),
  15 }
  16
  17 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
  18 pub(crate) enum RepeatKind {
  19     ZeroOrMore,
  20     OneOrMore,
  21     ZeroOrOne,
  22 }
  23
  24 #[derive(Clone, Debug, Eq)]
  25 pub(crate) enum Separator {
  26     Literal(tt::Literal),
  27     Ident(tt::Ident),
  28     Puncts(SmallVec<[tt::Punct; 3]>),
  29 }
  30
  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 {
  34         use Separator::*;
  35
  36         match (self, other) {
  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);
  42                 a_iter.eq(b_iter)
  43             }
  44             _ => false,
  45         }
  46     }
  47 }
  48
  49 pub(crate) fn parse_template(template: &tt::Subtree) -> Vec<Result<Op, ExpandError>> {
  50     parse_inner(&template, Mode::Template)
  51 }
  52
  53 pub(crate) fn parse_pattern(pattern: &tt::Subtree) -> Vec<Result<Op, ExpandError>> {
  54     parse_inner(&pattern, Mode::Pattern)
  55 }
  56
  57 #[derive(Clone, Copy)]
  58 enum Mode {
  59     Pattern,
  60     Template,
  61 }
  62
  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))
  68     })
  69     .collect()
  70 }
  71
  72 macro_rules! err {
  73     ($($tt:tt)*) => {
  74         ExpandError::UnexpectedToken
  75     };
  76 }
  77
  78 macro_rules! bail {
  79     ($($tt:tt)*) => {
  80         return Err(err!($($tt)*))
  81     };
  82 }
  83
  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())),
  90                 Some(it) => it,
  91             };
  92             match second {
  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 }
  99                 }
 100                 tt::TokenTree::Leaf(leaf) => match leaf {
 101                     tt::Leaf::Punct(punct) => {
 102                         static UNDERSCORE: SmolStr = SmolStr::new_inline("_");
 103
 104                         if punct.char != '_' {
 105                             return Err(ExpandError::UnexpectedToken);
 106                         }
 107                         let name = UNDERSCORE.clone();
 108                         let kind = eat_fragment_kind(src, mode)?;
 109                         let id = punct.id;
 110                         Op::Var { name, kind, id }
 111                     }
 112                     tt::Leaf::Ident(ident) => {
 113                         let name = ident.text.clone();
 114                         let kind = eat_fragment_kind(src, mode)?;
 115                         let id = ident.id;
 116                         Op::Var { name, kind, id }
 117                     }
 118                     tt::Leaf::Literal(lit) => {
 119                         if is_boolean_literal(&lit) {
 120                             let name = lit.text.clone();
 121                             let kind = eat_fragment_kind(src, mode)?;
 122                             let id = lit.id;
 123                             Op::Var { name, kind, id }
 124                         } else {
 125                             bail!("bad var 2");
 126                         }
 127                     }
 128                 },
 129             }
 130         }
 131         tt::TokenTree::Leaf(tt) => Op::Leaf(tt.clone()),
 132         tt::TokenTree::Subtree(subtree) => {
 133             let delimiter = subtree.delimiter;
 134             let tokens = parse_inner(&subtree, mode);
 135             let subtree = MetaTemplate { tokens, delimiter };
 136             Op::Subtree(subtree)
 137         }
 138     };
 139     Ok(res)
 140 }
 141
 142 fn eat_fragment_kind<'a>(src: &mut TtIter<'a>, mode: Mode) -> Result<Option<SmolStr>, ExpandError> {
 143     if let Mode::Pattern = mode {
 144         src.expect_char(':').map_err(|()| err!("bad fragment specifier 1"))?;
 145         let ident = src.expect_ident().map_err(|()| err!("bad fragment specifier 1"))?;
 146         return Ok(Some(ident.text.clone()));
 147     };
 148     Ok(None)
 149 }
 150
 151 fn is_boolean_literal(lit: &tt::Literal) -> bool {
 152     matches!(lit.text.as_str(), "true" | "false")
 153 }
 154
 155 fn parse_repeat(src: &mut TtIter) -> Result<(Option<Separator>, RepeatKind), ExpandError> {
 156     let mut separator = Separator::Puncts(SmallVec::new());
 157     for tt in src {
 158         let tt = match tt {
 159             tt::TokenTree::Leaf(leaf) => leaf,
 160             tt::TokenTree::Subtree(_) => return Err(ExpandError::InvalidRepeat),
 161         };
 162         let has_sep = match &separator {
 163             Separator::Puncts(puncts) => !puncts.is_empty(),
 164             _ => true,
 165         };
 166         match tt {
 167             tt::Leaf::Ident(_) | tt::Leaf::Literal(_) if has_sep => {
 168                 return Err(ExpandError::InvalidRepeat)
 169             }
 170             tt::Leaf::Ident(ident) => separator = Separator::Ident(ident.clone()),
 171             tt::Leaf::Literal(lit) => separator = Separator::Literal(lit.clone()),
 172             tt::Leaf::Punct(punct) => {
 173                 let repeat_kind = match punct.char {
 174                     '*' => RepeatKind::ZeroOrMore,
 175                     '+' => RepeatKind::OneOrMore,
 176                     '?' => RepeatKind::ZeroOrOne,
 177                     _ => {
 178                         match &mut separator {
 179                             Separator::Puncts(puncts) => {
 180                                 if puncts.len() == 3 {
 181                                     return Err(ExpandError::InvalidRepeat);
 182                                 }
 183                                 puncts.push(punct.clone())
 184                             }
 185                             _ => return Err(ExpandError::InvalidRepeat),
 186                         }
 187                         continue;
 188                     }
 189                 };
 190                 let separator = if has_sep { Some(separator) } else { None };
 191                 return Ok((separator, repeat_kind));
 192             }
 193         }
 194     }
 195     Err(ExpandError::InvalidRepeat)
 196 }