1 //! Parser recognizes special macro syntax, `$var` and `$(repeat)*`, in token
4 use smallvec::SmallVec;
8 use crate::{tt_iter::TtIter, MetaTemplate, ParseError};
10 #[derive(Clone, Debug, PartialEq, Eq)]
12 Var { name: SmolStr, kind: Option<SmolStr>, id: tt::TokenId },
13 Repeat { tokens: MetaTemplate, kind: RepeatKind, separator: Option<Separator> },
15 Subtree { tokens: MetaTemplate, delimiter: Option<Delimiter> },
18 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
19 pub(crate) enum RepeatKind {
25 #[derive(Clone, Debug, Eq)]
26 pub(crate) enum Separator {
29 Puncts(SmallVec<[tt::Punct; 3]>),
32 // Note that when we compare a Separator, we just care about its textual value.
33 impl PartialEq for Separator {
34 fn eq(&self, other: &Separator) -> bool {
38 (Ident(ref a), Ident(ref b)) => a.text == b.text,
39 (Literal(ref a), Literal(ref b)) => a.text == b.text,
40 (Puncts(ref a), Puncts(ref b)) if a.len() == b.len() => {
41 let a_iter = a.iter().map(|a| a.char);
42 let b_iter = b.iter().map(|b| b.char);
50 pub(crate) fn parse_template(template: &tt::Subtree) -> Result<Vec<Op>, ParseError> {
51 parse_inner(&template, Mode::Template).into_iter().collect()
54 pub(crate) fn parse_pattern(pattern: &tt::Subtree) -> Result<Vec<Op>, ParseError> {
55 parse_inner(&pattern, Mode::Pattern).into_iter().collect()
58 #[derive(Clone, Copy)]
64 fn parse_inner(tt: &tt::Subtree, mode: Mode) -> Vec<Result<Op, ParseError>> {
65 let mut src = TtIter::new(&tt);
66 std::iter::from_fn(move || {
67 let first = src.next()?;
68 Some(next_op(first, &mut src, mode))
75 ParseError::UnexpectedToken(($($tt)*).to_string())
81 return Err(err!($($tt)*))
85 fn next_op<'a>(first: &tt::TokenTree, src: &mut TtIter<'a>, mode: Mode) -> Result<Op, ParseError> {
86 let res = match first {
87 tt::TokenTree::Leaf(leaf @ tt::Leaf::Punct(tt::Punct { char: '$', .. })) => {
88 // Note that the '$' itself is a valid token inside macro_rules.
89 let second = match src.next() {
90 None => return Ok(Op::Leaf(leaf.clone())),
94 tt::TokenTree::Subtree(subtree) => {
95 let (separator, kind) = parse_repeat(src)?;
96 let tokens = parse_inner(&subtree, mode)
98 .collect::<Result<Vec<Op>, ParseError>>()?;
99 Op::Repeat { tokens: MetaTemplate(tokens), separator, kind }
101 tt::TokenTree::Leaf(leaf) => match leaf {
102 tt::Leaf::Punct(punct) => {
103 static UNDERSCORE: SmolStr = SmolStr::new_inline("_");
105 if punct.char != '_' {
106 return Err(ParseError::Expected("_".to_string()));
108 let name = UNDERSCORE.clone();
109 let kind = eat_fragment_kind(src, mode)?;
111 Op::Var { name, kind, id }
113 tt::Leaf::Ident(ident) if ident.text == "crate" => {
114 // We simply produce identifier `$crate` here. And it will be resolved when lowering ast to Path.
115 Op::Leaf(tt::Leaf::from(tt::Ident { text: "$crate".into(), id: ident.id }))
117 tt::Leaf::Ident(ident) => {
118 let name = ident.text.clone();
119 let kind = eat_fragment_kind(src, mode)?;
121 Op::Var { name, kind, id }
123 tt::Leaf::Literal(lit) => {
124 if is_boolean_literal(&lit) {
125 let name = lit.text.clone();
126 let kind = eat_fragment_kind(src, mode)?;
128 Op::Var { name, kind, id }
136 tt::TokenTree::Leaf(tt) => Op::Leaf(tt.clone()),
137 tt::TokenTree::Subtree(subtree) => {
139 parse_inner(&subtree, mode).into_iter().collect::<Result<Vec<Op>, ParseError>>()?;
140 Op::Subtree { tokens: MetaTemplate(tokens), delimiter: subtree.delimiter }
146 fn eat_fragment_kind<'a>(src: &mut TtIter<'a>, mode: Mode) -> Result<Option<SmolStr>, ParseError> {
147 if let Mode::Pattern = mode {
148 src.expect_char(':').map_err(|()| err!("bad fragment specifier 1"))?;
149 let ident = src.expect_ident().map_err(|()| err!("bad fragment specifier 1"))?;
150 return Ok(Some(ident.text.clone()));
155 fn is_boolean_literal(lit: &tt::Literal) -> bool {
156 matches!(lit.text.as_str(), "true" | "false")
159 fn parse_repeat(src: &mut TtIter) -> Result<(Option<Separator>, RepeatKind), ParseError> {
160 let mut separator = Separator::Puncts(SmallVec::new());
163 tt::TokenTree::Leaf(leaf) => leaf,
164 tt::TokenTree::Subtree(_) => return Err(ParseError::InvalidRepeat),
166 let has_sep = match &separator {
167 Separator::Puncts(puncts) => !puncts.is_empty(),
171 tt::Leaf::Ident(_) | tt::Leaf::Literal(_) if has_sep => {
172 return Err(ParseError::InvalidRepeat)
174 tt::Leaf::Ident(ident) => separator = Separator::Ident(ident.clone()),
175 tt::Leaf::Literal(lit) => separator = Separator::Literal(lit.clone()),
176 tt::Leaf::Punct(punct) => {
177 let repeat_kind = match punct.char {
178 '*' => RepeatKind::ZeroOrMore,
179 '+' => RepeatKind::OneOrMore,
180 '?' => RepeatKind::ZeroOrOne,
182 match &mut separator {
183 Separator::Puncts(puncts) => {
184 if puncts.len() == 3 {
185 return Err(ParseError::InvalidRepeat);
187 puncts.push(punct.clone())
189 _ => return Err(ParseError::InvalidRepeat),
194 let separator = if has_sep { Some(separator) } else { None };
195 return Ok((separator, repeat_kind));
199 Err(ParseError::InvalidRepeat)