Merge #11179

11179: minor: simplify mbe matcher r=matklad a=matklad

bors r+
🤖

Co-authored-by: Aleksey Kladov <[email protected]>

Author: bors[bot]

crates/mbe/src/expander/matcher.rs

@@ -697,6 +697,7 @@ fn match_meta_var(kind: &str, input: &mut TtIter) -> ExpandResult<Option<Fragmen
         "block" => parser::PrefixEntryPoint::Block,
         "meta" => parser::PrefixEntryPoint::MetaItem,
         "item" => parser::PrefixEntryPoint::Item,
+        "vis" => parser::PrefixEntryPoint::Vis,
         "expr" => {
             return input
                 .expect_fragment(parser::PrefixEntryPoint::Expr)
@@ -706,33 +707,29 @@ fn match_meta_var(kind: &str, input: &mut TtIter) -> ExpandResult<Option<Fragmen
             let tt_result = match kind {
                 "ident" => input
                     .expect_ident()
-                    .map(|ident| Some(tt::Leaf::from(ident.clone()).into()))
+                    .map(|ident| tt::Leaf::from(ident.clone()).into())
                     .map_err(|()| err!("expected ident")),
-                "tt" => input.expect_tt().map(Some).map_err(|()| err!()),
-                "lifetime" => {
-                    input.expect_lifetime().map(Some).map_err(|()| err!("expected lifetime"))
-                }
+                "tt" => input.expect_tt().map_err(|()| err!()),
+                "lifetime" => input.expect_lifetime().map_err(|()| err!("expected lifetime")),
                 "literal" => {
                     let neg = input.eat_char('-');
                     input
                         .expect_literal()
                         .map(|literal| {
                             let lit = literal.clone();
                             match neg {
-                                None => Some(lit.into()),
-                                Some(neg) => Some(tt::TokenTree::Subtree(tt::Subtree {
+                                None => lit.into(),
+                                Some(neg) => tt::TokenTree::Subtree(tt::Subtree {
                                     delimiter: None,
                                     token_trees: vec![neg, lit.into()],
-                                })),
+                                }),
                             }
                         })
                         .map_err(|()| err!())
                 }
-                // `vis` is optional
-                "vis" => Ok(input.expect_fragment(parser::PrefixEntryPoint::Vis).value),
                 _ => Err(ExpandError::UnexpectedToken),
             };
-            return tt_result.map(|it| it.map(Fragment::Tokens)).into();
+            return tt_result.map(|it| Some(Fragment::Tokens(it))).into();
         }
     };
     input.expect_fragment(fragment).map(|it| it.map(Fragment::Tokens))

crates/mbe/src/tt_iter.rs

@@ -114,7 +114,7 @@ impl<'a> TtIter<'a> {
             }
         }
 
-        let mut err = if !cursor.is_root() || error {
+        let err = if error || !cursor.is_root() {
             Some(err!("expected {:?}", entry_point))
         } else {
             None
@@ -132,9 +132,6 @@ impl<'a> TtIter<'a> {
             }
         }
         self.inner = self.inner.as_slice()[res.len()..].iter();
-        if res.is_empty() && err.is_none() {
-            err = Some(err!("no tokens consumed"));
-        }
         let res = match res.len() {
             1 => Some(res[0].cloned()),
             0 => None,