diff --git a/peg-macros/ast.rs b/peg-macros/ast.rs index 24ff565..ad6d82f 100644 --- a/peg-macros/ast.rs +++ b/peg-macros/ast.rs @@ -24,12 +24,13 @@ impl Grammar { pub enum Item { Use(TokenStream), Rule(Rule), + StackLimit(TokenStream), } #[derive(Debug)] pub enum Cache { Simple, - Recursive + Recursive, } #[derive(Debug)] @@ -77,7 +78,11 @@ pub enum Expr { MethodExpr(Ident, TokenStream), ChoiceExpr(Vec), OptionalExpr(Box), - Repeat { inner: Box, bound: BoundedRepeat, sep: Option> }, + Repeat { + inner: Box, + bound: BoundedRepeat, + sep: Option>, + }, PosAssertExpr(Box), NegAssertExpr(Box), ActionExpr(Vec, Option), @@ -93,7 +98,10 @@ pub enum Expr { impl Expr { pub fn at(self, sp: Span) -> SpannedExpr { - SpannedExpr { expr: self, span:sp } + SpannedExpr { + expr: self, + span: sp, + } } } @@ -127,14 +135,14 @@ impl BoundedRepeat { pub fn has_lower_bound(&self) -> bool { match self { BoundedRepeat::None | BoundedRepeat::Both(None, _) => false, - BoundedRepeat::Plus | BoundedRepeat::Exact(_) | BoundedRepeat::Both(Some(_), _) => true + BoundedRepeat::Plus | BoundedRepeat::Exact(_) | BoundedRepeat::Both(Some(_), _) => true, } } pub fn has_upper_bound(&self) -> bool { match self { - BoundedRepeat::None | BoundedRepeat::Plus | BoundedRepeat::Both(_, None) => false, - BoundedRepeat::Exact(_) | BoundedRepeat::Both(_, Some(_)) => true + BoundedRepeat::None | BoundedRepeat::Plus | BoundedRepeat::Both(_, None) => false, + BoundedRepeat::Exact(_) | BoundedRepeat::Both(_, Some(_)) => true, } } } diff --git a/peg-macros/grammar.rs b/peg-macros/grammar.rs index d3020c8..aa95a01 100644 --- a/peg-macros/grammar.rs +++ b/peg-macros/grammar.rs @@ -71,68 +71,80 @@ pub mod peg { ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let __seq_res = __parse_rust_doc_comment(__input, __state, __err_state, __pos); - match __seq_res { - ::peg::RuleResult::Matched(__pos, doc) => { - let __seq_res = __parse_rust_visibility(__input, __state, __err_state, __pos); + let __rule_result: ::peg::RuleResult = { + { + let __seq_res = __parse_rust_doc_comment(__input, __state, __err_state, __pos); match __seq_res { - ::peg::RuleResult::Matched(__pos, visibility) => { - match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "grammar", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = - __parse_IDENT(__input, __state, __err_state, __pos); - match __seq_res { - ::peg::RuleResult::Matched(__pos, name) => { - let __seq_res = match __parse_rust_lifetime_params( - __input, - __state, - __err_state, - __pos, - ) { - ::peg::RuleResult::Matched(__newpos, __value) => { - ::peg::RuleResult::Matched( - __newpos, - Some(__value), - ) - } - ::peg::RuleResult::Failed => { - ::peg::RuleResult::Matched(__pos, None) - } - }; + ::peg::RuleResult::Matched(__pos, doc) => { + let __seq_res = + __parse_rust_visibility(__input, __state, __err_state, __pos); + match __seq_res { + ::peg::RuleResult::Matched(__pos, visibility) => { + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, "grammar", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + let __seq_res = + __parse_IDENT(__input, __state, __err_state, __pos); match __seq_res { - ::peg::RuleResult::Matched( - __pos, - lifetime_params, - ) => { - let __seq_res = __parse_grammar_args( - __input, - __state, - __err_state, - __pos, - ); - match __seq_res { :: peg :: RuleResult :: Matched (__pos , args) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "for") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = { let str_start = __pos ; match match __parse_rust_type (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } { :: peg :: RuleResult :: Matched (__newpos , _) => { :: peg :: RuleResult :: Matched (__newpos , :: peg :: ParseSlice :: parse_slice (__input , str_start , __newpos)) } , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , input_type) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "{") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! () ; loop { let __pos = __repeat_pos ; let __step_res = __parse_item (__input , __state , __err_state , __pos) ; match __step_res { :: peg :: RuleResult :: Matched (__newpos , __value) => { __repeat_pos = __newpos ; __repeat_value . push (__value) ; } , :: peg :: RuleResult :: Failed => { break ; } } } :: peg :: RuleResult :: Matched (__repeat_pos , __repeat_value) } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , items) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "}") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { Grammar { doc , visibility , name , lifetime_params , args , input_type , items } }) ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"}\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"{\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"for\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } + ::peg::RuleResult::Matched(__pos, name) => { + let __seq_res = + match __parse_rust_lifetime_params( + __input, + __state, + __err_state, + __pos, + ) { + ::peg::RuleResult::Matched( + __newpos, + __value, + ) => ::peg::RuleResult::Matched( + __newpos, + Some(__value), + ), + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Matched( + __pos, None, + ) + } + }; + match __seq_res { + ::peg::RuleResult::Matched( + __pos, + lifetime_params, + ) => { + let __seq_res = __parse_grammar_args( + __input, + __state, + __err_state, + __pos, + ); + match __seq_res { :: peg :: RuleResult :: Matched (__pos , args) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "for") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = { let str_start = __pos ; match match __parse_rust_type (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } { :: peg :: RuleResult :: Matched (__newpos , _) => { :: peg :: RuleResult :: Matched (__newpos , :: peg :: ParseSlice :: parse_slice (__input , str_start , __newpos)) } , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , input_type) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "{") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! () ; loop { let __pos = __repeat_pos ; let __step_res = __parse_item (__input , __state , __err_state , __pos) ; match __step_res { :: peg :: RuleResult :: Matched (__newpos , __value) => { __repeat_pos = __newpos ; __repeat_value . push (__value) ; } , :: peg :: RuleResult :: Failed => { break ; } } } :: peg :: RuleResult :: Matched (__repeat_pos , __repeat_value) } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , items) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "}") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { Grammar { doc , visibility , name , lifetime_params , args , input_type , items } }) ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"}\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"{\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"for\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed + } + } } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } } } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"grammar\""); + ::peg::RuleResult::Failed + } } } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"grammar\""); - ::peg::RuleResult::Failed - } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } + }; + __rule_result } } fn __parse_rust_lifetime_params<'input>( @@ -142,214 +154,83 @@ pub mod peg { __pos: usize, ) -> ::peg::RuleResult> { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "<") { - ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = { - let mut __repeat_pos = __pos; - let mut __repeat_value = vec![]; - loop { - let __pos = __repeat_pos; - let __pos = if __repeat_value.is_empty() { - __pos - } else { - let __sep_res = match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, ",", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, __val) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\",\""); - ::peg::RuleResult::Failed - } - }; - match __sep_res { - ::peg::RuleResult::Matched(__newpos, _) => __newpos, - ::peg::RuleResult::Failed => break, - } - }; - let __step_res = { - let str_start = __pos; - match match __parse_LIFETIME(__input, __state, __err_state, __pos) { - ::peg::RuleResult::Matched(pos, _) => { - ::peg::RuleResult::Matched(pos, ()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } { - ::peg::RuleResult::Matched(__newpos, _) => { - ::peg::RuleResult::Matched( - __newpos, - ::peg::ParseSlice::parse_slice( - __input, str_start, __newpos, - ), - ) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } - }; - match __step_res { - ::peg::RuleResult::Matched(__newpos, __value) => { - __repeat_pos = __newpos; - __repeat_value.push(__value); - } - ::peg::RuleResult::Failed => { - break; - } - } - } - if __repeat_value.len() >= 1 { - ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) - } else { - ::peg::RuleResult::Failed - } - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, p) => { - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, ">") { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, (|| p)()) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\">\""); - ::peg::RuleResult::Failed - } - } - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"<\""); - ::peg::RuleResult::Failed - } - } - } - fn __parse_grammar_args<'input>( - __input: &'input Input, - __state: &mut ParseState<'input>, - __err_state: &mut ::peg::error::ErrorState, - __pos: usize, - ) -> ::peg::RuleResult> { - #![allow(non_snake_case, unused, clippy::redundant_closure_call)] - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "(") { - ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = { - let mut __repeat_pos = __pos; - let mut __repeat_value = vec![]; - loop { - let __pos = __repeat_pos; - let __pos = if __repeat_value.is_empty() { - __pos - } else { - let __sep_res = match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, ",", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, __val) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\",\""); - ::peg::RuleResult::Failed - } - }; - match __sep_res { - ::peg::RuleResult::Matched(__newpos, _) => __newpos, - ::peg::RuleResult::Failed => break, - } - }; - let __step_res = { - let __seq_res = __parse_IDENT(__input, __state, __err_state, __pos); - match __seq_res { - ::peg::RuleResult::Matched(__pos, i) => { - match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, ":", + { + let __rule_result: ::peg::RuleResult> = { + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "<") { + ::peg::RuleResult::Matched(__pos, __val) => { + let __seq_res = { + let mut __repeat_pos = __pos; + let mut __repeat_value = vec![]; + loop { + let __pos = __repeat_pos; + let __pos = if __repeat_value.is_empty() { + __pos + } else { + let __sep_res = match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, ",", ) { ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = { - let str_start = __pos; - match match __parse_rust_type( - __input, - __state, - __err_state, - __pos, - ) { - ::peg::RuleResult::Matched(pos, _) => { - ::peg::RuleResult::Matched(pos, ()) - } - ::peg::RuleResult::Failed => { - ::peg::RuleResult::Failed - } - } { - ::peg::RuleResult::Matched(__newpos, _) => { - ::peg::RuleResult::Matched( - __newpos, - ::peg::ParseSlice::parse_slice( - __input, str_start, __newpos, - ), - ) - } - ::peg::RuleResult::Failed => { - ::peg::RuleResult::Failed - } - } - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, t) => { - ::peg::RuleResult::Matched(__pos, (|| (i, t))()) - } - ::peg::RuleResult::Failed => { - ::peg::RuleResult::Failed - } - } + ::peg::RuleResult::Matched(__pos, __val) } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\":\""); + __err_state.mark_failure(__pos, "\",\""); ::peg::RuleResult::Failed } + }; + match __sep_res { + ::peg::RuleResult::Matched(__newpos, _) => __newpos, + ::peg::RuleResult::Failed => break, + } + }; + let __step_res = { + let str_start = __pos; + match match __parse_LIFETIME( + __input, + __state, + __err_state, + __pos, + ) { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } { + ::peg::RuleResult::Matched(__newpos, _) => { + ::peg::RuleResult::Matched( + __newpos, + ::peg::ParseSlice::parse_slice( + __input, str_start, __newpos, + ), + ) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + }; + match __step_res { + ::peg::RuleResult::Matched(__newpos, __value) => { + __repeat_pos = __newpos; + __repeat_value.push(__value); + } + ::peg::RuleResult::Failed => { + break; } } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } - }; - match __step_res { - ::peg::RuleResult::Matched(__newpos, __value) => { - __repeat_pos = __newpos; - __repeat_value.push(__value); - } - ::peg::RuleResult::Failed => { - break; - } - } - } - ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, args) => { - let __seq_res = match match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, ",", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, __val) } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\",\""); + if __repeat_value.len() >= 1 { + ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) + } else { ::peg::RuleResult::Failed } - } { - ::peg::RuleResult::Matched(__newpos, _) => { - ::peg::RuleResult::Matched(__newpos, ()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, ()), }; match __seq_res { - ::peg::RuleResult::Matched(__pos, _) => { - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, ")") + ::peg::RuleResult::Matched(__pos, p) => { + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, ">") { ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, (|| args)()) + ::peg::RuleResult::Matched(__pos, (|| p)()) } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\")\""); + __err_state.mark_failure(__pos, "\">\""); ::peg::RuleResult::Failed } } @@ -357,179 +238,235 @@ pub mod peg { ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"<\""); + ::peg::RuleResult::Failed + } } - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"(\""); - ::peg::RuleResult::Failed - } + }; + __rule_result } } - fn __parse_peg_rule<'input>( + fn __parse_grammar_args<'input>( __input: &'input Input, __state: &mut ParseState<'input>, __err_state: &mut ::peg::error::ErrorState, __pos: usize, - ) -> ::peg::RuleResult { + ) -> ::peg::RuleResult> { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let __seq_res = __parse_rust_doc_comment(__input, __state, __err_state, __pos); - match __seq_res { - ::peg::RuleResult::Matched(__pos, doc) => { - let __seq_res = __parse_cacheflag(__input, __state, __err_state, __pos); - match __seq_res { - ::peg::RuleResult::Matched(__pos, cache) => { - let __seq_res = - __parse_no_eof_flag(__input, __state, __err_state, __pos); - match __seq_res { - ::peg::RuleResult::Matched(__pos, no_eof) => { - let __seq_res = __parse_rust_visibility( - __input, - __state, - __err_state, - __pos, - ); - match __seq_res { - ::peg::RuleResult::Matched(__pos, visibility) => { - let __seq_res = - __parse_sp(__input, __state, __err_state, __pos); - match __seq_res { - ::peg::RuleResult::Matched(__pos, span) => { - match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "rule", - ) { - ::peg::RuleResult::Matched( - __pos, - __val, - ) => { - let __seq_res = { - let __choice_res = { - let __seq_res = { - __err_state - .suppress_fail += 1; - let __assert_res = { - let __choice_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "_") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"_\"") ; :: peg :: RuleResult :: Failed } } ; - match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => { let __choice_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "__") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"__\"") ; :: peg :: RuleResult :: Failed } } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "___") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"___\"") ; :: peg :: RuleResult :: Failed } } } } } - }; - __err_state - .suppress_fail -= 1; - match __assert_res { :: peg :: RuleResult :: Matched (_ , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } - }; - match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { { let __seq_res = __parse_IDENT (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , name) => { { let __seq_res = match match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "(") { :: peg :: RuleResult :: Matched (__pos , __val) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ")") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\")\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"(\"") ; :: peg :: RuleResult :: Failed } } { :: peg :: RuleResult :: Matched (__newpos , _) => { :: peg :: RuleResult :: Matched (__newpos , ()) } , :: peg :: RuleResult :: Failed => { :: peg :: RuleResult :: Matched (__pos , ()) } , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { :: peg :: RuleResult :: Matched (__pos , (|| { (name , None , Vec :: new ()) }) ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } - }; - match __choice_res { - ::peg::RuleResult::Matched( - __pos, - __value, - ) => { - ::peg::RuleResult::Matched( - __pos, __value, - ) - } - ::peg::RuleResult::Failed => { - let __seq_res = - __parse_IDENT( - __input, - __state, - __err_state, - __pos, - ); - match __seq_res { :: peg :: RuleResult :: Matched (__pos , name) => { { let __seq_res = match __parse_rust_ty_params (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (__newpos , __value) => { :: peg :: RuleResult :: Matched (__newpos , Some (__value)) } , :: peg :: RuleResult :: Failed => { :: peg :: RuleResult :: Matched (__pos , None) } , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , ty_params) => { { let __seq_res = __parse_rule_params (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , params) => { :: peg :: RuleResult :: Matched (__pos , (|| { (name , ty_params , params) }) ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } - } - } - }; - match __seq_res { - ::peg::RuleResult::Matched( - __pos, - header, - ) => { - let __seq_res = match match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "->") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = { let str_start = __pos ; match match __parse_rust_type (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } { :: peg :: RuleResult :: Matched (__newpos , _) => { :: peg :: RuleResult :: Matched (__newpos , :: peg :: ParseSlice :: parse_slice (__input , str_start , __newpos)) } , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , t) => { :: peg :: RuleResult :: Matched (__pos , (|| { t }) ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"->\"") ; :: peg :: RuleResult :: Failed } } { :: peg :: RuleResult :: Matched (__newpos , __value) => { :: peg :: RuleResult :: Matched (__newpos , Some (__value)) } , :: peg :: RuleResult :: Failed => { :: peg :: RuleResult :: Matched (__pos , None) } , } ; - match __seq_res { :: peg :: RuleResult :: Matched (__pos , ret_type) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "=") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = __parse_expression (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , expr) => { { let __seq_res = match match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ";") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\";\"") ; :: peg :: RuleResult :: Failed } } { :: peg :: RuleResult :: Matched (__newpos , _) => { :: peg :: RuleResult :: Matched (__newpos , ()) } , :: peg :: RuleResult :: Failed => { :: peg :: RuleResult :: Matched (__pos , ()) } , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { :: peg :: RuleResult :: Matched (__pos , (|| { Rule { span , doc , name : header . 0 , ty_params : header . 1 , params : header . 2 , expr , ret_type , visibility , no_eof , cache } }) ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"=\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } - } - ::peg::RuleResult::Failed => { - ::peg::RuleResult::Failed - } + let __rule_result: ::peg::RuleResult> = { + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "(") { + ::peg::RuleResult::Matched(__pos, __val) => { + let __seq_res = { + let mut __repeat_pos = __pos; + let mut __repeat_value = vec![]; + loop { + let __pos = __repeat_pos; + let __pos = if __repeat_value.is_empty() { + __pos + } else { + let __sep_res = match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, ",", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched(__pos, __val) + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\",\""); + ::peg::RuleResult::Failed + } + }; + match __sep_res { + ::peg::RuleResult::Matched(__newpos, _) => __newpos, + ::peg::RuleResult::Failed => break, + } + }; + let __step_res = { + let __seq_res = + __parse_IDENT(__input, __state, __err_state, __pos); + match __seq_res { + ::peg::RuleResult::Matched(__pos, i) => { + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, ":", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + let __seq_res = { + let str_start = __pos; + match match __parse_rust_type( + __input, + __state, + __err_state, + __pos, + ) { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed + } + } { + ::peg::RuleResult::Matched( + __newpos, + _, + ) => ::peg::RuleResult::Matched( + __newpos, + ::peg::ParseSlice::parse_slice( + __input, str_start, __newpos, + ), + ), + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed } } + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, t) => { + ::peg::RuleResult::Matched( + __pos, + (|| (i, t))(), + ) + } ::peg::RuleResult::Failed => { - __err_state - .mark_failure(__pos, "\"rule\""); ::peg::RuleResult::Failed } } } ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\":\""); ::peg::RuleResult::Failed } } } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } + }; + match __step_res { + ::peg::RuleResult::Matched(__newpos, __value) => { + __repeat_pos = __newpos; + __repeat_value.push(__value); + } + ::peg::RuleResult::Failed => { + break; + } + } + } + ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, args) => { + let __seq_res = + match match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, ",", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched(__pos, __val) + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\",\""); + ::peg::RuleResult::Failed + } + } { + ::peg::RuleResult::Matched(__newpos, _) => { + ::peg::RuleResult::Matched(__newpos, ()) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Matched(__pos, ()) + } + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, _) => { + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, ")", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched(__pos, (|| args)()) + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\")\""); + ::peg::RuleResult::Failed + } + } + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"(\""); + ::peg::RuleResult::Failed } } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } + }; + __rule_result } } - fn __parse_cacheflag<'input>( + fn __parse_peg_rule<'input>( __input: &'input Input, __state: &mut ParseState<'input>, __err_state: &mut ::peg::error::ErrorState, __pos: usize, - ) -> ::peg::RuleResult> { + ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let __choice_res = match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "#") - { - ::peg::RuleResult::Matched(__pos, __val) => { - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "[") { - ::peg::RuleResult::Matched(__pos, __val) => { - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "cache") - { - ::peg::RuleResult::Matched(__pos, __val) => { - match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "]", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched( + let __rule_result: ::peg::RuleResult = { + { + let __seq_res = __parse_rust_doc_comment(__input, __state, __err_state, __pos); + match __seq_res { + ::peg::RuleResult::Matched(__pos, doc) => { + let __seq_res = __parse_cacheflag(__input, __state, __err_state, __pos); + match __seq_res { + ::peg::RuleResult::Matched(__pos, cache) => { + let __seq_res = + __parse_no_eof_flag(__input, __state, __err_state, __pos); + match __seq_res { + ::peg::RuleResult::Matched(__pos, no_eof) => { + let __seq_res = __parse_rust_visibility( + __input, + __state, + __err_state, __pos, - (|| Some(Cache::Simple))(), - ) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"]\""); - ::peg::RuleResult::Failed + ); + match __seq_res { + ::peg::RuleResult::Matched(__pos, visibility) => { + let __seq_res = __parse_sp( + __input, + __state, + __err_state, + __pos, + ); + match __seq_res { :: peg :: RuleResult :: Matched (__pos , span) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "rule") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = { let __choice_res = { let __seq_res = { __err_state . suppress_fail += 1 ; let __assert_res = { let __choice_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "_") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"_\"") ; :: peg :: RuleResult :: Failed } } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => { let __choice_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "__") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"__\"") ; :: peg :: RuleResult :: Failed } } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "___") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"___\"") ; :: peg :: RuleResult :: Failed } } } } } } ; __err_state . suppress_fail -= 1 ; match __assert_res { :: peg :: RuleResult :: Matched (_ , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { { let __seq_res = __parse_IDENT (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , name) => { { let __seq_res = match match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "(") { :: peg :: RuleResult :: Matched (__pos , __val) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ")") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\")\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"(\"") ; :: peg :: RuleResult :: Failed } } { :: peg :: RuleResult :: Matched (__newpos , _) => { :: peg :: RuleResult :: Matched (__newpos , ()) } , :: peg :: RuleResult :: Failed => { :: peg :: RuleResult :: Matched (__pos , ()) } , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { :: peg :: RuleResult :: Matched (__pos , (|| { (name , None , Vec :: new ()) }) ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => { let __seq_res = __parse_IDENT (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , name) => { { let __seq_res = match __parse_rust_ty_params (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (__newpos , __value) => { :: peg :: RuleResult :: Matched (__newpos , Some (__value)) } , :: peg :: RuleResult :: Failed => { :: peg :: RuleResult :: Matched (__pos , None) } , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , ty_params) => { { let __seq_res = __parse_rule_params (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , params) => { :: peg :: RuleResult :: Matched (__pos , (|| { (name , ty_params , params) }) ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , header) => { { let __seq_res = match match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "->") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = { let str_start = __pos ; match match __parse_rust_type (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } { :: peg :: RuleResult :: Matched (__newpos , _) => { :: peg :: RuleResult :: Matched (__newpos , :: peg :: ParseSlice :: parse_slice (__input , str_start , __newpos)) } , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , t) => { :: peg :: RuleResult :: Matched (__pos , (|| { t }) ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"->\"") ; :: peg :: RuleResult :: Failed } } { :: peg :: RuleResult :: Matched (__newpos , __value) => { :: peg :: RuleResult :: Matched (__newpos , Some (__value)) } , :: peg :: RuleResult :: Failed => { :: peg :: RuleResult :: Matched (__pos , None) } , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , ret_type) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "=") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = __parse_expression (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , expr) => { { let __seq_res = match match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ";") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\";\"") ; :: peg :: RuleResult :: Failed } } { :: peg :: RuleResult :: Matched (__newpos , _) => { :: peg :: RuleResult :: Matched (__newpos , ()) } , :: peg :: RuleResult :: Failed => { :: peg :: RuleResult :: Matched (__pos , ()) } , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { :: peg :: RuleResult :: Matched (__pos , (|| { Rule { span , doc , name : header . 0 , ty_params : header . 1 , params : header . 2 , expr , ret_type , visibility , no_eof , cache } }) ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"=\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"rule\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed + } + } } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"cache\""); - ::peg::RuleResult::Failed - } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"[\""); - ::peg::RuleResult::Failed - } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"#\""); - ::peg::RuleResult::Failed - } }; - match __choice_res { - ::peg::RuleResult::Matched(__pos, __value) => { - ::peg::RuleResult::Matched(__pos, __value) - } - ::peg::RuleResult::Failed => { + __rule_result + } + } + fn __parse_cacheflag<'input>( + __input: &'input Input, + __state: &mut ParseState<'input>, + __err_state: &mut ::peg::error::ErrorState, + __pos: usize, + ) -> ::peg::RuleResult> { + #![allow(non_snake_case, unused, clippy::redundant_closure_call)] + { + let __rule_result: ::peg::RuleResult> = { + { let __choice_res = match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "#") { ::peg::RuleResult::Matched(__pos, __val) => { @@ -537,9 +474,7 @@ pub mod peg { { ::peg::RuleResult::Matched(__pos, __val) => { match ::peg::ParseLiteral::parse_string_literal( - __input, - __pos, - "cache_left_rec", + __input, __pos, "cache", ) { ::peg::RuleResult::Matched(__pos, __val) => { match ::peg::ParseLiteral::parse_string_literal( @@ -548,7 +483,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched( __pos, - (|| Some(Cache::Recursive))(), + (|| Some(Cache::Simple))(), ) } ::peg::RuleResult::Failed => { @@ -558,8 +493,7 @@ pub mod peg { } } ::peg::RuleResult::Failed => { - __err_state - .mark_failure(__pos, "\"cache_left_rec\""); + __err_state.mark_failure(__pos, "\"cache\""); ::peg::RuleResult::Failed } } @@ -579,459 +513,417 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } - ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, (|| None)()), - } - } - } - } - } - fn __parse_no_eof_flag<'input>( - __input: &'input Input, - __state: &mut ParseState<'input>, - __err_state: &mut ::peg::error::ErrorState, - __pos: usize, - ) -> ::peg::RuleResult { - #![allow(non_snake_case, unused, clippy::redundant_closure_call)] - { - let __choice_res = match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "#") - { - ::peg::RuleResult::Matched(__pos, __val) => { - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "[") { - ::peg::RuleResult::Matched(__pos, __val) => { - match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "no_eof", + ::peg::RuleResult::Failed => { + let __choice_res = match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, "#", ) { ::peg::RuleResult::Matched(__pos, __val) => { match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "]", + __input, __pos, "[", ) { ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, (|| true)()) + match ::peg::ParseLiteral::parse_string_literal( + __input, + __pos, + "cache_left_rec", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, "]", + ) { + ::peg::RuleResult::Matched( + __pos, + __val, + ) => ::peg::RuleResult::Matched( + __pos, + (|| Some(Cache::Recursive))(), + ), + ::peg::RuleResult::Failed => { + __err_state + .mark_failure(__pos, "\"]\""); + ::peg::RuleResult::Failed + } + } + } + ::peg::RuleResult::Failed => { + __err_state + .mark_failure(__pos, "\"cache_left_rec\""); + ::peg::RuleResult::Failed + } + } } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"]\""); + __err_state.mark_failure(__pos, "\"[\""); ::peg::RuleResult::Failed } } } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"no_eof\""); + __err_state.mark_failure(__pos, "\"#\""); ::peg::RuleResult::Failed } + }; + match __choice_res { + ::peg::RuleResult::Matched(__pos, __value) => { + ::peg::RuleResult::Matched(__pos, __value) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Matched(__pos, (|| None)()) + } } } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"[\""); - ::peg::RuleResult::Failed - } } } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"#\""); - ::peg::RuleResult::Failed - } }; - match __choice_res { - ::peg::RuleResult::Matched(__pos, __value) => { - ::peg::RuleResult::Matched(__pos, __value) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, (|| false)()), - } + __rule_result } } - fn __parse_rule_param_ty<'input>( + fn __parse_no_eof_flag<'input>( __input: &'input Input, __state: &mut ParseState<'input>, __err_state: &mut ::peg::error::ErrorState, __pos: usize, - ) -> ::peg::RuleResult { + ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let __choice_res = - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "rule") { - ::peg::RuleResult::Matched(__pos, __val) => { - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "<") { + let __rule_result: ::peg::RuleResult = { + { + let __choice_res = + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "#") { ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = { - let str_start = __pos; - match match __parse_rust_type( - __input, - __state, - __err_state, - __pos, - ) { - ::peg::RuleResult::Matched(pos, _) => { - ::peg::RuleResult::Matched(pos, ()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } { - ::peg::RuleResult::Matched(__newpos, _) => { - ::peg::RuleResult::Matched( - __newpos, - ::peg::ParseSlice::parse_slice( - __input, str_start, __newpos, - ), - ) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, r) => { + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "[") + { + ::peg::RuleResult::Matched(__pos, __val) => { match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, ">", + __input, __pos, "no_eof", ) { ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched( - __pos, - (|| RuleParamTy::Rule(r))(), - ) + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, "]", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched( + __pos, + (|| true)(), + ) + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"]\""); + ::peg::RuleResult::Failed + } + } } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\">\""); + __err_state.mark_failure(__pos, "\"no_eof\""); ::peg::RuleResult::Failed } } } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"[\""); + ::peg::RuleResult::Failed + } } } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"<\""); + __err_state.mark_failure(__pos, "\"#\""); ::peg::RuleResult::Failed } + }; + match __choice_res { + ::peg::RuleResult::Matched(__pos, __value) => { + ::peg::RuleResult::Matched(__pos, __value) } - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"rule\""); - ::peg::RuleResult::Failed - } - }; - match __choice_res { - ::peg::RuleResult::Matched(__pos, __value) => { - ::peg::RuleResult::Matched(__pos, __value) - } - ::peg::RuleResult::Failed => { - let __seq_res = { - let str_start = __pos; - match match __parse_rust_type(__input, __state, __err_state, __pos) { - ::peg::RuleResult::Matched(pos, _) => { - ::peg::RuleResult::Matched(pos, ()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } { - ::peg::RuleResult::Matched(__newpos, _) => ::peg::RuleResult::Matched( - __newpos, - ::peg::ParseSlice::parse_slice(__input, str_start, __newpos), - ), - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, t) => { - ::peg::RuleResult::Matched(__pos, (|| RuleParamTy::Rust(t))()) + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Matched(__pos, (|| false)()) } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } - } + }; + __rule_result } } - fn __parse_rule_params<'input>( + fn __parse_rule_param_ty<'input>( __input: &'input Input, __state: &mut ParseState<'input>, __err_state: &mut ::peg::error::ErrorState, __pos: usize, - ) -> ::peg::RuleResult> { + ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "(") { - ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = { - let mut __repeat_pos = __pos; - let mut __repeat_value = vec![]; - loop { - let __pos = __repeat_pos; - let __pos = if __repeat_value.is_empty() { - __pos - } else { - let __sep_res = match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, ",", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, __val) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\",\""); - ::peg::RuleResult::Failed - } - }; - match __sep_res { - ::peg::RuleResult::Matched(__newpos, _) => __newpos, - ::peg::RuleResult::Failed => break, - } - }; - let __step_res = { - let __seq_res = __parse_IDENT(__input, __state, __err_state, __pos); - match __seq_res { - ::peg::RuleResult::Matched(__pos, name) => { - match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, ":", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = __parse_rule_param_ty( + { + let __rule_result: ::peg::RuleResult = { + { + let __choice_res = + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "rule") { + ::peg::RuleResult::Matched(__pos, __val) => { + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "<") + { + ::peg::RuleResult::Matched(__pos, __val) => { + let __seq_res = { + let str_start = __pos; + match match __parse_rust_type( __input, __state, __err_state, __pos, - ); - match __seq_res { - ::peg::RuleResult::Matched(__pos, ty) => { + ) { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed + } + } { + ::peg::RuleResult::Matched(__newpos, _) => { ::peg::RuleResult::Matched( - __pos, - (|| RuleParam { name, ty })(), + __newpos, + ::peg::ParseSlice::parse_slice( + __input, str_start, __newpos, + ), ) } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } } + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, r) => { + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, ">", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched( + __pos, + (|| RuleParamTy::Rule(r))(), + ) + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\">\""); + ::peg::RuleResult::Failed + } + } + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\":\""); - ::peg::RuleResult::Failed - } + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"<\""); + ::peg::RuleResult::Failed } } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } - }; - match __step_res { - ::peg::RuleResult::Matched(__newpos, __value) => { - __repeat_pos = __newpos; - __repeat_value.push(__value); } ::peg::RuleResult::Failed => { - break; + __err_state.mark_failure(__pos, "\"rule\""); + ::peg::RuleResult::Failed } + }; + match __choice_res { + ::peg::RuleResult::Matched(__pos, __value) => { + ::peg::RuleResult::Matched(__pos, __value) } - } - ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, params) => { - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, ")") { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, (|| params)()) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\")\""); - ::peg::RuleResult::Failed + ::peg::RuleResult::Failed => { + let __seq_res = { + let str_start = __pos; + match match __parse_rust_type(__input, __state, __err_state, __pos) + { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } { + ::peg::RuleResult::Matched(__newpos, _) => { + ::peg::RuleResult::Matched( + __newpos, + ::peg::ParseSlice::parse_slice( + __input, str_start, __newpos, + ), + ) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, t) => { + ::peg::RuleResult::Matched(__pos, (|| RuleParamTy::Rust(t))()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"(\""); - ::peg::RuleResult::Failed - } - } - } - fn __parse_item<'input>( - __input: &'input Input, - __state: &mut ParseState<'input>, - __err_state: &mut ::peg::error::ErrorState, - __pos: usize, - ) -> ::peg::RuleResult { - #![allow(non_snake_case, unused, clippy::redundant_closure_call)] - { - let __choice_res = { - let __seq_res = __parse_rust_use(__input, __state, __err_state, __pos); - match __seq_res { - ::peg::RuleResult::Matched(__pos, u) => { - ::peg::RuleResult::Matched(__pos, (|| Item::Use(u))()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } }; - match __choice_res { - ::peg::RuleResult::Matched(__pos, __value) => { - ::peg::RuleResult::Matched(__pos, __value) - } - ::peg::RuleResult::Failed => { - let __seq_res = __parse_peg_rule(__input, __state, __err_state, __pos); - match __seq_res { - ::peg::RuleResult::Matched(__pos, r) => { - ::peg::RuleResult::Matched(__pos, (|| Item::Rule(r))()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } - } - } + __rule_result } } - fn __parse_rust_doc_comment<'input>( + fn __parse_rule_params<'input>( __input: &'input Input, __state: &mut ParseState<'input>, __err_state: &mut ::peg::error::ErrorState, __pos: usize, - ) -> ::peg::RuleResult> { + ) -> ::peg::RuleResult> { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] - match { - let str_start = __pos; - match { - let mut __repeat_pos = __pos; - loop { - let __pos = __repeat_pos; - let __step_res = match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "#", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "[") { - ::peg::RuleResult::Matched(__pos, __val) => { - match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "doc", + { + let __rule_result: ::peg::RuleResult> = { + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "(") { + ::peg::RuleResult::Matched(__pos, __val) => { + let __seq_res = { + let mut __repeat_pos = __pos; + let mut __repeat_value = vec![]; + loop { + let __pos = __repeat_pos; + let __pos = if __repeat_value.is_empty() { + __pos + } else { + let __sep_res = match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, ",", ) { ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched(__pos, __val) + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\",\""); + ::peg::RuleResult::Failed + } + }; + match __sep_res { + ::peg::RuleResult::Matched(__newpos, _) => __newpos, + ::peg::RuleResult::Failed => break, + } + }; + let __step_res = { + let __seq_res = + __parse_IDENT(__input, __state, __err_state, __pos); + match __seq_res { + ::peg::RuleResult::Matched(__pos, name) => { match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "=", + __input, __pos, ":", ) { ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = match __parse_LITERAL( + let __seq_res = __parse_rule_param_ty( __input, __state, __err_state, __pos, - ) { - ::peg::RuleResult::Matched(pos, _) => { - ::peg::RuleResult::Matched(pos, ()) + ); + match __seq_res { + ::peg::RuleResult::Matched(__pos, ty) => { + ::peg::RuleResult::Matched( + __pos, + (|| RuleParam { name, ty })(), + ) } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } - }; - match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "]") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"]\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } + } } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"=\""); + __err_state.mark_failure(__pos, "\":\""); ::peg::RuleResult::Failed } } } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"doc\""); - ::peg::RuleResult::Failed - } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + }; + match __step_res { + ::peg::RuleResult::Matched(__newpos, __value) => { + __repeat_pos = __newpos; + __repeat_value.push(__value); + } + ::peg::RuleResult::Failed => { + break; } - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"[\""); - ::peg::RuleResult::Failed } } - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"#\""); - ::peg::RuleResult::Failed - } - }; - match __step_res { - ::peg::RuleResult::Matched(__newpos, __value) => { - __repeat_pos = __newpos; - } - ::peg::RuleResult::Failed => { - break; + ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, params) => { + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, ")") + { + ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched(__pos, (|| params)()) + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\")\""); + ::peg::RuleResult::Failed + } + } + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"(\""); + ::peg::RuleResult::Failed + } } - ::peg::RuleResult::Matched(__repeat_pos, ()) - } { - ::peg::RuleResult::Matched(__newpos, _) => ::peg::RuleResult::Matched( - __newpos, - ::peg::ParseSlice::parse_slice(__input, str_start, __newpos), - ), - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } - } { - ::peg::RuleResult::Matched(__newpos, __value) => { - ::peg::RuleResult::Matched(__newpos, Some(__value)) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, None), + }; + __rule_result } } - fn __parse_rust_visibility<'input>( + fn __parse_item<'input>( __input: &'input Input, __state: &mut ParseState<'input>, __err_state: &mut ::peg::error::ErrorState, __pos: usize, - ) -> ::peg::RuleResult> { + ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] - match { - let str_start = __pos; - match { - let __choice_res = - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "pub") { - ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = match match __parse_PAREN_GROUP( - __input, - __state, - __err_state, - __pos, - ) { - ::peg::RuleResult::Matched(pos, _) => { - ::peg::RuleResult::Matched(pos, ()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } { - ::peg::RuleResult::Matched(__newpos, _) => { - ::peg::RuleResult::Matched(__newpos, ()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, ()), - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, _) => { - ::peg::RuleResult::Matched(__pos, ()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + { + let __rule_result: ::peg::RuleResult = { + { + let __choice_res = { + let __seq_res = __parse_rust_use(__input, __state, __err_state, __pos); + match __seq_res { + ::peg::RuleResult::Matched(__pos, u) => { + ::peg::RuleResult::Matched(__pos, (|| Item::Use(u))()) } - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"pub\""); - ::peg::RuleResult::Failed + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } }; - match __choice_res { - ::peg::RuleResult::Matched(__pos, __value) => { - ::peg::RuleResult::Matched(__pos, __value) - } - ::peg::RuleResult::Failed => { - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "crate") { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, __val) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"crate\""); - ::peg::RuleResult::Failed + match __choice_res { + ::peg::RuleResult::Matched(__pos, __value) => { + ::peg::RuleResult::Matched(__pos, __value) + } + ::peg::RuleResult::Failed => { + let __choice_res = { + let __seq_res = + __parse_peg_rule(__input, __state, __err_state, __pos); + match __seq_res { + ::peg::RuleResult::Matched(__pos, r) => { + ::peg::RuleResult::Matched(__pos, (|| Item::Rule(r))()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + }; + match __choice_res { + ::peg::RuleResult::Matched(__pos, __value) => { + ::peg::RuleResult::Matched(__pos, __value) + } + ::peg::RuleResult::Failed => { + let __seq_res = + __parse_stack_limit(__input, __state, __err_state, __pos); + match __seq_res { + ::peg::RuleResult::Matched(__pos, l) => { + ::peg::RuleResult::Matched( + __pos, + (|| Item::StackLimit(l))(), + ) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + } } } } } - } { - ::peg::RuleResult::Matched(__newpos, _) => ::peg::RuleResult::Matched( - __newpos, - ::peg::ParseSlice::parse_slice(__input, str_start, __newpos), - ), - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } - } { - ::peg::RuleResult::Matched(__newpos, __value) => { - ::peg::RuleResult::Matched(__newpos, Some(__value)) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, None), + }; + __rule_result } } - fn __parse_rust_use<'input>( + fn __parse_stack_limit<'input>( __input: &'input Input, __state: &mut ParseState<'input>, __err_state: &mut ::peg::error::ErrorState, @@ -1039,262 +931,284 @@ pub mod peg { ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let __seq_res = { - let str_start = __pos; - match match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "use") { + let __rule_result: ::peg::RuleResult = { + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "stack_limit") { ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = - match __parse_rust_path(__input, __state, __err_state, __pos) { + let __seq_res = { + let str_start = __pos; + match match __parse_INTEGER(__input, __state, __err_state, __pos) { ::peg::RuleResult::Matched(pos, _) => { ::peg::RuleResult::Matched(pos, ()) } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - }; + } { + ::peg::RuleResult::Matched(__newpos, _) => { + ::peg::RuleResult::Matched( + __newpos, + ::peg::ParseSlice::parse_slice( + __input, str_start, __newpos, + ), + ) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + }; match __seq_res { - ::peg::RuleResult::Matched(__pos, _) => { - let __seq_res = { - let __choice_res = - match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "::", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "*", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, ()) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"*\""); - ::peg::RuleResult::Failed - } - } - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"::\""); - ::peg::RuleResult::Failed - } - }; - match __choice_res { - ::peg::RuleResult::Matched(__pos, __value) => { - ::peg::RuleResult::Matched(__pos, __value) - } - ::peg::RuleResult::Failed => { - let __choice_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "::") { :: peg :: RuleResult :: Matched (__pos , __val) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "{") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! () ; loop { let __pos = __repeat_pos ; let __pos = if __repeat_value . is_empty () { __pos } else { let __sep_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ",") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\",\"") ; :: peg :: RuleResult :: Failed } } ; match __sep_res { :: peg :: RuleResult :: Matched (__newpos , _) => { __newpos } , :: peg :: RuleResult :: Failed => break , } } ; let __step_res = { let __seq_res = match __parse_IDENT (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { { let __seq_res = match match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "as") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = match __parse_IDENT (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"as\"") ; :: peg :: RuleResult :: Failed } } { :: peg :: RuleResult :: Matched (__newpos , _) => { :: peg :: RuleResult :: Matched (__newpos , ()) } , :: peg :: RuleResult :: Failed => { :: peg :: RuleResult :: Matched (__pos , ()) } , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ; match __step_res { :: peg :: RuleResult :: Matched (__newpos , __value) => { __repeat_pos = __newpos ; __repeat_value . push (__value) ; } , :: peg :: RuleResult :: Failed => { break ; } } } if __repeat_value . len () >= 1 { :: peg :: RuleResult :: Matched (__repeat_pos , ()) } else { :: peg :: RuleResult :: Failed } } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "}") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"}\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"{\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"::\"") ; :: peg :: RuleResult :: Failed } } ; - match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => match match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "as") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = match __parse_IDENT (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"as\"") ; :: peg :: RuleResult :: Failed } } { :: peg :: RuleResult :: Matched (__newpos , _) => { :: peg :: RuleResult :: Matched (__newpos , ()) } , :: peg :: RuleResult :: Failed => { :: peg :: RuleResult :: Matched (__pos , ()) } , } } - } + ::peg::RuleResult::Matched(__pos, i) => { + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, ";") + { + ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched(__pos, (|| i)()) } - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, _) => { - match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, ";", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, ()) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\";\""); - ::peg::RuleResult::Failed - } - } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\";\""); + ::peg::RuleResult::Failed } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"use\""); + __err_state.mark_failure(__pos, "\"stack_limit\""); ::peg::RuleResult::Failed } - } { - ::peg::RuleResult::Matched(__newpos, _) => ::peg::RuleResult::Matched( - __newpos, - ::peg::ParseSlice::parse_slice(__input, str_start, __newpos), - ), - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, v) => { - ::peg::RuleResult::Matched(__pos, (|| v.to_owned())()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } + __rule_result } } - fn __parse_rust_path<'input>( + fn __parse_rust_doc_comment<'input>( __input: &'input Input, __state: &mut ParseState<'input>, __err_state: &mut ::peg::error::ErrorState, __pos: usize, - ) -> ::peg::RuleResult<()> { + ) -> ::peg::RuleResult> { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let __seq_res = - match match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "crate") { - ::peg::RuleResult::Matched(__pos, __val) => { - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "::") { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, ()) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"::\""); - ::peg::RuleResult::Failed - } - } - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"crate\""); - ::peg::RuleResult::Failed - } - } { - ::peg::RuleResult::Matched(__newpos, _) => { - ::peg::RuleResult::Matched(__newpos, ()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, ()), - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, _) => { - let __seq_res = { + let __rule_result: ::peg::RuleResult> = { + match { + let str_start = __pos; + match { let mut __repeat_pos = __pos; - let mut __repeat_value = vec![]; loop { let __pos = __repeat_pos; - let __pos = if __repeat_value.is_empty() { - __pos - } else { - let __sep_res = match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "::", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, __val) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"::\""); - ::peg::RuleResult::Failed + let __step_res = match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, "#", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, "[", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, "doc", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, "=", + ) { + ::peg::RuleResult::Matched( + __pos, + __val, + ) => { + let __seq_res = match __parse_LITERAL( + __input, + __state, + __err_state, + __pos, + ) { + ::peg::RuleResult::Matched( + pos, + _, + ) => ::peg::RuleResult::Matched( + pos, + (), + ), + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed + } + }; + match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "]") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"]\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } + } + ::peg::RuleResult::Failed => { + __err_state + .mark_failure(__pos, "\"=\""); + ::peg::RuleResult::Failed + } + } + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"doc\""); + ::peg::RuleResult::Failed + } + } + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"[\""); + ::peg::RuleResult::Failed + } } - }; - match __sep_res { - ::peg::RuleResult::Matched(__newpos, _) => __newpos, - ::peg::RuleResult::Failed => break, + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"#\""); + ::peg::RuleResult::Failed } }; - let __step_res = - match __parse_IDENT(__input, __state, __err_state, __pos) { - ::peg::RuleResult::Matched(pos, _) => { - ::peg::RuleResult::Matched(pos, ()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - }; match __step_res { ::peg::RuleResult::Matched(__newpos, __value) => { __repeat_pos = __newpos; - __repeat_value.push(__value); } ::peg::RuleResult::Failed => { break; } } } - if __repeat_value.len() >= 1 { - ::peg::RuleResult::Matched(__repeat_pos, ()) - } else { - ::peg::RuleResult::Failed - } - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, _) => { - ::peg::RuleResult::Matched(__pos, ()) - } + ::peg::RuleResult::Matched(__repeat_pos, ()) + } { + ::peg::RuleResult::Matched(__newpos, _) => ::peg::RuleResult::Matched( + __newpos, + ::peg::ParseSlice::parse_slice(__input, str_start, __newpos), + ), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } + } { + ::peg::RuleResult::Matched(__newpos, __value) => { + ::peg::RuleResult::Matched(__newpos, Some(__value)) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, None), } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } + }; + __rule_result } } - fn __parse_rust_type<'input>( + fn __parse_rust_visibility<'input>( __input: &'input Input, __state: &mut ParseState<'input>, __err_state: &mut ::peg::error::ErrorState, __pos: usize, - ) -> ::peg::RuleResult<()> { + ) -> ::peg::RuleResult> { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let __choice_res = match __parse_BRACKET_GROUP(__input, __state, __err_state, __pos) { - ::peg::RuleResult::Matched(pos, _) => ::peg::RuleResult::Matched(pos, ()), - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - }; - match __choice_res { - ::peg::RuleResult::Matched(__pos, __value) => { - ::peg::RuleResult::Matched(__pos, __value) - } - ::peg::RuleResult::Failed => { - let __choice_res = - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "&") { + let __rule_result: ::peg::RuleResult> = { + match { + let str_start = __pos; + match { + let __choice_res = match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, "pub", + ) { ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = - match match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "mut", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, __val) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"mut\""); - ::peg::RuleResult::Failed - } - } { - ::peg::RuleResult::Matched(__newpos, _) => { - ::peg::RuleResult::Matched(__newpos, ()) - } - ::peg::RuleResult::Failed => { - ::peg::RuleResult::Matched(__pos, ()) + let __seq_res = match match __parse_PAREN_GROUP( + __input, + __state, + __err_state, + __pos, + ) { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } { + ::peg::RuleResult::Matched(__newpos, _) => { + ::peg::RuleResult::Matched(__newpos, ()) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Matched(__pos, ()) + } + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, _) => { + ::peg::RuleResult::Matched(__pos, ()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"pub\""); + ::peg::RuleResult::Failed + } + }; + match __choice_res { + ::peg::RuleResult::Matched(__pos, __value) => { + ::peg::RuleResult::Matched(__pos, __value) + } + ::peg::RuleResult::Failed => { + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, "crate", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched(__pos, __val) + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"crate\""); + ::peg::RuleResult::Failed + } + } + } + } + } { + ::peg::RuleResult::Matched(__newpos, _) => ::peg::RuleResult::Matched( + __newpos, + ::peg::ParseSlice::parse_slice(__input, str_start, __newpos), + ), + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + } { + ::peg::RuleResult::Matched(__newpos, __value) => { + ::peg::RuleResult::Matched(__newpos, Some(__value)) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, None), + } + }; + __rule_result + } + } + fn __parse_rust_use<'input>( + __input: &'input Input, + __state: &mut ParseState<'input>, + __err_state: &mut ::peg::error::ErrorState, + __pos: usize, + ) -> ::peg::RuleResult { + #![allow(non_snake_case, unused, clippy::redundant_closure_call)] + { + let __rule_result: ::peg::RuleResult = { + { + let __seq_res = { + let str_start = __pos; + match match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "use") + { + ::peg::RuleResult::Matched(__pos, __val) => { + let __seq_res = + match __parse_rust_path(__input, __state, __err_state, __pos) { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, }; match __seq_res { ::peg::RuleResult::Matched(__pos, _) => { - let __seq_res = match match __parse_LIFETIME( - __input, - __state, - __err_state, - __pos, - ) { - ::peg::RuleResult::Matched(pos, _) => { - ::peg::RuleResult::Matched(pos, ()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } { - ::peg::RuleResult::Matched(__newpos, _) => { - ::peg::RuleResult::Matched(__newpos, ()) - } - ::peg::RuleResult::Failed => { - ::peg::RuleResult::Matched(__pos, ()) + let __seq_res = { + let __choice_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "::") { :: peg :: RuleResult :: Matched (__pos , __val) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "*") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"*\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"::\"") ; :: peg :: RuleResult :: Failed } } ; + match __choice_res { + ::peg::RuleResult::Matched(__pos, __value) => { + ::peg::RuleResult::Matched(__pos, __value) + } + ::peg::RuleResult::Failed => { + let __choice_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "::") { :: peg :: RuleResult :: Matched (__pos , __val) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "{") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! () ; loop { let __pos = __repeat_pos ; let __pos = if __repeat_value . is_empty () { __pos } else { let __sep_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ",") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\",\"") ; :: peg :: RuleResult :: Failed } } ; match __sep_res { :: peg :: RuleResult :: Matched (__newpos , _) => { __newpos } , :: peg :: RuleResult :: Failed => break , } } ; let __step_res = { let __seq_res = match __parse_IDENT (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { { let __seq_res = match match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "as") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = match __parse_IDENT (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"as\"") ; :: peg :: RuleResult :: Failed } } { :: peg :: RuleResult :: Matched (__newpos , _) => { :: peg :: RuleResult :: Matched (__newpos , ()) } , :: peg :: RuleResult :: Failed => { :: peg :: RuleResult :: Matched (__pos , ()) } , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ; match __step_res { :: peg :: RuleResult :: Matched (__newpos , __value) => { __repeat_pos = __newpos ; __repeat_value . push (__value) ; } , :: peg :: RuleResult :: Failed => { break ; } } } if __repeat_value . len () >= 1 { :: peg :: RuleResult :: Matched (__repeat_pos , ()) } else { :: peg :: RuleResult :: Failed } } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "}") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"}\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"{\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"::\"") ; :: peg :: RuleResult :: Failed } } ; + match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => match match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "as") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = match __parse_IDENT (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"as\"") ; :: peg :: RuleResult :: Failed } } { :: peg :: RuleResult :: Matched (__newpos , _) => { :: peg :: RuleResult :: Matched (__newpos , ()) } , :: peg :: RuleResult :: Failed => { :: peg :: RuleResult :: Matched (__pos , ()) } , } } + } } }; match __seq_res { ::peg::RuleResult::Matched(__pos, _) => { - let __seq_res = match __parse_rust_type( - __input, - __state, - __err_state, - __pos, + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, ";", ) { - ::peg::RuleResult::Matched(pos, _) => { - ::peg::RuleResult::Matched(pos, ()) - } - ::peg::RuleResult::Failed => { - ::peg::RuleResult::Failed - } - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, _) => { + ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, ()) } ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\";\""); ::peg::RuleResult::Failed } } @@ -1306,9 +1220,142 @@ pub mod peg { } } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"&\""); + __err_state.mark_failure(__pos, "\"use\""); ::peg::RuleResult::Failed } + } { + ::peg::RuleResult::Matched(__newpos, _) => ::peg::RuleResult::Matched( + __newpos, + ::peg::ParseSlice::parse_slice(__input, str_start, __newpos), + ), + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, v) => { + ::peg::RuleResult::Matched(__pos, (|| v.to_owned())()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + } + }; + __rule_result + } + } + fn __parse_rust_path<'input>( + __input: &'input Input, + __state: &mut ParseState<'input>, + __err_state: &mut ::peg::error::ErrorState, + __pos: usize, + ) -> ::peg::RuleResult<()> { + #![allow(non_snake_case, unused, clippy::redundant_closure_call)] + { + let __rule_result: ::peg::RuleResult<()> = { + { + let __seq_res = match match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, "crate", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "::") { + ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched(__pos, ()) + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"::\""); + ::peg::RuleResult::Failed + } + } + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"crate\""); + ::peg::RuleResult::Failed + } + } { + ::peg::RuleResult::Matched(__newpos, _) => { + ::peg::RuleResult::Matched(__newpos, ()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, ()), + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, _) => { + let __seq_res = { + let mut __repeat_pos = __pos; + let mut __repeat_value = vec![]; + loop { + let __pos = __repeat_pos; + let __pos = if __repeat_value.is_empty() { + __pos + } else { + let __sep_res = + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, "::", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched(__pos, __val) + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"::\""); + ::peg::RuleResult::Failed + } + }; + match __sep_res { + ::peg::RuleResult::Matched(__newpos, _) => __newpos, + ::peg::RuleResult::Failed => break, + } + }; + let __step_res = + match __parse_IDENT(__input, __state, __err_state, __pos) { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + }; + match __step_res { + ::peg::RuleResult::Matched(__newpos, __value) => { + __repeat_pos = __newpos; + __repeat_value.push(__value); + } + ::peg::RuleResult::Failed => { + break; + } + } + } + if __repeat_value.len() >= 1 { + ::peg::RuleResult::Matched(__repeat_pos, ()) + } else { + ::peg::RuleResult::Failed + } + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, _) => { + ::peg::RuleResult::Matched(__pos, ()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + } + }; + __rule_result + } + } + fn __parse_rust_type<'input>( + __input: &'input Input, + __state: &mut ParseState<'input>, + __err_state: &mut ::peg::error::ErrorState, + __pos: usize, + ) -> ::peg::RuleResult<()> { + #![allow(non_snake_case, unused, clippy::redundant_closure_call)] + { + let __rule_result: ::peg::RuleResult<()> = { + { + let __choice_res = + match __parse_BRACKET_GROUP(__input, __state, __err_state, __pos) { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, }; match __choice_res { ::peg::RuleResult::Matched(__pos, __value) => { @@ -1316,29 +1363,84 @@ pub mod peg { } ::peg::RuleResult::Failed => { let __choice_res = match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "dyn", + __input, __pos, "&", ) { ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = match __parse_rust_type( - __input, - __state, - __err_state, - __pos, - ) { - ::peg::RuleResult::Matched(pos, _) => { - ::peg::RuleResult::Matched(pos, ()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - }; + let __seq_res = + match match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, "mut", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched(__pos, __val) + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"mut\""); + ::peg::RuleResult::Failed + } + } { + ::peg::RuleResult::Matched(__newpos, _) => { + ::peg::RuleResult::Matched(__newpos, ()) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Matched(__pos, ()) + } + }; match __seq_res { ::peg::RuleResult::Matched(__pos, _) => { - ::peg::RuleResult::Matched(__pos, ()) + let __seq_res = match match __parse_LIFETIME( + __input, + __state, + __err_state, + __pos, + ) { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed + } + } { + ::peg::RuleResult::Matched(__newpos, _) => { + ::peg::RuleResult::Matched(__newpos, ()) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Matched(__pos, ()) + } + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, _) => { + let __seq_res = match __parse_rust_type( + __input, + __state, + __err_state, + __pos, + ) { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed + } + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, _) => { + ::peg::RuleResult::Matched(__pos, ()) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed + } + } + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed + } + } } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"dyn\""); + __err_state.mark_failure(__pos, "\"&\""); ::peg::RuleResult::Failed } }; @@ -1349,7 +1451,7 @@ pub mod peg { ::peg::RuleResult::Failed => { let __choice_res = match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "impl", + __input, __pos, "dyn", ) { ::peg::RuleResult::Matched(__pos, __val) => { let __seq_res = match __parse_rust_type( @@ -1375,7 +1477,7 @@ pub mod peg { } } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"impl\""); + __err_state.mark_failure(__pos, "\"dyn\""); ::peg::RuleResult::Failed } }; @@ -1386,46 +1488,37 @@ pub mod peg { ::peg::RuleResult::Failed => { let __choice_res = match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "(", + __input, __pos, "impl", ) { ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = { - let mut __repeat_pos = __pos; - let mut __repeat_value = vec![]; - loop { - let __pos = __repeat_pos; - let __pos = if __repeat_value - .is_empty() - { - __pos - } else { - let __sep_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ",") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\",\"") ; :: peg :: RuleResult :: Failed } } ; - match __sep_res { :: peg :: RuleResult :: Matched (__newpos , _) => { __newpos } , :: peg :: RuleResult :: Failed => break , } - }; - let __step_res = match __parse_rust_type (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; - match __step_res { - ::peg::RuleResult::Matched( - __newpos, - __value, - ) => { - __repeat_pos = __newpos; - __repeat_value - .push(__value); - } - ::peg::RuleResult::Failed => { - break; - } - } + let __seq_res = match __parse_rust_type( + __input, + __state, + __err_state, + __pos, + ) { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed + } + }; + match __seq_res { ::peg::RuleResult::Matched( - __repeat_pos, + __pos, + _, + ) => ::peg::RuleResult::Matched( + __pos, (), - ) - }; - match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ")") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\")\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } + ), + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed + } + } } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"(\""); + __err_state.mark_failure(__pos, "\"impl\""); ::peg::RuleResult::Failed } }; @@ -1434,17 +1527,32 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) } ::peg::RuleResult::Failed => { - match __parse_rust_ty_path( - __input, - __state, - __err_state, - __pos, - ) { - ::peg::RuleResult::Matched(pos, _) => { - ::peg::RuleResult::Matched(pos, ()) - } + let __choice_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "(") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! () ; loop { let __pos = __repeat_pos ; let __pos = if __repeat_value . is_empty () { __pos } else { let __sep_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ",") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\",\"") ; :: peg :: RuleResult :: Failed } } ; match __sep_res { :: peg :: RuleResult :: Matched (__newpos , _) => { __newpos } , :: peg :: RuleResult :: Failed => break , } } ; let __step_res = match __parse_rust_type (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; match __step_res { :: peg :: RuleResult :: Matched (__newpos , __value) => { __repeat_pos = __newpos ; __repeat_value . push (__value) ; } , :: peg :: RuleResult :: Failed => { break ; } } } :: peg :: RuleResult :: Matched (__repeat_pos , ()) } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ")") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\")\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"(\"") ; :: peg :: RuleResult :: Failed } } ; + match __choice_res { + ::peg::RuleResult::Matched( + __pos, + __value, + ) => ::peg::RuleResult::Matched( + __pos, __value, + ), ::peg::RuleResult::Failed => { - ::peg::RuleResult::Failed + match __parse_rust_ty_path( + __input, + __state, + __err_state, + __pos, + ) { + ::peg::RuleResult::Matched( + pos, + _, + ) => ::peg::RuleResult::Matched( + pos, + (), + ), + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed + } + } } } } @@ -1456,7 +1564,8 @@ pub mod peg { } } } - } + }; + __rule_result } } fn __parse_rust_ty_path<'input>( @@ -1467,152 +1576,116 @@ pub mod peg { ) -> ::peg::RuleResult<()> { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let __seq_res = - match match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "::") { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, __val) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"::\""); - ::peg::RuleResult::Failed - } - } { - ::peg::RuleResult::Matched(__newpos, _) => { - ::peg::RuleResult::Matched(__newpos, ()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, ()), - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, _) => { - let __seq_res = { - let mut __repeat_pos = __pos; - let mut __repeat_value = vec![]; - loop { - let __pos = __repeat_pos; - let __pos = if __repeat_value.is_empty() { - __pos - } else { - let __sep_res = match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "::", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, __val) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"::\""); - ::peg::RuleResult::Failed - } - }; - match __sep_res { - ::peg::RuleResult::Matched(__newpos, _) => __newpos, - ::peg::RuleResult::Failed => break, - } - }; - let __step_res = { - let __seq_res = - match __parse_IDENT(__input, __state, __err_state, __pos) { - ::peg::RuleResult::Matched(pos, _) => { - ::peg::RuleResult::Matched(pos, ()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, _) => { - let __seq_res = match { - let __seq_res = match match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "::") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"::\"") ; :: peg :: RuleResult :: Failed } } { :: peg :: RuleResult :: Matched (__newpos , _) => { :: peg :: RuleResult :: Matched (__newpos , ()) } , :: peg :: RuleResult :: Failed => { :: peg :: RuleResult :: Matched (__pos , ()) } , } ; - match __seq_res { - ::peg::RuleResult::Matched(__pos, _) => { - match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "<", - ) { - ::peg::RuleResult::Matched( - __pos, - __val, - ) => { - let __seq_res = { - let mut __repeat_pos = __pos; - let mut __repeat_value = vec![]; - loop { - let __pos = __repeat_pos; - let __pos = if __repeat_value - .is_empty() - { - __pos - } else { - let __sep_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ",") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\",\"") ; :: peg :: RuleResult :: Failed } } ; - match __sep_res { :: peg :: RuleResult :: Matched (__newpos , _) => { __newpos } , :: peg :: RuleResult :: Failed => break , } - }; - let __step_res = { - let __choice_res = match __parse_LIFETIME (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; - match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => { let __choice_res = match __parse_rust_type (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => { let __choice_res = match __parse_BRACE_GROUP (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => match __parse_LITERAL (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } } } } - }; - match __step_res { :: peg :: RuleResult :: Matched (__newpos , __value) => { __repeat_pos = __newpos ; __repeat_value . push (__value) ; } , :: peg :: RuleResult :: Failed => { break ; } } - } - if __repeat_value.len() >= 1 { - ::peg::RuleResult::Matched( - __repeat_pos, - (), - ) - } else { - ::peg::RuleResult::Failed - } - }; - match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ">") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\">\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } - } - ::peg::RuleResult::Failed => { - __err_state - .mark_failure(__pos, "\"<\""); - ::peg::RuleResult::Failed - } - } + let __rule_result: ::peg::RuleResult<()> = { + { + let __seq_res = + match match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "::") + { + ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched(__pos, __val) + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"::\""); + ::peg::RuleResult::Failed + } + } { + ::peg::RuleResult::Matched(__newpos, _) => { + ::peg::RuleResult::Matched(__newpos, ()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, ()), + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, _) => { + let __seq_res = { + let mut __repeat_pos = __pos; + let mut __repeat_value = vec![]; + loop { + let __pos = __repeat_pos; + let __pos = if __repeat_value.is_empty() { + __pos + } else { + let __sep_res = + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, "::", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched(__pos, __val) } ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"::\""); ::peg::RuleResult::Failed } + }; + match __sep_res { + ::peg::RuleResult::Matched(__newpos, _) => __newpos, + ::peg::RuleResult::Failed => break, + } + }; + let __step_res = { + let __seq_res = match __parse_IDENT( + __input, + __state, + __err_state, + __pos, + ) { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) } - } { - ::peg::RuleResult::Matched(__newpos, _) => { - ::peg::RuleResult::Matched(__newpos, ()) - } - ::peg::RuleResult::Failed => { - ::peg::RuleResult::Matched(__pos, ()) - } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, }; match __seq_res { ::peg::RuleResult::Matched(__pos, _) => { - ::peg::RuleResult::Matched(__pos, ()) + let __seq_res = match { + let __seq_res = match match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "::") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"::\"") ; :: peg :: RuleResult :: Failed } } { :: peg :: RuleResult :: Matched (__newpos , _) => { :: peg :: RuleResult :: Matched (__newpos , ()) } , :: peg :: RuleResult :: Failed => { :: peg :: RuleResult :: Matched (__pos , ()) } , } ; + match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "<") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = { let mut __repeat_pos = __pos ; let mut __repeat_value = vec ! () ; loop { let __pos = __repeat_pos ; let __pos = if __repeat_value . is_empty () { __pos } else { let __sep_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ",") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\",\"") ; :: peg :: RuleResult :: Failed } } ; match __sep_res { :: peg :: RuleResult :: Matched (__newpos , _) => { __newpos } , :: peg :: RuleResult :: Failed => break , } } ; let __step_res = { let __choice_res = match __parse_LIFETIME (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => { let __choice_res = match __parse_rust_type (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => { let __choice_res = match __parse_BRACE_GROUP (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => match __parse_LITERAL (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } } } } } ; match __step_res { :: peg :: RuleResult :: Matched (__newpos , __value) => { __repeat_pos = __newpos ; __repeat_value . push (__value) ; } , :: peg :: RuleResult :: Failed => { break ; } } } if __repeat_value . len () >= 1 { :: peg :: RuleResult :: Matched (__repeat_pos , ()) } else { :: peg :: RuleResult :: Failed } } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ">") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\">\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"<\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } + } { + ::peg::RuleResult::Matched(__newpos, _) => { + ::peg::RuleResult::Matched(__newpos, ()) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Matched(__pos, ()) + } + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, _) => { + ::peg::RuleResult::Matched(__pos, ()) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed + } + } } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } + }; + match __step_res { + ::peg::RuleResult::Matched(__newpos, __value) => { + __repeat_pos = __newpos; + __repeat_value.push(__value); + } + ::peg::RuleResult::Failed => { + break; + } } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } - }; - match __step_res { - ::peg::RuleResult::Matched(__newpos, __value) => { - __repeat_pos = __newpos; - __repeat_value.push(__value); + if __repeat_value.len() >= 1 { + ::peg::RuleResult::Matched(__repeat_pos, ()) + } else { + ::peg::RuleResult::Failed } - ::peg::RuleResult::Failed => { - break; + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, _) => { + ::peg::RuleResult::Matched(__pos, ()) } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } - if __repeat_value.len() >= 1 { - ::peg::RuleResult::Matched(__repeat_pos, ()) - } else { - ::peg::RuleResult::Failed - } - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, _) => { - ::peg::RuleResult::Matched(__pos, ()) - } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } + }; + __rule_result } } fn __parse_rust_ty_params<'input>( @@ -1622,91 +1695,97 @@ pub mod peg { __pos: usize, ) -> ::peg::RuleResult> { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "<") { - ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = { - let mut __repeat_pos = __pos; - let mut __repeat_value = vec![]; - loop { - let __pos = __repeat_pos; - let __pos = if __repeat_value.is_empty() { - __pos - } else { - let __sep_res = match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, ",", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, __val) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\",\""); - ::peg::RuleResult::Failed + { + let __rule_result: ::peg::RuleResult> = { + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "<") { + ::peg::RuleResult::Matched(__pos, __val) => { + let __seq_res = { + let mut __repeat_pos = __pos; + let mut __repeat_value = vec![]; + loop { + let __pos = __repeat_pos; + let __pos = if __repeat_value.is_empty() { + __pos + } else { + let __sep_res = match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, ",", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched(__pos, __val) + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\",\""); + ::peg::RuleResult::Failed + } + }; + match __sep_res { + ::peg::RuleResult::Matched(__newpos, _) => __newpos, + ::peg::RuleResult::Failed => break, + } + }; + let __step_res = { + let str_start = __pos; + match match __parse_rust_generic_param( + __input, + __state, + __err_state, + __pos, + ) { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } { + ::peg::RuleResult::Matched(__newpos, _) => { + ::peg::RuleResult::Matched( + __newpos, + ::peg::ParseSlice::parse_slice( + __input, str_start, __newpos, + ), + ) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + }; + match __step_res { + ::peg::RuleResult::Matched(__newpos, __value) => { + __repeat_pos = __newpos; + __repeat_value.push(__value); + } + ::peg::RuleResult::Failed => { + break; + } } - }; - match __sep_res { - ::peg::RuleResult::Matched(__newpos, _) => __newpos, - ::peg::RuleResult::Failed => break, } - }; - let __step_res = { - let str_start = __pos; - match match __parse_rust_generic_param( - __input, - __state, - __err_state, - __pos, - ) { - ::peg::RuleResult::Matched(pos, _) => { - ::peg::RuleResult::Matched(pos, ()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } { - ::peg::RuleResult::Matched(__newpos, _) => { - ::peg::RuleResult::Matched( - __newpos, - ::peg::ParseSlice::parse_slice( - __input, str_start, __newpos, - ), - ) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + if __repeat_value.len() >= 1 { + ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) + } else { + ::peg::RuleResult::Failed } }; - match __step_res { - ::peg::RuleResult::Matched(__newpos, __value) => { - __repeat_pos = __newpos; - __repeat_value.push(__value); - } - ::peg::RuleResult::Failed => { - break; + match __seq_res { + ::peg::RuleResult::Matched(__pos, p) => { + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, ">") + { + ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched(__pos, (|| p)()) + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\">\""); + ::peg::RuleResult::Failed + } + } } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } - if __repeat_value.len() >= 1 { - ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) - } else { + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"<\""); ::peg::RuleResult::Failed } - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, p) => { - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, ">") { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, (|| p)()) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\">\""); - ::peg::RuleResult::Failed - } - } - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"<\""); - ::peg::RuleResult::Failed - } + }; + __rule_result } } fn __parse_rust_generic_param<'input>( @@ -1717,69 +1796,93 @@ pub mod peg { ) -> ::peg::RuleResult<()> { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let __choice_res = { - let __seq_res = match __parse_LIFETIME(__input, __state, __err_state, __pos) { - ::peg::RuleResult::Matched(pos, _) => ::peg::RuleResult::Matched(pos, ()), - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, _) => { - let __seq_res = match match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, ":", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = { - let mut __repeat_pos = __pos; - let mut __repeat_value = vec![]; - loop { - let __pos = __repeat_pos; - let __pos = if __repeat_value.is_empty() { - __pos - } else { - let __sep_res = - match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "+", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, __val) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"+\""); - ::peg::RuleResult::Failed + let __rule_result: ::peg::RuleResult<()> = { + { + let __choice_res = { + let __seq_res = match __parse_LIFETIME(__input, __state, __err_state, __pos) + { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, _) => { + let __seq_res = + match match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, ":", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + let __seq_res = { + let mut __repeat_pos = __pos; + let mut __repeat_value = vec![]; + loop { + let __pos = __repeat_pos; + let __pos = if __repeat_value.is_empty() { + __pos + } else { + let __sep_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "+") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"+\"") ; :: peg :: RuleResult :: Failed } } ; + match __sep_res { + ::peg::RuleResult::Matched( + __newpos, + _, + ) => __newpos, + ::peg::RuleResult::Failed => break, + } + }; + let __step_res = match __parse_LIFETIME( + __input, + __state, + __err_state, + __pos, + ) { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed + } + }; + match __step_res { + ::peg::RuleResult::Matched( + __newpos, + __value, + ) => { + __repeat_pos = __newpos; + __repeat_value.push(__value); + } + ::peg::RuleResult::Failed => { + break; + } } - }; - match __sep_res { - ::peg::RuleResult::Matched(__newpos, _) => __newpos, - ::peg::RuleResult::Failed => break, - } - }; - let __step_res = match __parse_LIFETIME( - __input, - __state, - __err_state, - __pos, - ) { - ::peg::RuleResult::Matched(pos, _) => { - ::peg::RuleResult::Matched(pos, ()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - }; - match __step_res { - ::peg::RuleResult::Matched(__newpos, __value) => { - __repeat_pos = __newpos; - __repeat_value.push(__value); - } - ::peg::RuleResult::Failed => { - break; + } + if __repeat_value.len() >= 1 { + ::peg::RuleResult::Matched(__repeat_pos, ()) + } else { + ::peg::RuleResult::Failed + } + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, _) => { + ::peg::RuleResult::Matched(__pos, ()) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed + } } } - } - if __repeat_value.len() >= 1 { - ::peg::RuleResult::Matched(__repeat_pos, ()) - } else { - ::peg::RuleResult::Failed - } - }; + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\":\""); + ::peg::RuleResult::Failed + } + } { + ::peg::RuleResult::Matched(__newpos, _) => { + ::peg::RuleResult::Matched(__newpos, ()) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Matched(__pos, ()) + } + }; match __seq_res { ::peg::RuleResult::Matched(__pos, _) => { ::peg::RuleResult::Matched(__pos, ()) @@ -1787,136 +1890,119 @@ pub mod peg { ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\":\""); - ::peg::RuleResult::Failed - } - } { - ::peg::RuleResult::Matched(__newpos, _) => { - ::peg::RuleResult::Matched(__newpos, ()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, ()), - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, _) => { - ::peg::RuleResult::Matched(__pos, ()) - } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } - }; - match __choice_res { - ::peg::RuleResult::Matched(__pos, __value) => { - ::peg::RuleResult::Matched(__pos, __value) - } - ::peg::RuleResult::Failed => { - let __seq_res = match __parse_IDENT(__input, __state, __err_state, __pos) { - ::peg::RuleResult::Matched(pos, _) => ::peg::RuleResult::Matched(pos, ()), - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, _) => { - let __seq_res = match match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, ":", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = { - let mut __repeat_pos = __pos; - let mut __repeat_value = vec![]; - loop { - let __pos = __repeat_pos; - let __pos = if __repeat_value.is_empty() { - __pos - } else { - let __sep_res = - match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "+", - ) { - ::peg::RuleResult::Matched( - __pos, - __val, - ) => { - ::peg::RuleResult::Matched(__pos, __val) - } - ::peg::RuleResult::Failed => { - __err_state - .mark_failure(__pos, "\"+\""); - ::peg::RuleResult::Failed - } - }; - match __sep_res { - ::peg::RuleResult::Matched(__newpos, _) => { - __newpos - } - ::peg::RuleResult::Failed => break, - } - }; - let __step_res = { - let __choice_res = match __parse_LIFETIME( - __input, - __state, - __err_state, - __pos, - ) { - ::peg::RuleResult::Matched(pos, _) => { - ::peg::RuleResult::Matched(pos, ()) - } - ::peg::RuleResult::Failed => { - ::peg::RuleResult::Failed - } - }; - match __choice_res { - ::peg::RuleResult::Matched(__pos, __value) => { - ::peg::RuleResult::Matched(__pos, __value) - } - ::peg::RuleResult::Failed => { - let __seq_res = match match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "?") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"?\"") ; :: peg :: RuleResult :: Failed } } { :: peg :: RuleResult :: Matched (__newpos , _) => { :: peg :: RuleResult :: Matched (__newpos , ()) } , :: peg :: RuleResult :: Failed => { :: peg :: RuleResult :: Matched (__pos , ()) } , } ; - match __seq_res { - ::peg::RuleResult::Matched( - __pos, - _, - ) => { - let __seq_res = match __parse_rust_ty_path (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; - match __seq_res { + match __choice_res { + ::peg::RuleResult::Matched(__pos, __value) => { + ::peg::RuleResult::Matched(__pos, __value) + } + ::peg::RuleResult::Failed => { + let __seq_res = + match __parse_IDENT(__input, __state, __err_state, __pos) { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, _) => { + let __seq_res = + match match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, ":", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + let __seq_res = { + let mut __repeat_pos = __pos; + let mut __repeat_value = vec![]; + loop { + let __pos = __repeat_pos; + let __pos = if __repeat_value.is_empty() { + __pos + } else { + let __sep_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "+") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"+\"") ; :: peg :: RuleResult :: Failed } } ; + match __sep_res { + ::peg::RuleResult::Matched( + __newpos, + _, + ) => __newpos, + ::peg::RuleResult::Failed => break, + } + }; + let __step_res = { + let __choice_res = + match __parse_LIFETIME( + __input, + __state, + __err_state, + __pos, + ) { ::peg::RuleResult::Matched( - __pos, + pos, _, ) => { ::peg::RuleResult::Matched( - __pos, + pos, (), ) } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } + }; + match __choice_res { + ::peg::RuleResult::Matched( + __pos, + __value, + ) => ::peg::RuleResult::Matched( + __pos, __value, + ), + ::peg::RuleResult::Failed => { + let __seq_res = match match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "?") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"?\"") ; :: peg :: RuleResult :: Failed } } { :: peg :: RuleResult :: Matched (__newpos , _) => { :: peg :: RuleResult :: Matched (__newpos , ()) } , :: peg :: RuleResult :: Failed => { :: peg :: RuleResult :: Matched (__pos , ()) } , } ; + match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { { let __seq_res = match __parse_rust_ty_path (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } + }; + match __step_res { + ::peg::RuleResult::Matched( + __newpos, + __value, + ) => { + __repeat_pos = __newpos; + __repeat_value.push(__value); + } ::peg::RuleResult::Failed => { - ::peg::RuleResult::Failed + break; } } } - } - }; - match __step_res { - ::peg::RuleResult::Matched(__newpos, __value) => { - __repeat_pos = __newpos; - __repeat_value.push(__value); - } - ::peg::RuleResult::Failed => { - break; + if __repeat_value.len() >= 1 { + ::peg::RuleResult::Matched(__repeat_pos, ()) + } else { + ::peg::RuleResult::Failed + } + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, _) => { + ::peg::RuleResult::Matched(__pos, ()) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed + } } } - } - if __repeat_value.len() >= 1 { - ::peg::RuleResult::Matched(__repeat_pos, ()) - } else { - ::peg::RuleResult::Failed - } - }; + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\":\""); + ::peg::RuleResult::Failed + } + } { + ::peg::RuleResult::Matched(__newpos, _) => { + ::peg::RuleResult::Matched(__newpos, ()) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Matched(__pos, ()) + } + }; match __seq_res { ::peg::RuleResult::Matched(__pos, _) => { ::peg::RuleResult::Matched(__pos, ()) @@ -1924,27 +2010,13 @@ pub mod peg { ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\":\""); - ::peg::RuleResult::Failed - } - } { - ::peg::RuleResult::Matched(__newpos, _) => { - ::peg::RuleResult::Matched(__newpos, ()) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, ()), - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, _) => { - ::peg::RuleResult::Matched(__pos, ()) - } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } - } + }; + __rule_result } } fn __parse_expression<'input>( @@ -1952,81 +2024,15 @@ pub mod peg { __state: &mut ParseState<'input>, __err_state: &mut ::peg::error::ErrorState, __pos: usize, - ) -> ::peg::RuleResult { - #![allow(non_snake_case, unused, clippy::redundant_closure_call)] - __parse_choice(__input, __state, __err_state, __pos) - } - fn __parse_choice<'input>( - __input: &'input Input, - __state: &mut ParseState<'input>, - __err_state: &mut ::peg::error::ErrorState, - __pos: usize, ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let __seq_res = __parse_sp(__input, __state, __err_state, __pos); - match __seq_res { - ::peg::RuleResult::Matched(__pos, sp) => { - let __seq_res = { - let mut __repeat_pos = __pos; - let mut __repeat_value = vec![]; - loop { - let __pos = __repeat_pos; - let __pos = if __repeat_value.is_empty() { - __pos - } else { - let __sep_res = match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "/", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, __val) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"/\""); - ::peg::RuleResult::Failed - } - }; - match __sep_res { - ::peg::RuleResult::Matched(__newpos, _) => __newpos, - ::peg::RuleResult::Failed => break, - } - }; - let __step_res = __parse_sequence(__input, __state, __err_state, __pos); - match __step_res { - ::peg::RuleResult::Matched(__newpos, __value) => { - __repeat_pos = __newpos; - __repeat_value.push(__value); - } - ::peg::RuleResult::Failed => { - break; - } - } - } - if __repeat_value.len() >= 1 { - ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) - } else { - ::peg::RuleResult::Failed - } - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, s) => ::peg::RuleResult::Matched( - __pos, - (|| { - if s.len() == 1 { - s.into_iter().next().unwrap() - } else { - ChoiceExpr(s).at(sp) - } - })(), - ), - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } + let __rule_result: ::peg::RuleResult = + { __parse_choice(__input, __state, __err_state, __pos) }; + __rule_result } } - fn __parse_sequence<'input>( + fn __parse_choice<'input>( __input: &'input Input, __state: &mut ParseState<'input>, __err_state: &mut ::peg::error::ErrorState, @@ -2034,153 +2040,217 @@ pub mod peg { ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let __seq_res = __parse_sp(__input, __state, __err_state, __pos); - match __seq_res { - ::peg::RuleResult::Matched(__pos, sp) => { - let __seq_res = { - let mut __repeat_pos = __pos; - let mut __repeat_value = vec![]; - loop { - let __pos = __repeat_pos; - let __step_res = __parse_labeled(__input, __state, __err_state, __pos); - match __step_res { - ::peg::RuleResult::Matched(__newpos, __value) => { - __repeat_pos = __newpos; - __repeat_value.push(__value); - } - ::peg::RuleResult::Failed => { - break; - } - } - } - ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) - }; + let __rule_result: ::peg::RuleResult = { + { + let __seq_res = __parse_sp(__input, __state, __err_state, __pos); match __seq_res { - ::peg::RuleResult::Matched(__pos, elements) => { - let __seq_res = - match __parse_BRACE_GROUP(__input, __state, __err_state, __pos) { - ::peg::RuleResult::Matched(__newpos, __value) => { - ::peg::RuleResult::Matched(__newpos, Some(__value)) - } - ::peg::RuleResult::Failed => { - ::peg::RuleResult::Matched(__pos, None) + ::peg::RuleResult::Matched(__pos, sp) => { + let __seq_res = { + let mut __repeat_pos = __pos; + let mut __repeat_value = vec![]; + loop { + let __pos = __repeat_pos; + let __pos = if __repeat_value.is_empty() { + __pos + } else { + let __sep_res = + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, "/", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched(__pos, __val) + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"/\""); + ::peg::RuleResult::Failed + } + }; + match __sep_res { + ::peg::RuleResult::Matched(__newpos, _) => __newpos, + ::peg::RuleResult::Failed => break, + } + }; + let __step_res = + __parse_sequence(__input, __state, __err_state, __pos); + match __step_res { + ::peg::RuleResult::Matched(__newpos, __value) => { + __repeat_pos = __newpos; + __repeat_value.push(__value); + } + ::peg::RuleResult::Failed => { + break; + } } - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, code) => { - ::peg::RuleResult::Matched( - __pos, - (|| { - if let Some(code) = code { - ActionExpr(elements, Some(code)).at(sp) - } else if elements.len() != 1 { - ActionExpr(elements, None).at(sp) - } else { - elements.into_iter().next().unwrap().expr - } - })(), - ) } + if __repeat_value.len() >= 1 { + ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) + } else { + ::peg::RuleResult::Failed + } + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, s) => ::peg::RuleResult::Matched( + __pos, + (|| { + if s.len() == 1 { + s.into_iter().next().unwrap() + } else { + ChoiceExpr(s).at(sp) + } + })(), + ), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } + }; + __rule_result } } - fn __parse_labeled<'input>( + fn __parse_sequence<'input>( __input: &'input Input, __state: &mut ParseState<'input>, __err_state: &mut ::peg::error::ErrorState, __pos: usize, - ) -> ::peg::RuleResult { + ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let __seq_res = match { - let __seq_res = __parse_IDENT(__input, __state, __err_state, __pos); - match __seq_res { - ::peg::RuleResult::Matched(__pos, l) => { - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, ":") { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, (|| l)()) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\":\""); - ::peg::RuleResult::Failed - } - } - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } - } { - ::peg::RuleResult::Matched(__newpos, __value) => { - ::peg::RuleResult::Matched(__newpos, Some(__value)) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, None), - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, label) => { - let __seq_res = __parse_suffixed(__input, __state, __err_state, __pos); + let __rule_result: ::peg::RuleResult = { + { + let __seq_res = __parse_sp(__input, __state, __err_state, __pos); match __seq_res { - ::peg::RuleResult::Matched(__pos, expression) => { - ::peg::RuleResult::Matched( - __pos, - (|| TaggedExpr { - name: label, - expr: expression, - })(), - ) + ::peg::RuleResult::Matched(__pos, sp) => { + let __seq_res = { + let mut __repeat_pos = __pos; + let mut __repeat_value = vec![]; + loop { + let __pos = __repeat_pos; + let __step_res = + __parse_labeled(__input, __state, __err_state, __pos); + match __step_res { + ::peg::RuleResult::Matched(__newpos, __value) => { + __repeat_pos = __newpos; + __repeat_value.push(__value); + } + ::peg::RuleResult::Failed => { + break; + } + } + } + ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, elements) => { + let __seq_res = match __parse_BRACE_GROUP( + __input, + __state, + __err_state, + __pos, + ) { + ::peg::RuleResult::Matched(__newpos, __value) => { + ::peg::RuleResult::Matched(__newpos, Some(__value)) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Matched(__pos, None) + } + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, code) => { + ::peg::RuleResult::Matched( + __pos, + (|| { + if let Some(code) = code { + ActionExpr(elements, Some(code)).at(sp) + } else if elements.len() != 1 { + ActionExpr(elements, None).at(sp) + } else { + elements.into_iter().next().unwrap().expr + } + })( + ), + ) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } + }; + __rule_result } } - fn __parse_suffixed<'input>( + fn __parse_labeled<'input>( __input: &'input Input, __state: &mut ParseState<'input>, __err_state: &mut ::peg::error::ErrorState, __pos: usize, - ) -> ::peg::RuleResult { + ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let __choice_res = { - let __seq_res = __parse_prefixed(__input, __state, __err_state, __pos); - match __seq_res { - ::peg::RuleResult::Matched(__pos, e) => { - let __seq_res = __parse_sp(__input, __state, __err_state, __pos); + let __rule_result: ::peg::RuleResult = { + { + let __seq_res = match { + let __seq_res = __parse_IDENT(__input, __state, __err_state, __pos); match __seq_res { - ::peg::RuleResult::Matched(__pos, sp) => { - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "?") + ::peg::RuleResult::Matched(__pos, l) => { + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, ":") { ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched( - __pos, - (|| OptionalExpr(Box::new(e)).at(sp))(), - ) + ::peg::RuleResult::Matched(__pos, (|| l)()) } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"?\""); + __err_state.mark_failure(__pos, "\":\""); ::peg::RuleResult::Failed } } } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } + } { + ::peg::RuleResult::Matched(__newpos, __value) => { + ::peg::RuleResult::Matched(__newpos, Some(__value)) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, None), + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, label) => { + let __seq_res = __parse_suffixed(__input, __state, __err_state, __pos); + match __seq_res { + ::peg::RuleResult::Matched(__pos, expression) => { + ::peg::RuleResult::Matched( + __pos, + (|| TaggedExpr { + name: label, + expr: expression, + })(), + ) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } }; - match __choice_res { - ::peg::RuleResult::Matched(__pos, __value) => { - ::peg::RuleResult::Matched(__pos, __value) - } - ::peg::RuleResult::Failed => { + __rule_result + } + } + fn __parse_suffixed<'input>( + __input: &'input Input, + __state: &mut ParseState<'input>, + __err_state: &mut ::peg::error::ErrorState, + __pos: usize, + ) -> ::peg::RuleResult { + #![allow(non_snake_case, unused, clippy::redundant_closure_call)] + { + let __rule_result: ::peg::RuleResult = { + { let __choice_res = { let __seq_res = __parse_prefixed(__input, __state, __err_state, __pos); match __seq_res { @@ -2189,51 +2259,16 @@ pub mod peg { match __seq_res { ::peg::RuleResult::Matched(__pos, sp) => { match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "**", + __input, __pos, "?", ) { ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = __parse_repeatcount( - __input, - __state, - __err_state, + ::peg::RuleResult::Matched( __pos, - ); - match __seq_res { - ::peg::RuleResult::Matched(__pos, count) => { - let __seq_res = __parse_primary( - __input, - __state, - __err_state, - __pos, - ); - match __seq_res { - ::peg::RuleResult::Matched( - __pos, - sep, - ) => ::peg::RuleResult::Matched( - __pos, - (|| { - Repeat { - inner: Box::new(e), - bound: count, - sep: Some(Box::new(sep)), - } - .at(sp) - })( - ), - ), - ::peg::RuleResult::Failed => { - ::peg::RuleResult::Failed - } - } - } - ::peg::RuleResult::Failed => { - ::peg::RuleResult::Failed - } - } + (|| OptionalExpr(Box::new(e)).at(sp))(), + ) } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"**\""); + __err_state.mark_failure(__pos, "\"?\""); ::peg::RuleResult::Failed } } @@ -2259,10 +2294,10 @@ pub mod peg { match __seq_res { ::peg::RuleResult::Matched(__pos, sp) => { match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "++", + __input, __pos, "**", ) { ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = __parse_primary( + let __seq_res = __parse_repeatcount( __input, __state, __err_state, @@ -2271,26 +2306,50 @@ pub mod peg { match __seq_res { ::peg::RuleResult::Matched( __pos, - sep, - ) => ::peg::RuleResult::Matched( - __pos, - (|| { - Repeat { - inner: Box::new(e), - bound: BoundedRepeat::Plus, - sep: Some(Box::new(sep)), + count, + ) => { + let __seq_res = __parse_primary( + __input, + __state, + __err_state, + __pos, + ); + match __seq_res { + ::peg::RuleResult::Matched( + __pos, + sep, + ) => { + ::peg::RuleResult::Matched( + __pos, + (|| { + Repeat { + inner: Box::new( + e, + ), + bound: count, + sep: Some( + Box::new( + sep, + ), + ), + } + .at(sp) + })( + ), + ) } - .at(sp) - })( - ), - ), + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed + } + } + } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } } } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"++\""); + __err_state.mark_failure(__pos, "\"**\""); ::peg::RuleResult::Failed } } @@ -2317,7 +2376,7 @@ pub mod peg { __err_state, __pos, ); - match __seq_res { :: peg :: RuleResult :: Matched (__pos , sp) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "*") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = __parse_repeatcount (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , count) => { :: peg :: RuleResult :: Matched (__pos , (|| { Repeat { inner : Box :: new (e) , bound : count , sep : None } . at (sp) }) ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"*\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } + match __seq_res { :: peg :: RuleResult :: Matched (__pos , sp) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "++") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = __parse_primary (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , sep) => { :: peg :: RuleResult :: Matched (__pos , (|| { Repeat { inner : Box :: new (e) , bound : BoundedRepeat :: Plus , sep : Some (Box :: new (sep)) } . at (sp) }) ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"++\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } @@ -2342,7 +2401,7 @@ pub mod peg { __err_state, __pos, ); - match __seq_res { :: peg :: RuleResult :: Matched (__pos , sp) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "+") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { Repeat { inner : Box :: new (e) , bound : BoundedRepeat :: Plus , sep : None } . at (sp) }) ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"+\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } + match __seq_res { :: peg :: RuleResult :: Matched (__pos , sp) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "*") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = __parse_repeatcount (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , count) => { :: peg :: RuleResult :: Matched (__pos , (|| { Repeat { inner : Box :: new (e) , bound : count , sep : None } . at (sp) }) ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"*\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed @@ -2353,12 +2412,49 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } - ::peg::RuleResult::Failed => __parse_prefixed( - __input, - __state, - __err_state, - __pos, - ), + ::peg::RuleResult::Failed => { + let __choice_res = { + let __seq_res = __parse_prefixed( + __input, + __state, + __err_state, + __pos, + ); + match __seq_res { + ::peg::RuleResult::Matched( + __pos, + e, + ) => { + let __seq_res = __parse_sp( + __input, + __state, + __err_state, + __pos, + ); + match __seq_res { :: peg :: RuleResult :: Matched (__pos , sp) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "+") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { Repeat { inner : Box :: new (e) , bound : BoundedRepeat :: Plus , sep : None } . at (sp) }) ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"+\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed + } + } + }; + match __choice_res { + ::peg::RuleResult::Matched( + __pos, + __value, + ) => ::peg::RuleResult::Matched( + __pos, __value, + ), + ::peg::RuleResult::Failed => { + __parse_prefixed( + __input, + __state, + __err_state, + __pos, + ) + } + } + } } } } @@ -2367,7 +2463,8 @@ pub mod peg { } } } - } + }; + __rule_result } } fn __parse_repeatcount<'input>( @@ -2378,121 +2475,112 @@ pub mod peg { ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let __choice_res = match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "<") - { - ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = __parse_repeatnum(__input, __state, __err_state, __pos); - match __seq_res { - ::peg::RuleResult::Matched(__pos, n) => { - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, ">") { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched( - __pos, - (|| BoundedRepeat::Exact(n))(), - ) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\">\""); - ::peg::RuleResult::Failed - } - } - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"<\""); - ::peg::RuleResult::Failed - } - }; - match __choice_res { - ::peg::RuleResult::Matched(__pos, __value) => { - ::peg::RuleResult::Matched(__pos, __value) - } - ::peg::RuleResult::Failed => { - let __choice_res = match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "<", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = - match __parse_repeatnum(__input, __state, __err_state, __pos) { - ::peg::RuleResult::Matched(__newpos, __value) => { - ::peg::RuleResult::Matched(__newpos, Some(__value)) - } - ::peg::RuleResult::Failed => { - ::peg::RuleResult::Matched(__pos, None) + let __rule_result: ::peg::RuleResult = { + { + let __choice_res = + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "<") { + ::peg::RuleResult::Matched(__pos, __val) => { + let __seq_res = + __parse_repeatnum(__input, __state, __err_state, __pos); + match __seq_res { + ::peg::RuleResult::Matched(__pos, n) => { + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, ">", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched( + __pos, + (|| BoundedRepeat::Exact(n))(), + ) + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\">\""); + ::peg::RuleResult::Failed + } + } } - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, min) => { - match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, ",", + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"<\""); + ::peg::RuleResult::Failed + } + }; + match __choice_res { + ::peg::RuleResult::Matched(__pos, __value) => { + ::peg::RuleResult::Matched(__pos, __value) + } + ::peg::RuleResult::Failed => { + let __choice_res = match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, "<", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + let __seq_res = match __parse_repeatnum( + __input, + __state, + __err_state, + __pos, ) { - ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = match __parse_repeatnum( - __input, - __state, - __err_state, - __pos, + ::peg::RuleResult::Matched(__newpos, __value) => { + ::peg::RuleResult::Matched(__newpos, Some(__value)) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Matched(__pos, None) + } + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, min) => { + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, ",", ) { - ::peg::RuleResult::Matched(__newpos, __value) => { - ::peg::RuleResult::Matched( - __newpos, - Some(__value), - ) - } - ::peg::RuleResult::Failed => { - ::peg::RuleResult::Matched(__pos, None) - } - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, max) => { - match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, ">", + ::peg::RuleResult::Matched(__pos, __val) => { + let __seq_res = match __parse_repeatnum( + __input, + __state, + __err_state, + __pos, ) { ::peg::RuleResult::Matched( - __pos, - __val, + __newpos, + __value, ) => ::peg::RuleResult::Matched( - __pos, - (|| BoundedRepeat::Both(min, max))(), + __newpos, + Some(__value), ), ::peg::RuleResult::Failed => { - __err_state - .mark_failure(__pos, "\">\""); - ::peg::RuleResult::Failed + ::peg::RuleResult::Matched(__pos, None) } - } + }; + match __seq_res { :: peg :: RuleResult :: Matched (__pos , max) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ">") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { BoundedRepeat :: Both (min , max) }) ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\">\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\",\""); ::peg::RuleResult::Failed } } } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\",\""); - ::peg::RuleResult::Failed - } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"<\""); + ::peg::RuleResult::Failed + } + }; + match __choice_res { + ::peg::RuleResult::Matched(__pos, __value) => { + ::peg::RuleResult::Matched(__pos, __value) + } + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Matched(__pos, (|| BoundedRepeat::None)()) + } } } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"<\""); - ::peg::RuleResult::Failed - } - }; - match __choice_res { - ::peg::RuleResult::Matched(__pos, __value) => { - ::peg::RuleResult::Matched(__pos, __value) - } - ::peg::RuleResult::Failed => { - ::peg::RuleResult::Matched(__pos, (|| BoundedRepeat::None)()) - } } } - } + }; + __rule_result } } fn __parse_repeatnum<'input>( @@ -2503,32 +2591,40 @@ pub mod peg { ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let str_start = __pos; - match { - let __choice_res = match __parse_INTEGER(__input, __state, __err_state, __pos) { - ::peg::RuleResult::Matched(pos, _) => ::peg::RuleResult::Matched(pos, ()), - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - }; - match __choice_res { - ::peg::RuleResult::Matched(__pos, __value) => { - ::peg::RuleResult::Matched(__pos, __value) - } - ::peg::RuleResult::Failed => { - match __parse_BRACE_GROUP(__input, __state, __err_state, __pos) { - ::peg::RuleResult::Matched(pos, _) => { - ::peg::RuleResult::Matched(pos, ()) + let __rule_result: ::peg::RuleResult = { + { + let str_start = __pos; + match { + let __choice_res = + match __parse_INTEGER(__input, __state, __err_state, __pos) { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + }; + match __choice_res { + ::peg::RuleResult::Matched(__pos, __value) => { + ::peg::RuleResult::Matched(__pos, __value) + } + ::peg::RuleResult::Failed => { + match __parse_BRACE_GROUP(__input, __state, __err_state, __pos) { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } + } { + ::peg::RuleResult::Matched(__newpos, _) => ::peg::RuleResult::Matched( + __newpos, + ::peg::ParseSlice::parse_slice(__input, str_start, __newpos), + ), + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } - } { - ::peg::RuleResult::Matched(__newpos, _) => ::peg::RuleResult::Matched( - __newpos, - ::peg::ParseSlice::parse_slice(__input, str_start, __newpos), - ), - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } + }; + __rule_result } } fn __parse_prefixed<'input>( @@ -2539,43 +2635,13 @@ pub mod peg { ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let __choice_res = { - let __seq_res = __parse_sp(__input, __state, __err_state, __pos); - match __seq_res { - ::peg::RuleResult::Matched(__pos, sp) => { - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "$") { - ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = - __parse_primary(__input, __state, __err_state, __pos); - match __seq_res { - ::peg::RuleResult::Matched(__pos, expression) => { - ::peg::RuleResult::Matched( - __pos, - (|| MatchStrExpr(Box::new(expression)).at(sp))(), - ) - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"$\""); - ::peg::RuleResult::Failed - } - } - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } - }; - match __choice_res { - ::peg::RuleResult::Matched(__pos, __value) => { - ::peg::RuleResult::Matched(__pos, __value) - } - ::peg::RuleResult::Failed => { + let __rule_result: ::peg::RuleResult = { + { let __choice_res = { let __seq_res = __parse_sp(__input, __state, __err_state, __pos); match __seq_res { ::peg::RuleResult::Matched(__pos, sp) => { - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "&") + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "$") { ::peg::RuleResult::Matched(__pos, __val) => { let __seq_res = @@ -2584,7 +2650,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, expression) => { ::peg::RuleResult::Matched( __pos, - (|| PosAssertExpr(Box::new(expression)).at(sp))( + (|| MatchStrExpr(Box::new(expression)).at(sp))( ), ) } @@ -2592,7 +2658,7 @@ pub mod peg { } } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"&\""); + __err_state.mark_failure(__pos, "\"$\""); ::peg::RuleResult::Failed } } @@ -2610,7 +2676,7 @@ pub mod peg { match __seq_res { ::peg::RuleResult::Matched(__pos, sp) => { match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "!", + __input, __pos, "&", ) { ::peg::RuleResult::Matched(__pos, __val) => { let __seq_res = __parse_primary( @@ -2626,7 +2692,7 @@ pub mod peg { ) => ::peg::RuleResult::Matched( __pos, (|| { - NegAssertExpr(Box::new(expression)) + PosAssertExpr(Box::new(expression)) .at(sp) })( ), @@ -2637,7 +2703,7 @@ pub mod peg { } } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"!\""); + __err_state.mark_failure(__pos, "\"&\""); ::peg::RuleResult::Failed } } @@ -2650,13 +2716,64 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) } ::peg::RuleResult::Failed => { - __parse_primary(__input, __state, __err_state, __pos) + let __choice_res = { + let __seq_res = + __parse_sp(__input, __state, __err_state, __pos); + match __seq_res { + ::peg::RuleResult::Matched(__pos, sp) => { + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, "!", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + let __seq_res = __parse_primary( + __input, + __state, + __err_state, + __pos, + ); + match __seq_res { + ::peg::RuleResult::Matched( + __pos, + expression, + ) => ::peg::RuleResult::Matched( + __pos, + (|| { + NegAssertExpr(Box::new( + expression, + )) + .at(sp) + })( + ), + ), + ::peg::RuleResult::Failed => { + ::peg::RuleResult::Failed + } + } + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"!\""); + ::peg::RuleResult::Failed + } + } + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + }; + match __choice_res { + ::peg::RuleResult::Matched(__pos, __value) => { + ::peg::RuleResult::Matched(__pos, __value) + } + ::peg::RuleResult::Failed => { + __parse_primary(__input, __state, __err_state, __pos) + } + } } } } } } - } + }; + __rule_result } } fn __parse_primary<'input>( @@ -2937,170 +3054,144 @@ pub mod peg { __pos, __value, ), ::peg::RuleResult::Failed => { - let __choice_res = { - let __seq_res = __parse_sp( - __input, - __state, - __err_state, - __pos, - ); - match __seq_res { :: peg :: RuleResult :: Matched (__pos , sp) => { { let __seq_res = __parse_BRACKET_GROUP (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , p) => { :: peg :: RuleResult :: Matched (__pos , (|| { PatternExpr (p) . at (sp) }) ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } - }; - match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => { let __choice_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "(") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = __parse_sp (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , sp) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "@") { :: peg :: RuleResult :: Matched (__pos , __val) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ")") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { MarkerExpr (true) . at (sp) }) ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\")\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"@\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"(\"") ; :: peg :: RuleResult :: Failed } } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => { let __choice_res = { let __seq_res = __parse_sp (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , sp) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "@") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { MarkerExpr (false) . at (sp) }) ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"@\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => { let __choice_res = { let __seq_res = __parse_sp (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , sp) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "##") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = __parse_IDENT (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , method) => { { let __seq_res = __parse_PAREN_GROUP (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , args) => { :: peg :: RuleResult :: Matched (__pos , (|| { MethodExpr (method , args . stream ()) . at (sp) }) ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"##\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "(") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = __parse_expression (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , expression) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ")") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { expression }) ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\")\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"(\"") ; :: peg :: RuleResult :: Failed } } } } } } } } } - } - } - } - } - } - } - } - } - } - } - } - } - } - } - }; - __state.primary_cache.insert(__pos, __rule_result.clone()); - __rule_result - } - fn __parse_rule_arg<'input>( - __input: &'input Input, - __state: &mut ParseState<'input>, - __err_state: &mut ::peg::error::ErrorState, - __pos: usize, - ) -> ::peg::RuleResult { - #![allow(non_snake_case, unused, clippy::redundant_closure_call)] - { - let __choice_res = match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "<") - { - ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = __parse_expression(__input, __state, __err_state, __pos); - match __seq_res { - ::peg::RuleResult::Matched(__pos, e) => { - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, ">") { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, (|| RuleArg::Peg(e))()) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\">\""); - ::peg::RuleResult::Failed - } - } - } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"<\""); - ::peg::RuleResult::Failed - } - }; - match __choice_res { - ::peg::RuleResult::Matched(__pos, __value) => { - ::peg::RuleResult::Matched(__pos, __value) - } - ::peg::RuleResult::Failed => { - let __seq_res = { - let str_start = __pos; - match { - let mut __repeat_pos = __pos; - let mut __repeat_value = vec![]; - loop { - let __pos = __repeat_pos; - let __step_res = __input.eat_until(__pos, ','); - match __step_res { - ::peg::RuleResult::Matched(__newpos, __value) => { - __repeat_pos = __newpos; - __repeat_value.push(__value); - } - ::peg::RuleResult::Failed => { - break; + let __choice_res = { + let __seq_res = __parse_sp( + __input, + __state, + __err_state, + __pos, + ); + match __seq_res { :: peg :: RuleResult :: Matched (__pos , sp) => { { let __seq_res = __parse_BRACKET_GROUP (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , p) => { :: peg :: RuleResult :: Matched (__pos , (|| { PatternExpr (p) . at (sp) }) ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } + }; + match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => { let __choice_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "(") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = __parse_sp (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , sp) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "@") { :: peg :: RuleResult :: Matched (__pos , __val) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ")") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { MarkerExpr (true) . at (sp) }) ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\")\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"@\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"(\"") ; :: peg :: RuleResult :: Failed } } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => { let __choice_res = { let __seq_res = __parse_sp (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , sp) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "@") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { MarkerExpr (false) . at (sp) }) ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"@\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => { let __choice_res = { let __seq_res = __parse_sp (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , sp) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "##") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = __parse_IDENT (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , method) => { { let __seq_res = __parse_PAREN_GROUP (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , args) => { :: peg :: RuleResult :: Matched (__pos , (|| { MethodExpr (method , args . stream ()) . at (sp) }) ()) } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"##\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "(") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = __parse_expression (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , expression) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ")") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { expression }) ()) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\")\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"(\"") ; :: peg :: RuleResult :: Failed } } } } } } } } } + } + } + } + } + } + } + } } } } - if __repeat_value.len() >= 1 { - ::peg::RuleResult::Matched(__repeat_pos, ()) - } else { - ::peg::RuleResult::Failed - } - } { - ::peg::RuleResult::Matched(__newpos, _) => ::peg::RuleResult::Matched( - __newpos, - ::peg::ParseSlice::parse_slice(__input, str_start, __newpos), - ), - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, tt) => { - ::peg::RuleResult::Matched(__pos, (|| RuleArg::Rust(tt))()) } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } } - } + }; + __state.primary_cache.insert(__pos, __rule_result.clone()); + __rule_result } - fn __parse_precedence_level<'input>( + fn __parse_rule_arg<'input>( __input: &'input Input, __state: &mut ParseState<'input>, __err_state: &mut ::peg::error::ErrorState, __pos: usize, - ) -> ::peg::RuleResult { + ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let __seq_res = { - let mut __repeat_pos = __pos; - let mut __repeat_value = vec![]; - loop { - let __pos = __repeat_pos; - let __step_res = __parse_precedence_op(__input, __state, __err_state, __pos); - match __step_res { - ::peg::RuleResult::Matched(__newpos, __value) => { - __repeat_pos = __newpos; - __repeat_value.push(__value); + let __rule_result: ::peg::RuleResult = { + { + let __choice_res = + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "<") { + ::peg::RuleResult::Matched(__pos, __val) => { + let __seq_res = + __parse_expression(__input, __state, __err_state, __pos); + match __seq_res { + ::peg::RuleResult::Matched(__pos, e) => { + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, ">", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched( + __pos, + (|| RuleArg::Peg(e))(), + ) + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\">\""); + ::peg::RuleResult::Failed + } + } + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"<\""); + ::peg::RuleResult::Failed + } + }; + match __choice_res { + ::peg::RuleResult::Matched(__pos, __value) => { + ::peg::RuleResult::Matched(__pos, __value) } ::peg::RuleResult::Failed => { - break; + let __seq_res = { + let str_start = __pos; + match { + let mut __repeat_pos = __pos; + let mut __repeat_value = vec![]; + loop { + let __pos = __repeat_pos; + let __step_res = __input.eat_until(__pos, ','); + match __step_res { + ::peg::RuleResult::Matched(__newpos, __value) => { + __repeat_pos = __newpos; + __repeat_value.push(__value); + } + ::peg::RuleResult::Failed => { + break; + } + } + } + if __repeat_value.len() >= 1 { + ::peg::RuleResult::Matched(__repeat_pos, ()) + } else { + ::peg::RuleResult::Failed + } + } { + ::peg::RuleResult::Matched(__newpos, _) => { + ::peg::RuleResult::Matched( + __newpos, + ::peg::ParseSlice::parse_slice( + __input, str_start, __newpos, + ), + ) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, tt) => { + ::peg::RuleResult::Matched(__pos, (|| RuleArg::Rust(tt))()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } } } } - if __repeat_value.len() >= 1 { - ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) - } else { - ::peg::RuleResult::Failed - } }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, operators) => ::peg::RuleResult::Matched( - __pos, - (|| PrecedenceLevel { - operators: operators, - })(), - ), - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } + __rule_result } } - fn __parse_precedence_op<'input>( + fn __parse_precedence_level<'input>( __input: &'input Input, __state: &mut ParseState<'input>, __err_state: &mut ::peg::error::ErrorState, __pos: usize, - ) -> ::peg::RuleResult { + ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let __seq_res = __parse_sp(__input, __state, __err_state, __pos); - match __seq_res { - ::peg::RuleResult::Matched(__pos, span) => { + let __rule_result: ::peg::RuleResult = { + { let __seq_res = { let mut __repeat_pos = __pos; let mut __repeat_value = vec![]; loop { let __pos = __repeat_pos; - let __step_res = __parse_labeled(__input, __state, __err_state, __pos); + let __step_res = + __parse_precedence_op(__input, __state, __err_state, __pos); match __step_res { ::peg::RuleResult::Matched(__newpos, __value) => { __repeat_pos = __newpos; @@ -3111,22 +3202,76 @@ pub mod peg { } } } - ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) + if __repeat_value.len() >= 1 { + ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) + } else { + ::peg::RuleResult::Failed + } }; match __seq_res { - ::peg::RuleResult::Matched(__pos, elements) => { - let __seq_res = - __parse_BRACE_GROUP(__input, __state, __err_state, __pos); + ::peg::RuleResult::Matched(__pos, operators) => ::peg::RuleResult::Matched( + __pos, + (|| PrecedenceLevel { + operators: operators, + })(), + ), + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + } + }; + __rule_result + } + } + fn __parse_precedence_op<'input>( + __input: &'input Input, + __state: &mut ParseState<'input>, + __err_state: &mut ::peg::error::ErrorState, + __pos: usize, + ) -> ::peg::RuleResult { + #![allow(non_snake_case, unused, clippy::redundant_closure_call)] + { + let __rule_result: ::peg::RuleResult = { + { + let __seq_res = __parse_sp(__input, __state, __err_state, __pos); + match __seq_res { + ::peg::RuleResult::Matched(__pos, span) => { + let __seq_res = { + let mut __repeat_pos = __pos; + let mut __repeat_value = vec![]; + loop { + let __pos = __repeat_pos; + let __step_res = + __parse_labeled(__input, __state, __err_state, __pos); + match __step_res { + ::peg::RuleResult::Matched(__newpos, __value) => { + __repeat_pos = __newpos; + __repeat_value.push(__value); + } + ::peg::RuleResult::Failed => { + break; + } + } + } + ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) + }; match __seq_res { - ::peg::RuleResult::Matched(__pos, action) => { - ::peg::RuleResult::Matched( - __pos, - (|| PrecedenceOperator { - span, - elements, - action, - })(), - ) + ::peg::RuleResult::Matched(__pos, elements) => { + let __seq_res = + __parse_BRACE_GROUP(__input, __state, __err_state, __pos); + match __seq_res { + ::peg::RuleResult::Matched(__pos, action) => { + ::peg::RuleResult::Matched( + __pos, + (|| PrecedenceOperator { + span, + elements, + action, + })( + ), + ) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } @@ -3134,8 +3279,8 @@ pub mod peg { ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } + }; + __rule_result } } fn __parse_sp<'input>( @@ -3145,7 +3290,10 @@ pub mod peg { __pos: usize, ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] - __input.next_span(__pos) + { + let __rule_result: ::peg::RuleResult = { __input.next_span(__pos) }; + __rule_result + } } fn __parse_KEYWORD<'input>( __input: &'input Input, @@ -3155,28 +3303,15 @@ pub mod peg { ) -> ::peg::RuleResult<()> { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let __choice_res = - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "pub") { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, __val) - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"pub\""); - ::peg::RuleResult::Failed - } - }; - match __choice_res { - ::peg::RuleResult::Matched(__pos, __value) => { - ::peg::RuleResult::Matched(__pos, __value) - } - ::peg::RuleResult::Failed => { + let __rule_result: ::peg::RuleResult<()> = { + { let __choice_res = - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "crate") { + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "pub") { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"crate\""); + __err_state.mark_failure(__pos, "\"pub\""); ::peg::RuleResult::Failed } }; @@ -3186,13 +3321,13 @@ pub mod peg { } ::peg::RuleResult::Failed => { let __choice_res = match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "rule", + __input, __pos, "crate", ) { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"rule\""); + __err_state.mark_failure(__pos, "\"crate\""); ::peg::RuleResult::Failed } }; @@ -3203,13 +3338,13 @@ pub mod peg { ::peg::RuleResult::Failed => { let __choice_res = match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "use", + __input, __pos, "rule", ) { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"use\""); + __err_state.mark_failure(__pos, "\"rule\""); ::peg::RuleResult::Failed } }; @@ -3218,15 +3353,38 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) } ::peg::RuleResult::Failed => { - match ::peg::ParseLiteral::parse_string_literal( - __input, __pos, "type", - ) { - ::peg::RuleResult::Matched(__pos, __val) => { - ::peg::RuleResult::Matched(__pos, __val) + let __choice_res = + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, "use", + ) { + ::peg::RuleResult::Matched(__pos, __val) => { + ::peg::RuleResult::Matched(__pos, __val) + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"use\""); + ::peg::RuleResult::Failed + } + }; + match __choice_res { + ::peg::RuleResult::Matched(__pos, __value) => { + ::peg::RuleResult::Matched(__pos, __value) } ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"type\""); - ::peg::RuleResult::Failed + match ::peg::ParseLiteral::parse_string_literal( + __input, __pos, "type", + ) { + ::peg::RuleResult::Matched( + __pos, + __val, + ) => { + ::peg::RuleResult::Matched(__pos, __val) + } + ::peg::RuleResult::Failed => { + __err_state + .mark_failure(__pos, "\"type\""); + ::peg::RuleResult::Failed + } + } } } } @@ -3236,7 +3394,8 @@ pub mod peg { } } } - } + }; + __rule_result } } fn __parse_IDENT<'input>( @@ -3247,30 +3406,38 @@ pub mod peg { ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] { - let __seq_res = { - __err_state.suppress_fail += 1; - let __assert_res = match __parse_KEYWORD(__input, __state, __err_state, __pos) { - ::peg::RuleResult::Matched(pos, _) => ::peg::RuleResult::Matched(pos, ()), - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - }; - __err_state.suppress_fail -= 1; - match __assert_res { - ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, ()), - ::peg::RuleResult::Matched(..) => ::peg::RuleResult::Failed, - } - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, _) => { - let __seq_res = __input.ident(__pos); + let __rule_result: ::peg::RuleResult = { + { + let __seq_res = { + __err_state.suppress_fail += 1; + let __assert_res = + match __parse_KEYWORD(__input, __state, __err_state, __pos) { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + }; + __err_state.suppress_fail -= 1; + match __assert_res { + ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, ()), + ::peg::RuleResult::Matched(..) => ::peg::RuleResult::Failed, + } + }; match __seq_res { - ::peg::RuleResult::Matched(__pos, i) => { - ::peg::RuleResult::Matched(__pos, (|| i)()) + ::peg::RuleResult::Matched(__pos, _) => { + let __seq_res = __input.ident(__pos); + match __seq_res { + ::peg::RuleResult::Matched(__pos, i) => { + ::peg::RuleResult::Matched(__pos, (|| i)()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - } + }; + __rule_result } } fn __parse_LITERAL<'input>( @@ -3280,7 +3447,10 @@ pub mod peg { __pos: usize, ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] - __input.literal(__pos) + { + let __rule_result: ::peg::RuleResult = { __input.literal(__pos) }; + __rule_result + } } fn __parse_PAREN_GROUP<'input>( __input: &'input Input, @@ -3289,7 +3459,11 @@ pub mod peg { __pos: usize, ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] - __input.group(__pos, Delimiter::Parenthesis) + { + let __rule_result: ::peg::RuleResult = + { __input.group(__pos, Delimiter::Parenthesis) }; + __rule_result + } } fn __parse_BRACE_GROUP<'input>( __input: &'input Input, @@ -3298,7 +3472,11 @@ pub mod peg { __pos: usize, ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] - __input.group(__pos, Delimiter::Brace) + { + let __rule_result: ::peg::RuleResult = + { __input.group(__pos, Delimiter::Brace) }; + __rule_result + } } fn __parse_BRACKET_GROUP<'input>( __input: &'input Input, @@ -3307,7 +3485,11 @@ pub mod peg { __pos: usize, ) -> ::peg::RuleResult { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] - __input.group(__pos, Delimiter::Bracket) + { + let __rule_result: ::peg::RuleResult = + { __input.group(__pos, Delimiter::Bracket) }; + __rule_result + } } fn __parse_LIFETIME<'input>( __input: &'input Input, @@ -3316,21 +3498,30 @@ pub mod peg { __pos: usize, ) -> ::peg::RuleResult<()> { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] - match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "'") { - ::peg::RuleResult::Matched(__pos, __val) => { - let __seq_res = match __parse_IDENT(__input, __state, __err_state, __pos) { - ::peg::RuleResult::Matched(pos, _) => ::peg::RuleResult::Matched(pos, ()), - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, - }; - match __seq_res { - ::peg::RuleResult::Matched(__pos, _) => ::peg::RuleResult::Matched(__pos, ()), - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + { + let __rule_result: ::peg::RuleResult<()> = { + match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "'") { + ::peg::RuleResult::Matched(__pos, __val) => { + let __seq_res = match __parse_IDENT(__input, __state, __err_state, __pos) { + ::peg::RuleResult::Matched(pos, _) => { + ::peg::RuleResult::Matched(pos, ()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + }; + match __seq_res { + ::peg::RuleResult::Matched(__pos, _) => { + ::peg::RuleResult::Matched(__pos, ()) + } + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + } + ::peg::RuleResult::Failed => { + __err_state.mark_failure(__pos, "\"'\""); + ::peg::RuleResult::Failed + } } - } - ::peg::RuleResult::Failed => { - __err_state.mark_failure(__pos, "\"'\""); - ::peg::RuleResult::Failed - } + }; + __rule_result } } fn __parse_INTEGER<'input>( @@ -3340,9 +3531,14 @@ pub mod peg { __pos: usize, ) -> ::peg::RuleResult<()> { #![allow(non_snake_case, unused, clippy::redundant_closure_call)] - match __parse_LITERAL(__input, __state, __err_state, __pos) { - ::peg::RuleResult::Matched(pos, _) => ::peg::RuleResult::Matched(pos, ()), - ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + { + let __rule_result: ::peg::RuleResult<()> = { + match __parse_LITERAL(__input, __state, __err_state, __pos) { + ::peg::RuleResult::Matched(pos, _) => ::peg::RuleResult::Matched(pos, ()), + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + } + }; + __rule_result } } } diff --git a/peg-macros/grammar.rustpeg b/peg-macros/grammar.rustpeg index 6d8337e..23f7cf7 100644 --- a/peg-macros/grammar.rustpeg +++ b/peg-macros/grammar.rustpeg @@ -40,6 +40,10 @@ rule peg_rule() -> Rule rule item() -> Item = u:rust_use() { Item::Use(u) } / r:peg_rule() { Item::Rule(r) } + / l:stack_limit() { Item::StackLimit(l) } + +rule stack_limit() -> TokenStream + = "stack_limit" i:$(INTEGER()) ";" { i } rule rust_doc_comment() -> Option = $(("#" "[" "doc" "=" LITERAL() "]")*)? diff --git a/peg-macros/translate.rs b/peg-macros/translate.rs index 1705a40..7cfe0fd 100644 --- a/peg-macros/translate.rs +++ b/peg-macros/translate.rs @@ -43,6 +43,13 @@ fn extra_args_call(grammar: &Grammar) -> TokenStream { quote!(#(#args)*) } +fn stack_limit(grammar: &Grammar) -> Option { + grammar.items.iter().find_map(|it| match it { + Item::StackLimit(lim) => Some(quote!(#lim)), + _ => None, + }) +} + #[derive(Clone)] struct Context<'a> { rules: &'a HashMap, @@ -52,6 +59,7 @@ struct Context<'a> { parse_state_ty: TokenStream, extra_args_call: TokenStream, extra_args_def: TokenStream, + stack_limit: Option, } pub(crate) fn compile_grammar(grammar: &Grammar) -> TokenStream { @@ -67,6 +75,7 @@ pub(crate) fn compile_grammar(grammar: &Grammar) -> TokenStream { parse_state_ty: quote!(&mut ParseState<'input #(, #grammar_lifetime_params)*>), extra_args_call: extra_args_call(grammar), extra_args_def: extra_args_def(grammar), + stack_limit: stack_limit(grammar), }; let mut seen_rule_names = HashSet::new(); @@ -112,10 +121,11 @@ pub(crate) fn compile_grammar(grammar: &Grammar) -> TokenStream { items.push(compile_rule(context, rule)); } + _ => {} } } - let parse_state = make_parse_state(grammar); + let parse_state = make_parse_state(grammar, context); let Grammar { name, doc, @@ -152,7 +162,7 @@ pub(crate) fn compile_grammar(grammar: &Grammar) -> TokenStream { } } -fn make_parse_state(grammar: &Grammar) -> TokenStream { +fn make_parse_state(grammar: &Grammar, context: &Context) -> TokenStream { let span = Span::mixed_site(); let grammar_lifetime_params = ty_params_slice(&grammar.lifetime_params); let mut cache_fields_def: Vec = Vec::new(); @@ -168,18 +178,29 @@ fn make_parse_state(grammar: &Grammar) -> TokenStream { } } + let (stack_size_def, stack_size_init) = if context.stack_limit.is_some() { + ( + Some(quote_spanned! { span => _stack_size: usize, }), + Some(quote_spanned! { span => _stack_size: 0, }), + ) + } else { + (None, None) + }; + quote_spanned! { span => #[allow(unused_parens)] struct ParseState<'input #(, #grammar_lifetime_params)*> { _phantom: ::std::marker::PhantomData<(&'input () #(, &#grammar_lifetime_params ())*)>, - #(#cache_fields_def),* + #(#cache_fields_def,)* + #stack_size_def } impl<'input #(, #grammar_lifetime_params)*> ParseState<'input #(, #grammar_lifetime_params)*> { fn new() -> ParseState<'input #(, #grammar_lifetime_params)*> { ParseState { _phantom: ::std::marker::PhantomData, - #(#cache_fields: ::std::collections::HashMap::new()),* + #(#cache_fields: ::std::collections::HashMap::new(),)* + #stack_size_init } } } @@ -221,6 +242,7 @@ fn compile_rule(context: &Context, rule: &Rule) -> TokenStream { parse_state_ty, grammar_lifetime_params, extra_args_def, + stack_limit, .. } = context; @@ -253,10 +275,33 @@ fn compile_rule(context: &Context, rule: &Rule) -> TokenStream { body }; + let stack_increment = stack_limit.as_ref().map(|lim| { + quote_spanned! { span => { + if __state._stack_size > #lim { + __err_state.mark_failure(__pos, "STACK OVERFLOW"); + return ::peg::RuleResult::Failed; + } + __state._stack_size += 1; + }} + }); + + let stack_decrement = if stack_limit.is_some() { + Some(quote_spanned! { span => { + __state._stack_size -= 1; + }}) + } else { + None + }; + let rule_params = rule_params_list(&context, rule); let fn_body = match &rule.cache { - None => wrapped_body, + None => quote_spanned! { span => { + #stack_increment + let __rule_result: ::peg::RuleResult<#ret_ty> = { #wrapped_body }; + #stack_decrement + __rule_result + }}, Some(cache_type) => { let cache_field = format_ident!("{}_cache", rule.name); @@ -279,8 +324,9 @@ fn compile_rule(context: &Context, rule: &Rule) -> TokenStream { #cache_trace return entry.clone(); } - + #stack_increment let __rule_result = #wrapped_body; + #stack_decrement __state.#cache_field.insert(__pos, __rule_result.clone()); __rule_result }, @@ -288,6 +334,18 @@ fn compile_rule(context: &Context, rule: &Rule) -> TokenStream { // `#[cache_left_rec] support for recursive rules using the technique described here: // { + let stack_save = if stack_limit.is_some() { + Some( + quote_spanned! { span => let __stack_size_before = __state._stack_size; }, + ) + } else { + None + }; + let stack_restore = if stack_limit.is_some() { + Some(quote_spanned! { span => __state._stack_size = __stack_size_before; }) + } else { + None + }; quote_spanned! { span => if let Some(entry) = __state.#cache_field.get(&__pos) { #cache_trace @@ -296,7 +354,9 @@ fn compile_rule(context: &Context, rule: &Rule) -> TokenStream { __state.#cache_field.insert(__pos, ::peg::RuleResult::Failed); let mut __last_result = ::peg::RuleResult::Failed; + #stack_save loop { + #stack_increment let __current_result = { #wrapped_body }; match __current_result { ::peg::RuleResult::Failed => break, @@ -310,7 +370,7 @@ fn compile_rule(context: &Context, rule: &Rule) -> TokenStream { } } } - + #stack_restore return __last_result; } } diff --git a/tests/compile-fail/syntax_error.stderr b/tests/compile-fail/syntax_error.stderr index 1164f59..3da9128 100644 --- a/tests/compile-fail/syntax_error.stderr +++ b/tests/compile-fail/syntax_error.stderr @@ -1,4 +1,4 @@ -error: expected one of "#", "crate", "pub", "rule", "use", "}" +error: expected one of "#", "crate", "pub", "rule", "stack_limit", "use", "}" --> $DIR/syntax_error.rs:4:5 | 4 | fn asdf() {} //~ ERROR expected one of "#", "crate", "pub", "rule", "use", "}" diff --git a/tests/run-pass/recursion_limit.rs b/tests/run-pass/recursion_limit.rs new file mode 100644 index 0000000..6e45ba4 --- /dev/null +++ b/tests/run-pass/recursion_limit.rs @@ -0,0 +1,46 @@ +fn prepend(head: i64, mut tail: Vec) -> Vec { + tail.insert(0, head); + tail +} + +fn append(mut init: Vec, last: i64) -> Vec { + init.push(last); + init +} + +peg::parser! { +grammar list() for str { + stack_limit 2; + + pub rule of_one_or_two() -> Vec + = head:number() "," tail:of_one_or_two() { prepend(head, tail) } + / single:number() { vec![single] } + + rule number() -> i64 + = n:$(['0'..='9']+) { n.parse().unwrap() } + + #[cache_left_rec] + pub rule leftrec() -> Vec + = init:leftrec() "," last:number() { append(init, last) } + / single: number() { vec![single] } +} +} + +fn main() { + assert_eq!(list::of_one_or_two("1"), Ok(vec![1])); + assert_eq!(list::of_one_or_two("1,2"), Ok(vec![1, 2])); + let err = list::of_one_or_two("1,2,3"); + assert!(err.is_err()); + assert_eq!( + err.unwrap_err().expected.tokens().collect::>(), + vec!["STACK OVERFLOW"] + ); + + assert_eq!(list::leftrec("1,2"), Ok(vec![1, 2])); + let err = list::leftrec("1,2,3"); + assert!(err.is_err()); + assert_eq!( + err.unwrap_err().expected.tokens().collect::>(), + vec!["STACK OVERFLOW"] + ); +}