Rewrite group parser without macros

Author: dtolnay

src/fallback.rs

@@ -895,28 +895,27 @@ named!(token_kind -> TokenTree, alt!(
     symbol
 ));
 
-named!(group -> Group, alt!(
-    do_parse!(
-        punct!("(") >>
-        ts: token_stream >>
-        punct!(")") >>
-        (Group::new(Delimiter::Parenthesis, ts))
-    )
-    |
-    do_parse!(
-        punct!("[") >>
-        ts: token_stream >>
-        punct!("]") >>
-        (Group::new(Delimiter::Bracket, ts))
-    )
-    |
-    do_parse!(
-        punct!("{") >>
-        ts: token_stream >>
-        punct!("}") >>
-        (Group::new(Delimiter::Brace, ts))
-    )
-));
+fn group(input: Cursor) -> PResult<Group> {
+    let input = skip_whitespace(input);
+    if let Ok(input) = input.expect("(") {
+        let (input, ts) = token_stream(input)?;
+        let input = skip_whitespace(input);
+        let input = input.expect(")")?;
+        Ok((input, Group::new(Delimiter::Parenthesis, ts)))
+    } else if let Ok(input) = input.expect("[") {
+        let (input, ts) = token_stream(input)?;
+        let input = skip_whitespace(input);
+        let input = input.expect("]")?;
+        Ok((input, Group::new(Delimiter::Bracket, ts)))
+    } else if let Ok(input) = input.expect("{") {
+        let (input, ts) = token_stream(input)?;
+        let input = skip_whitespace(input);
+        let input = input.expect("}")?;
+        Ok((input, Group::new(Delimiter::Brace, ts)))
+    } else {
+        Err(LexError)
+    }
+}
 
 fn symbol(input: Cursor) -> PResult<TokenTree> {
     let raw = input.starts_with("r#");

src/strnom.rs

@@ -214,59 +214,12 @@ macro_rules! alt {
     };
 }
 
-macro_rules! do_parse {
-    ($i:expr, ( $($rest:expr),* )) => {
-        Ok(($i, ( $($rest),* )))
-    };
-
-    ($i:expr, $e:ident >> $($rest:tt)*) => {
-        do_parse!($i, call!($e) >> $($rest)*)
-    };
-
-    ($i:expr, $submac:ident!( $($args:tt)* ) >> $($rest:tt)*) => {
-        match $submac!($i, $($args)*) {
-            Err(LexError) => Err(LexError),
-            Ok((i, _)) => do_parse!(i, $($rest)*),
-        }
-    };
-
-    ($i:expr, $field:ident : $e:ident >> $($rest:tt)*) => {
-        do_parse!($i, $field: call!($e) >> $($rest)*)
-    };
-
-    ($i:expr, $field:ident : $submac:ident!( $($args:tt)* ) >> $($rest:tt)*) => {
-        match $submac!($i, $($args)*) {
-            Err(LexError) => Err(LexError),
-            Ok((i, o)) => {
-                let $field = o;
-                do_parse!(i, $($rest)*)
-            },
-        }
-    };
-}
-
 macro_rules! call {
     ($i:expr, $fun:expr $(, $args:expr)*) => {
         $fun($i $(, $args)*)
     };
 }
 
-macro_rules! punct {
-    ($i:expr, $punct:expr) => {
-        $crate::strnom::punct($i, $punct)
-    };
-}
-
-/// Do not use directly. Use `punct!`.
-pub(crate) fn punct<'a>(input: Cursor<'a>, token: &'static str) -> PResult<'a, ()> {
-    let input = skip_whitespace(input);
-    if input.starts_with(token) {
-        Ok((input.advance(token.len()), ()))
-    } else {
-        Err(LexError)
-    }
-}
-
 macro_rules! map {
     ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => {
         match $submac!($i, $($args)*) {