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};
   8
   9 #[derive(Debug)]
  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),
  14 }
  15
  16 #[derive(Clone, Debug, PartialEq, Eq)]
  17 pub(crate) enum RepeatKind {
  18     ZeroOrMore,
  19     OneOrMore,
  20     ZeroOrOne,
  21 }
  22
  23 #[derive(Clone, Debug, Eq)]
  24 pub(crate) enum Separator {
  25     Literal(tt::Literal),
  26     Ident(tt::Ident),
  27     Puncts(SmallVec<[tt::Punct; 3]>),
  28 }
  29
  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 {
  33         use Separator::*;
  34
  35         match (self, other) {
  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);
  41                 a_iter.eq(b_iter)
  42             }
  43             _ => false,
  44         }
  45     }
  46 }
  47
  48 pub(crate) fn parse_template(
  49     template: &tt::Subtree,
  50 ) -> impl Iterator<Item = Result<Op<'_>, ExpandError>> {
  51     parse_inner(template, Mode::Template)
  52 }
  53
  54 pub(crate) fn parse_pattern(
  55     pattern: &tt::Subtree,
  56 ) -> impl Iterator<Item = Result<Op<'_>, ExpandError>> {
  57     parse_inner(pattern, Mode::Pattern)
  58 }
  59
  60 #[derive(Clone, Copy)]
  61 enum Mode {
  62     Pattern,
  63     Template,
  64 }
  65
  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))
  71     })
  72 }
  73
  74 macro_rules! err {
  75     ($($tt:tt)*) => {
  76         ExpandError::UnexpectedToken
  77     };
  78 }
  79
  80 macro_rules! bail {
  81     ($($tt:tt)*) => {
  82         return Err(err!($($tt)*))
  83     };
  84 }
  85
  86 fn next_op<'a>(
  87     first: &'a tt::TokenTree,
  88     src: &mut TtIter<'a>,
  89     mode: Mode,
  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)),
  96                 Some(it) => it,
  97             };
  98             match second {
  99                 tt::TokenTree::Subtree(subtree) => {
 100                     let (separator, kind) = parse_repeat(src)?;
 101                     Op::Repeat { subtree, separator, kind }
 102                 }
 103                 tt::TokenTree::Leaf(leaf) => match leaf {
 104                     tt::Leaf::Punct(punct) => {
 105                         static UNDERSCORE: SmolStr = SmolStr::new_inline("_");
 106
 107                         if punct.char != '_' {
 108                             return Err(ExpandError::UnexpectedToken);
 109                         }
 110                         let name = &UNDERSCORE;
 111                         let kind = eat_fragment_kind(src, mode)?;
 112                         Op::Var { name, kind }
 113                     }
 114                     tt::Leaf::Ident(ident) => {
 115                         let name = &ident.text;
 116                         let kind = eat_fragment_kind(src, mode)?;
 117                         Op::Var { name, kind }
 118                     }
 119                     tt::Leaf::Literal(lit) => {
 120                         if is_boolean_literal(lit) {
 121                             let name = &lit.text;
 122                             let kind = eat_fragment_kind(src, mode)?;
 123                             Op::Var { name, kind }
 124                         } else {
 125                             bail!("bad var 2");
 126                         }
 127                     }
 128                 },
 129             }
 130         }
 131         tt => Op::TokenTree(tt),
 132     };
 133     Ok(res)
 134 }
 135
 136 fn eat_fragment_kind<'a>(
 137     src: &mut TtIter<'a>,
 138     mode: Mode,
 139 ) -> Result<Option<&'a 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));
 144     };
 145     Ok(None)
 146 }
 147
 148 fn is_boolean_literal(lit: &tt::Literal) -> bool {
 149     matches!(lit.text.as_str(), "true" | "false")
 150 }
 151
 152 fn parse_repeat(src: &mut TtIter) -> Result<(Option<Separator>, RepeatKind), ExpandError> {
 153     let mut separator = Separator::Puncts(SmallVec::new());
 154     for tt in src {
 155         let tt = match tt {
 156             tt::TokenTree::Leaf(leaf) => leaf,
 157             tt::TokenTree::Subtree(_) => return Err(ExpandError::InvalidRepeat),
 158         };
 159         let has_sep = match &separator {
 160             Separator::Puncts(puncts) => !puncts.is_empty(),
 161             _ => true,
 162         };
 163         match tt {
 164             tt::Leaf::Ident(_) | tt::Leaf::Literal(_) if has_sep => {
 165                 return Err(ExpandError::InvalidRepeat)
 166             }
 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,
 174                     _ => {
 175                         match &mut separator {
 176                             Separator::Puncts(puncts) => {
 177                                 if puncts.len() == 3 {
 178                                     return Err(ExpandError::InvalidRepeat);
 179                                 }
 180                                 puncts.push(punct.clone())
 181                             }
 182                             _ => return Err(ExpandError::InvalidRepeat),
 183                         }
 184                         continue;
 185                     }
 186                 };
 187                 let separator = if has_sep { Some(separator) } else { None };
 188                 return Ok((separator, repeat_kind));
 189             }
 190         }
 191     }
 192     Err(ExpandError::InvalidRepeat)
 193 }