diff --git a/README.md b/README.md index 15e1944..c511d3f 100644 --- a/README.md +++ b/README.md @@ -13,6 +13,7 @@ * Helpful `rustc` error messages for errors in the grammar definition or the Rust code embedded within it * Rule-level tracing to debug grammars +* Error recovery ## Example @@ -30,21 +31,21 @@ peg::parser!{ } pub fn main() { - assert_eq!(list_parser::list("[1,1,2,3,5,8]"), Ok(vec![1, 1, 2, 3, 5, 8])); + assert_eq!(list_parser::list("[1,1,2,3,5,8]").into_result(), Ok(vec![1, 1, 2, 3, 5, 8])); } ``` -[See the tests for more examples](./tests/run-pass/) +[See the tests for more examples](./tests/run-pass/) [Grammar rule syntax reference in rustdoc](https://docs.rs/peg) ## Comparison with similar parser generators -| crate | parser type | action code | integration | input type | precedence climbing | parameterized rules | streaming input | -|----------- |------------- |------------- |-------------------- |------------------------ |--------------------- |-------------------- |----------------- | -| peg | PEG | in grammar | proc macro (block) | `&str`, `&[T]`, custom | Yes | Yes | No | -| [pest] | PEG | external | proc macro (file) | `&str` | Yes | No | No | -| [nom] | combinators | in source | library | `&[u8]`, custom | No | Yes | Yes | -| [lalrpop] | LR(1) | in grammar | build script | `&str` | No | Yes | No | +| crate | parser type | action code | integration | input type | precedence climbing | parameterized rules | streaming input | recovery | +|----------- |------------- |------------- |-------------------- |------------------------ |--------------------- |-------------------- |----------------- |--------- | +| peg | PEG | in grammar | proc macro (block) | `&str`, `&[T]`, custom | Yes | Yes | No | Yes | +| [pest] | PEG | external | proc macro (file) | `&str` | Yes | No | No | No | +| [nom] | combinators | in source | library | `&[u8]`, custom | No | Yes | Yes | No | +| [lalrpop] | LR(1) | in grammar | build script | `&str` | No | Yes | No | Yes | [pest]: https://github.com/pest-parser/pest [nom]: https://github.com/geal/nom @@ -60,6 +61,13 @@ pub fn main() { [annotate-snippets]: https://crates.io/crates/annotate-snippets [codespan-reporting]: https://crates.io/crates/codespan-reporting [codemap-diagnostic]: https://crates.io/crates/codemap-diagnostic + +## Upgrade guide + +The rule return type has changed between 0.8 to 0.9, +and now supports recovery and reporting multiple errors. +To upgrade, add a call to `.into_result()` to convert the new rule return type +to a simple `Result`. ## Development The `rust-peg` grammar is written in `rust-peg`: `peg-macros/grammar.rustpeg`. To avoid the circular dependency, a precompiled grammar is checked in as `peg-macros/grammar.rs`. To regenerate this, run the `./bootstrap.sh` script. diff --git a/peg-macros/analysis.rs b/peg-macros/analysis.rs index ffdac50..eb2b9e3 100644 --- a/peg-macros/analysis.rs +++ b/peg-macros/analysis.rs @@ -164,7 +164,7 @@ impl<'a> LeftRecursionVisitor<'a> { nullable } - LiteralExpr(_) | PatternExpr(_) | MethodExpr(_, _) | FailExpr(_) | MarkerExpr(_) => false, + LiteralExpr(_) | PatternExpr(_) | MethodExpr(_, _) | FailExpr(_) | ErrorIfExpr(..) | ErrorUnlessExpr(..) |MarkerExpr(_) => false, PositionExpr => true, } @@ -220,7 +220,7 @@ impl<'a> LoopNullabilityVisitor<'a> { let name = rule_ident.to_string(); *self.rule_nullability.get(&name).unwrap_or(&false) } - + ActionExpr(ref elems, ..) => { let mut nullable = true; for elem in elems { @@ -250,7 +250,7 @@ impl<'a> LoopNullabilityVisitor<'a> { if inner_nullable && sep_nullable && !bound.has_upper_bound() { self.errors.push(LoopNullabilityError { span: this_expr.span }); } - + inner_nullable | !bound.has_lower_bound() } @@ -269,10 +269,10 @@ impl<'a> LoopNullabilityVisitor<'a> { } } - nullable + nullable } - LiteralExpr(_) | PatternExpr(_) | MethodExpr(_, _) | FailExpr(_) | MarkerExpr(_) => false, + LiteralExpr(_) | PatternExpr(_) | MethodExpr(_, _) | FailExpr(_) | ErrorIfExpr(..) | ErrorUnlessExpr(..) | MarkerExpr(_) => false, PositionExpr => true, } } diff --git a/peg-macros/ast.rs b/peg-macros/ast.rs index 24ff565..6370de3 100644 --- a/peg-macros/ast.rs +++ b/peg-macros/ast.rs @@ -85,6 +85,8 @@ pub enum Expr { PositionExpr, QuietExpr(Box), FailExpr(Literal), + ErrorIfExpr(Box, Literal, Box), + ErrorUnlessExpr(Box, Literal, Box), PrecedenceExpr { levels: Vec, }, diff --git a/peg-macros/bin.rs b/peg-macros/bin.rs index a66f4c5..ce24b06 100644 --- a/peg-macros/bin.rs +++ b/peg-macros/bin.rs @@ -42,7 +42,7 @@ fn main() { let source_tokens = source.parse().expect("Error tokenizing input"); let input_tokens = tokens::FlatTokenStream::new(source_tokens); - let grammar = match grammar::peg::peg_grammar(&input_tokens) { + let grammar = match grammar::peg::peg_grammar(&input_tokens).into_result() { Ok(g) => g, Err(err) => { eprintln!("Failed to parse grammar: expected {}", err.expected); diff --git a/peg-macros/grammar.rs b/peg-macros/grammar.rs index d3020c8..605ef23 100644 --- a/peg-macros/grammar.rs +++ b/peg-macros/grammar.rs @@ -23,7 +23,7 @@ pub mod peg { use proc_macro2::{Delimiter, Group, Ident, Literal, Span, TokenStream}; pub fn peg_grammar<'input>( __input: &'input Input, - ) -> ::std::result::Result> { + ) -> ::peg::ParseResults { #![allow(non_snake_case, unused)] let mut __err_state = ::peg::error::ErrorState::new(::peg::Parse::start(__input)); let mut __state = ParseState::new(); @@ -35,15 +35,16 @@ pub mod peg { ) { ::peg::RuleResult::Matched(__pos, __value) => { if ::peg::Parse::is_eof(__input, __pos) { - return Ok(__value); + return __err_state.into_matched(__value, __input); } else { __err_state.mark_failure(__pos, "EOF"); } } - _ => (), + ::peg::RuleResult::Error(__e) => return __err_state.into_error(__e, __input), + ::peg::RuleResult::Failed => (), } __state = ParseState::new(); - __err_state.reparse_for_error(); + __err_state.reparse_for_failure(); match __parse_peg_grammar( __input, &mut __state, @@ -61,7 +62,7 @@ pub mod peg { } _ => (), } - Err(__err_state.into_parse_error(__input)) + __err_state.into_failure(__input) } fn __parse_peg_grammar<'input>( __input: &'input Input, @@ -100,6 +101,9 @@ pub mod peg { ::peg::RuleResult::Failed => { ::peg::RuleResult::Matched(__pos, None) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } }; match __seq_res { ::peg::RuleResult::Matched( @@ -112,25 +116,37 @@ pub mod peg { __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 , } + 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 :: Error (e) => :: peg :: RuleResult :: Error (e) , :: 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 :: Error (__e) => :: peg :: RuleResult :: Error (__e) , } } ; 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 __maybe_err = None ; 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 :: Error (__e) => { __maybe_err = Some (__e) ; 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 :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"}\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"{\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"for\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } + } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"grammar\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } @@ -146,6 +162,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { let __seq_res = { let mut __repeat_pos = __pos; + let mut __maybe_err = None; let mut __repeat_value = vec![]; loop { let __pos = __repeat_pos; @@ -158,6 +175,10 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\",\""); ::peg::RuleResult::Failed @@ -166,6 +187,10 @@ pub mod peg { match __sep_res { ::peg::RuleResult::Matched(__newpos, _) => __newpos, ::peg::RuleResult::Failed => break, + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } }; let __step_res = { @@ -174,6 +199,7 @@ pub mod peg { ::peg::RuleResult::Matched(pos, _) => { ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Error(e) => ::peg::RuleResult::Error(e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } { ::peg::RuleResult::Matched(__newpos, _) => { @@ -185,6 +211,7 @@ pub mod peg { ) } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), } }; match __step_res { @@ -195,9 +222,15 @@ pub mod peg { ::peg::RuleResult::Failed => { break; } + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } } - if __repeat_value.len() >= 1 { + if let Some(__e) = __maybe_err { + ::peg::RuleResult::Error(__e) + } else if __repeat_value.len() >= 1 { ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) } else { ::peg::RuleResult::Failed @@ -209,15 +242,24 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, (|| p)()) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\">\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"<\""); ::peg::RuleResult::Failed @@ -235,6 +277,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { let __seq_res = { let mut __repeat_pos = __pos; + let mut __maybe_err = None; let mut __repeat_value = vec![]; loop { let __pos = __repeat_pos; @@ -247,6 +290,10 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\",\""); ::peg::RuleResult::Failed @@ -255,6 +302,10 @@ pub mod peg { match __sep_res { ::peg::RuleResult::Matched(__newpos, _) => __newpos, ::peg::RuleResult::Failed => break, + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } }; let __step_res = { @@ -276,6 +327,9 @@ pub mod peg { ::peg::RuleResult::Matched(pos, _) => { ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Error(e) => { + ::peg::RuleResult::Error(e) + } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } @@ -291,23 +345,34 @@ pub mod peg { ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } } }; match __seq_res { ::peg::RuleResult::Matched(__pos, t) => { ::peg::RuleResult::Matched(__pos, (|| (i, t))()) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\":\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } }; @@ -319,6 +384,10 @@ pub mod peg { ::peg::RuleResult::Failed => { break; } + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } } ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) @@ -331,6 +400,10 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\",\""); ::peg::RuleResult::Failed @@ -340,6 +413,7 @@ pub mod peg { ::peg::RuleResult::Matched(__newpos, ()) } ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, ()), + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), }; match __seq_res { ::peg::RuleResult::Matched(__pos, _) => { @@ -348,18 +422,28 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, (|| args)()) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\")\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"(\""); ::peg::RuleResult::Failed @@ -409,14 +493,14 @@ pub mod peg { __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 } } } } } + let __choice_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "_") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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 :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: 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 :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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 :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "___") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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 __assert_res { :: peg :: RuleResult :: Matched (_ , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , :: peg :: RuleResult :: Error (..) => :: 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 __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 :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\")\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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 , ()) } , :: peg :: RuleResult :: Error (__e) => { :: peg :: RuleResult :: Error (__e) } , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { :: peg :: RuleResult :: Matched (__pos , (|| { (name , None , Vec :: new ()) }) ()) } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } }; match __choice_res { ::peg::RuleResult::Matched( @@ -427,6 +511,11 @@ pub mod peg { __pos, __value, ) } + ::peg::RuleResult::Error( + __e, + ) => ::peg::RuleResult::Error( + __e, + ), ::peg::RuleResult::Failed => { let __seq_res = __parse_IDENT( @@ -435,7 +524,7 @@ pub mod peg { __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 , 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) } , :: peg :: RuleResult :: Error (__e) => { :: peg :: RuleResult :: Error (__e) } , } ; 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 :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } }; @@ -444,14 +533,21 @@ pub mod peg { __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 , } + 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 :: Error (e) => :: peg :: RuleResult :: Error (e) , :: 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 :: Error (__e) => :: peg :: RuleResult :: Error (__e) , } } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , t) => { :: peg :: RuleResult :: Matched (__pos , (|| { t }) ()) } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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) } , :: peg :: RuleResult :: Error (__e) => { :: peg :: RuleResult :: Error (__e) } , } ; + 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 :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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 , ()) } , :: peg :: RuleResult :: Error (__e) => { :: peg :: RuleResult :: Error (__e) } , } ; 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 :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"=\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } + } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state .mark_failure(__pos, "\"rule\""); @@ -459,20 +555,29 @@ pub mod peg { } } } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } @@ -502,24 +607,40 @@ pub mod peg { (|| Some(Cache::Simple))(), ) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"]\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"cache\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"[\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"#\""); ::peg::RuleResult::Failed @@ -529,6 +650,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { let __choice_res = match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "#") { @@ -551,12 +673,20 @@ pub mod peg { (|| Some(Cache::Recursive))(), ) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"]\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state .mark_failure(__pos, "\"cache_left_rec\""); @@ -564,12 +694,20 @@ pub mod peg { } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"[\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"#\""); ::peg::RuleResult::Failed @@ -579,6 +717,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, (|| None)()), } } @@ -608,24 +747,40 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, (|| true)()) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"]\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"no_eof\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"[\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"#\""); ::peg::RuleResult::Failed @@ -635,6 +790,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, (|| false)()), } } @@ -663,6 +819,7 @@ pub mod peg { ::peg::RuleResult::Matched(pos, _) => { ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Error(e) => ::peg::RuleResult::Error(e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } { ::peg::RuleResult::Matched(__newpos, _) => { @@ -674,6 +831,9 @@ pub mod peg { ) } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } } }; match __seq_res { @@ -687,21 +847,34 @@ pub mod peg { (|| RuleParamTy::Rule(r))(), ) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\">\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"<\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"rule\""); ::peg::RuleResult::Failed @@ -711,6 +884,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { let __seq_res = { let str_start = __pos; @@ -718,6 +892,7 @@ pub mod peg { ::peg::RuleResult::Matched(pos, _) => { ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Error(e) => ::peg::RuleResult::Error(e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } { ::peg::RuleResult::Matched(__newpos, _) => ::peg::RuleResult::Matched( @@ -725,12 +900,14 @@ pub mod peg { ::peg::ParseSlice::parse_slice(__input, str_start, __newpos), ), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), } }; match __seq_res { ::peg::RuleResult::Matched(__pos, t) => { ::peg::RuleResult::Matched(__pos, (|| RuleParamTy::Rust(t))()) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } @@ -748,6 +925,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { let __seq_res = { let mut __repeat_pos = __pos; + let mut __maybe_err = None; let mut __repeat_value = vec![]; loop { let __pos = __repeat_pos; @@ -760,6 +938,10 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\",\""); ::peg::RuleResult::Failed @@ -768,6 +950,10 @@ pub mod peg { match __sep_res { ::peg::RuleResult::Matched(__newpos, _) => __newpos, ::peg::RuleResult::Failed => break, + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } }; let __step_res = { @@ -791,17 +977,25 @@ pub mod peg { (|| RuleParam { name, ty })(), ) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\":\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } }; @@ -813,6 +1007,10 @@ pub mod peg { ::peg::RuleResult::Failed => { break; } + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } } ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) @@ -823,15 +1021,24 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, (|| params)()) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\")\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"(\""); ::peg::RuleResult::Failed @@ -852,6 +1059,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, u) => { ::peg::RuleResult::Matched(__pos, (|| Item::Use(u))()) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } }; @@ -859,12 +1067,14 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::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::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } @@ -882,6 +1092,7 @@ pub mod peg { let str_start = __pos; match { let mut __repeat_pos = __pos; + let mut __maybe_err = None; loop { let __pos = __repeat_pos; let __step_res = match ::peg::ParseLiteral::parse_string_literal( @@ -907,11 +1118,18 @@ pub mod peg { ::peg::RuleResult::Matched(pos, _) => { ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Error(e) => { + ::peg::RuleResult::Error(e) + } ::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 , } + 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 :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"]\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } + } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"=\""); @@ -919,18 +1137,30 @@ pub mod peg { } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"doc\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"[\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"#\""); ::peg::RuleResult::Failed @@ -943,6 +1173,10 @@ pub mod peg { ::peg::RuleResult::Failed => { break; } + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } } ::peg::RuleResult::Matched(__repeat_pos, ()) @@ -952,12 +1186,14 @@ pub mod peg { ::peg::ParseSlice::parse_slice(__input, str_start, __newpos), ), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), } } { ::peg::RuleResult::Matched(__newpos, __value) => { ::peg::RuleResult::Matched(__newpos, Some(__value)) } ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, None), + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), } } fn __parse_rust_visibility<'input>( @@ -982,20 +1218,27 @@ pub mod peg { ::peg::RuleResult::Matched(pos, _) => { ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Error(e) => ::peg::RuleResult::Error(e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } { ::peg::RuleResult::Matched(__newpos, _) => { ::peg::RuleResult::Matched(__newpos, ()) } ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, ()), + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), }; match __seq_res { ::peg::RuleResult::Matched(__pos, _) => { ::peg::RuleResult::Matched(__pos, ()) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"pub\""); ::peg::RuleResult::Failed @@ -1005,11 +1248,16 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "crate") { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"crate\""); ::peg::RuleResult::Failed @@ -1023,12 +1271,14 @@ pub mod peg { ::peg::ParseSlice::parse_slice(__input, str_start, __newpos), ), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), } } { ::peg::RuleResult::Matched(__newpos, __value) => { ::peg::RuleResult::Matched(__newpos, Some(__value)) } ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, None), + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), } } fn __parse_rust_use<'input>( @@ -1048,6 +1298,7 @@ pub mod peg { ::peg::RuleResult::Matched(pos, _) => { ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Error(e) => ::peg::RuleResult::Error(e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, }; match __seq_res { @@ -1064,12 +1315,20 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, ()) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"*\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"::\""); ::peg::RuleResult::Failed @@ -1079,9 +1338,12 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::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 , ()) } , } } + 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 __maybe_err = None ; 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 :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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 :: Error (__e) => { __maybe_err = Some (__e) ; 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 :: Error (e) => :: peg :: RuleResult :: Error (e) , :: 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 :: Error (e) => :: peg :: RuleResult :: Error (e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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 :: Error (__e) => { :: peg :: RuleResult :: Error (__e) } , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: 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 :: Error (__e) => { __maybe_err = Some (__e) ; break ; } } } if let Some (__e) = __maybe_err { :: peg :: RuleResult :: Error (__e) } else 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 :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"}\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"{\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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 :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: 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 :: Error (e) => :: peg :: RuleResult :: Error (e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { :: peg :: RuleResult :: Matched (__pos , ()) } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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 :: Error (__e) => { :: peg :: RuleResult :: Error (__e) } , } } } } }; @@ -1093,18 +1355,28 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, ()) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\";\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"use\""); ::peg::RuleResult::Failed @@ -1115,12 +1387,14 @@ pub mod peg { ::peg::ParseSlice::parse_slice(__input, str_start, __newpos), ), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), } }; match __seq_res { ::peg::RuleResult::Matched(__pos, v) => { ::peg::RuleResult::Matched(__pos, (|| v.to_owned())()) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } @@ -1140,12 +1414,20 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, ()) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"::\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"crate\""); ::peg::RuleResult::Failed @@ -1155,11 +1437,13 @@ pub mod peg { ::peg::RuleResult::Matched(__newpos, ()) } ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, ()), + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), }; match __seq_res { ::peg::RuleResult::Matched(__pos, _) => { let __seq_res = { let mut __repeat_pos = __pos; + let mut __maybe_err = None; let mut __repeat_value = vec![]; loop { let __pos = __repeat_pos; @@ -1172,6 +1456,10 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"::\""); ::peg::RuleResult::Failed @@ -1180,6 +1468,10 @@ pub mod peg { match __sep_res { ::peg::RuleResult::Matched(__newpos, _) => __newpos, ::peg::RuleResult::Failed => break, + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } }; let __step_res = @@ -1187,6 +1479,7 @@ pub mod peg { ::peg::RuleResult::Matched(pos, _) => { ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Error(e) => ::peg::RuleResult::Error(e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, }; match __step_res { @@ -1197,9 +1490,15 @@ pub mod peg { ::peg::RuleResult::Failed => { break; } + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } } - if __repeat_value.len() >= 1 { + if let Some(__e) = __maybe_err { + ::peg::RuleResult::Error(__e) + } else if __repeat_value.len() >= 1 { ::peg::RuleResult::Matched(__repeat_pos, ()) } else { ::peg::RuleResult::Failed @@ -1209,9 +1508,11 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, _) => { ::peg::RuleResult::Matched(__pos, ()) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } @@ -1226,12 +1527,14 @@ pub mod peg { { let __choice_res = match __parse_BRACKET_GROUP(__input, __state, __err_state, __pos) { ::peg::RuleResult::Matched(pos, _) => ::peg::RuleResult::Matched(pos, ()), + ::peg::RuleResult::Error(e) => ::peg::RuleResult::Error(e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, }; match __choice_res { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { let __choice_res = match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "&") { @@ -1243,6 +1546,10 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"mut\""); ::peg::RuleResult::Failed @@ -1254,6 +1561,9 @@ pub mod peg { ::peg::RuleResult::Failed => { ::peg::RuleResult::Matched(__pos, ()) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } }; match __seq_res { ::peg::RuleResult::Matched(__pos, _) => { @@ -1266,6 +1576,9 @@ pub mod peg { ::peg::RuleResult::Matched(pos, _) => { ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Error(e) => { + ::peg::RuleResult::Error(e) + } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } { ::peg::RuleResult::Matched(__newpos, _) => { @@ -1274,6 +1587,9 @@ pub mod peg { ::peg::RuleResult::Failed => { ::peg::RuleResult::Matched(__pos, ()) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } }; match __seq_res { ::peg::RuleResult::Matched(__pos, _) => { @@ -1286,6 +1602,9 @@ pub mod peg { ::peg::RuleResult::Matched(pos, _) => { ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Error(e) => { + ::peg::RuleResult::Error(e) + } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } @@ -1294,17 +1613,28 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, _) => { ::peg::RuleResult::Matched(__pos, ()) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"&\""); ::peg::RuleResult::Failed @@ -1314,6 +1644,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { let __choice_res = match ::peg::ParseLiteral::parse_string_literal( __input, __pos, "dyn", @@ -1328,15 +1659,23 @@ pub mod peg { ::peg::RuleResult::Matched(pos, _) => { ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Error(e) => ::peg::RuleResult::Error(e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, }; match __seq_res { ::peg::RuleResult::Matched(__pos, _) => { ::peg::RuleResult::Matched(__pos, ()) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"dyn\""); ::peg::RuleResult::Failed @@ -1346,6 +1685,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { let __choice_res = match ::peg::ParseLiteral::parse_string_literal( @@ -1361,6 +1701,9 @@ pub mod peg { ::peg::RuleResult::Matched(pos, _) => { ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Error(e) => { + ::peg::RuleResult::Error(e) + } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } @@ -1369,11 +1712,18 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, _) => { ::peg::RuleResult::Matched(__pos, ()) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"impl\""); ::peg::RuleResult::Failed @@ -1383,6 +1733,9 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { let __choice_res = match ::peg::ParseLiteral::parse_string_literal( @@ -1391,6 +1744,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { let __seq_res = { let mut __repeat_pos = __pos; + let mut __maybe_err = None; let mut __repeat_value = vec![]; loop { let __pos = __repeat_pos; @@ -1399,10 +1753,10 @@ pub mod peg { { __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 __sep_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ",") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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 :: Error (__e) => { __maybe_err = Some (__e) ; 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 , } ; + let __step_res = match __parse_rust_type (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Error (e) => :: peg :: RuleResult :: Error (e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; match __step_res { ::peg::RuleResult::Matched( __newpos, @@ -1415,6 +1769,12 @@ pub mod peg { ::peg::RuleResult::Failed => { break; } + ::peg::RuleResult::Error( + __e, + ) => { + __maybe_err = Some(__e); + break; + } } } ::peg::RuleResult::Matched( @@ -1422,7 +1782,11 @@ pub mod peg { (), ) }; - 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 , } + 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 :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\")\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } + } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"(\""); @@ -1433,6 +1797,9 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { match __parse_rust_ty_path( __input, @@ -1443,6 +1810,9 @@ pub mod peg { ::peg::RuleResult::Matched(pos, _) => { ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Error(e) => { + ::peg::RuleResult::Error(e) + } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } @@ -1472,6 +1842,10 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"::\""); ::peg::RuleResult::Failed @@ -1481,11 +1855,13 @@ pub mod peg { ::peg::RuleResult::Matched(__newpos, ()) } ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, ()), + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), }; match __seq_res { ::peg::RuleResult::Matched(__pos, _) => { let __seq_res = { let mut __repeat_pos = __pos; + let mut __maybe_err = None; let mut __repeat_value = vec![]; loop { let __pos = __repeat_pos; @@ -1498,6 +1874,10 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"::\""); ::peg::RuleResult::Failed @@ -1506,6 +1886,10 @@ pub mod peg { match __sep_res { ::peg::RuleResult::Matched(__newpos, _) => __newpos, ::peg::RuleResult::Failed => break, + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } }; let __step_res = { @@ -1514,12 +1898,13 @@ pub mod peg { ::peg::RuleResult::Matched(pos, _) => { ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Error(e) => ::peg::RuleResult::Error(e), ::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 , ()) } , } ; + let __seq_res = match match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "::") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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 , ()) } , :: peg :: RuleResult :: Error (__e) => { :: peg :: RuleResult :: Error (__e) } , } ; match __seq_res { ::peg::RuleResult::Matched(__pos, _) => { match ::peg::ParseLiteral::parse_string_literal( @@ -1531,6 +1916,7 @@ pub mod peg { ) => { let __seq_res = { let mut __repeat_pos = __pos; + let mut __maybe_err = None; let mut __repeat_value = vec![]; loop { let __pos = __repeat_pos; @@ -1539,16 +1925,19 @@ pub mod peg { { __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 __sep_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ",") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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 :: Error (__e) => { __maybe_err = Some (__e) ; 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 , } } } } } } + let __choice_res = match __parse_LIFETIME (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Error (e) => :: peg :: RuleResult :: Error (e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; + match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: 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 :: Error (e) => :: peg :: RuleResult :: Error (e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: 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 :: Error (e) => :: peg :: RuleResult :: Error (e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => match __parse_LITERAL (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Error (e) => :: peg :: RuleResult :: Error (e) , :: 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 __step_res { :: peg :: RuleResult :: Matched (__newpos , __value) => { __repeat_pos = __newpos ; __repeat_value . push (__value) ; } , :: peg :: RuleResult :: Failed => { break ; } :: peg :: RuleResult :: Error (__e) => { __maybe_err = Some (__e) ; break ; } } } - if __repeat_value.len() >= 1 { + if let Some(__e) = __maybe_err { + ::peg::RuleResult::Error(__e) + } else if __repeat_value.len() >= 1 + { ::peg::RuleResult::Matched( __repeat_pos, (), @@ -1557,7 +1946,11 @@ pub mod peg { ::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 , } + 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 :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\">\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } + } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) } ::peg::RuleResult::Failed => { __err_state @@ -1566,6 +1959,9 @@ pub mod peg { } } } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } @@ -1577,14 +1973,21 @@ pub mod peg { ::peg::RuleResult::Failed => { ::peg::RuleResult::Matched(__pos, ()) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } }; match __seq_res { ::peg::RuleResult::Matched(__pos, _) => { ::peg::RuleResult::Matched(__pos, ()) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } }; @@ -1596,9 +1999,15 @@ pub mod peg { ::peg::RuleResult::Failed => { break; } + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } } - if __repeat_value.len() >= 1 { + if let Some(__e) = __maybe_err { + ::peg::RuleResult::Error(__e) + } else if __repeat_value.len() >= 1 { ::peg::RuleResult::Matched(__repeat_pos, ()) } else { ::peg::RuleResult::Failed @@ -1608,9 +2017,11 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, _) => { ::peg::RuleResult::Matched(__pos, ()) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } @@ -1626,6 +2037,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { let __seq_res = { let mut __repeat_pos = __pos; + let mut __maybe_err = None; let mut __repeat_value = vec![]; loop { let __pos = __repeat_pos; @@ -1638,6 +2050,10 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\",\""); ::peg::RuleResult::Failed @@ -1646,6 +2062,10 @@ pub mod peg { match __sep_res { ::peg::RuleResult::Matched(__newpos, _) => __newpos, ::peg::RuleResult::Failed => break, + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } }; let __step_res = { @@ -1659,6 +2079,7 @@ pub mod peg { ::peg::RuleResult::Matched(pos, _) => { ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Error(e) => ::peg::RuleResult::Error(e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } { ::peg::RuleResult::Matched(__newpos, _) => { @@ -1670,6 +2091,7 @@ pub mod peg { ) } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), } }; match __step_res { @@ -1680,9 +2102,15 @@ pub mod peg { ::peg::RuleResult::Failed => { break; } + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } } - if __repeat_value.len() >= 1 { + if let Some(__e) = __maybe_err { + ::peg::RuleResult::Error(__e) + } else if __repeat_value.len() >= 1 { ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) } else { ::peg::RuleResult::Failed @@ -1694,15 +2122,24 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, (|| p)()) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\">\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"<\""); ::peg::RuleResult::Failed @@ -1720,6 +2157,7 @@ pub mod peg { let __choice_res = { let __seq_res = match __parse_LIFETIME(__input, __state, __err_state, __pos) { ::peg::RuleResult::Matched(pos, _) => ::peg::RuleResult::Matched(pos, ()), + ::peg::RuleResult::Error(e) => ::peg::RuleResult::Error(e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, }; match __seq_res { @@ -1730,6 +2168,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { let __seq_res = { let mut __repeat_pos = __pos; + let mut __maybe_err = None; let mut __repeat_value = vec![]; loop { let __pos = __repeat_pos; @@ -1743,6 +2182,10 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"+\""); ::peg::RuleResult::Failed @@ -1751,6 +2194,10 @@ pub mod peg { match __sep_res { ::peg::RuleResult::Matched(__newpos, _) => __newpos, ::peg::RuleResult::Failed => break, + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } }; let __step_res = match __parse_LIFETIME( @@ -1762,6 +2209,9 @@ pub mod peg { ::peg::RuleResult::Matched(pos, _) => { ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Error(e) => { + ::peg::RuleResult::Error(e) + } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, }; match __step_res { @@ -1772,9 +2222,15 @@ pub mod peg { ::peg::RuleResult::Failed => { break; } + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } } - if __repeat_value.len() >= 1 { + if let Some(__e) = __maybe_err { + ::peg::RuleResult::Error(__e) + } else if __repeat_value.len() >= 1 { ::peg::RuleResult::Matched(__repeat_pos, ()) } else { ::peg::RuleResult::Failed @@ -1784,9 +2240,14 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, _) => { ::peg::RuleResult::Matched(__pos, ()) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\":\""); ::peg::RuleResult::Failed @@ -1796,14 +2257,17 @@ pub mod peg { ::peg::RuleResult::Matched(__newpos, ()) } ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, ()), + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), }; match __seq_res { ::peg::RuleResult::Matched(__pos, _) => { ::peg::RuleResult::Matched(__pos, ()) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } }; @@ -1811,9 +2275,11 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { let __seq_res = match __parse_IDENT(__input, __state, __err_state, __pos) { ::peg::RuleResult::Matched(pos, _) => ::peg::RuleResult::Matched(pos, ()), + ::peg::RuleResult::Error(e) => ::peg::RuleResult::Error(e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, }; match __seq_res { @@ -1824,6 +2290,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { let __seq_res = { let mut __repeat_pos = __pos; + let mut __maybe_err = None; let mut __repeat_value = vec![]; loop { let __pos = __repeat_pos; @@ -1840,6 +2307,10 @@ pub mod peg { ) => { ::peg::RuleResult::Matched(__pos, __val) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state .mark_failure(__pos, "\"+\""); @@ -1851,6 +2322,10 @@ pub mod peg { __newpos } ::peg::RuleResult::Failed => break, + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } }; let __step_res = { @@ -1863,6 +2338,9 @@ pub mod peg { ::peg::RuleResult::Matched(pos, _) => { ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Error(e) => { + ::peg::RuleResult::Error(e) + } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } @@ -1871,14 +2349,17 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::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 , ()) } , } ; + let __seq_res = match match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "?") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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 , ()) } , :: peg :: RuleResult :: Error (__e) => { :: peg :: RuleResult :: Error (__e) } , } ; 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 , } ; + let __seq_res = match __parse_rust_ty_path (__input , __state , __err_state , __pos) { :: peg :: RuleResult :: Matched (pos , _) => :: peg :: RuleResult :: Matched (pos , ()) , :: peg :: RuleResult :: Error (e) => :: peg :: RuleResult :: Error (e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } ; match __seq_res { ::peg::RuleResult::Matched( __pos, @@ -1889,11 +2370,19 @@ pub mod peg { (), ) } + ::peg::RuleResult::Error( + __e, + ) => ::peg::RuleResult::Error( + __e, + ), ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } @@ -1909,9 +2398,15 @@ pub mod peg { ::peg::RuleResult::Failed => { break; } + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } } - if __repeat_value.len() >= 1 { + if let Some(__e) = __maybe_err { + ::peg::RuleResult::Error(__e) + } else if __repeat_value.len() >= 1 { ::peg::RuleResult::Matched(__repeat_pos, ()) } else { ::peg::RuleResult::Failed @@ -1921,9 +2416,16 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, _) => { ::peg::RuleResult::Matched(__pos, ()) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\":\""); ::peg::RuleResult::Failed @@ -1933,14 +2435,17 @@ pub mod peg { ::peg::RuleResult::Matched(__newpos, ()) } ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, ()), + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), }; match __seq_res { ::peg::RuleResult::Matched(__pos, _) => { ::peg::RuleResult::Matched(__pos, ()) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } @@ -1969,6 +2474,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, sp) => { let __seq_res = { let mut __repeat_pos = __pos; + let mut __maybe_err = None; let mut __repeat_value = vec![]; loop { let __pos = __repeat_pos; @@ -1981,6 +2487,10 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"/\""); ::peg::RuleResult::Failed @@ -1989,6 +2499,10 @@ pub mod peg { match __sep_res { ::peg::RuleResult::Matched(__newpos, _) => __newpos, ::peg::RuleResult::Failed => break, + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } }; let __step_res = __parse_sequence(__input, __state, __err_state, __pos); @@ -2000,9 +2514,15 @@ pub mod peg { ::peg::RuleResult::Failed => { break; } + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } } - if __repeat_value.len() >= 1 { + if let Some(__e) = __maybe_err { + ::peg::RuleResult::Error(__e) + } else if __repeat_value.len() >= 1 { ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) } else { ::peg::RuleResult::Failed @@ -2019,9 +2539,11 @@ pub mod peg { } })(), ), + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } @@ -2039,6 +2561,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, sp) => { let __seq_res = { let mut __repeat_pos = __pos; + let mut __maybe_err = None; let mut __repeat_value = vec![]; loop { let __pos = __repeat_pos; @@ -2051,6 +2574,10 @@ pub mod peg { ::peg::RuleResult::Failed => { break; } + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } } ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) @@ -2065,6 +2592,7 @@ pub mod peg { ::peg::RuleResult::Failed => { ::peg::RuleResult::Matched(__pos, None) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), }; match __seq_res { ::peg::RuleResult::Matched(__pos, code) => { @@ -2081,12 +2609,15 @@ pub mod peg { })(), ) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } @@ -2107,12 +2638,17 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, (|| l)()) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\":\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } { @@ -2120,6 +2656,7 @@ pub mod peg { ::peg::RuleResult::Matched(__newpos, Some(__value)) } ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, None), + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), }; match __seq_res { ::peg::RuleResult::Matched(__pos, label) => { @@ -2134,9 +2671,11 @@ pub mod peg { })(), ) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } @@ -2164,15 +2703,21 @@ pub mod peg { (|| OptionalExpr(Box::new(e)).at(sp))(), ) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"?\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } }; @@ -2180,6 +2725,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { let __choice_res = { let __seq_res = __parse_prefixed(__input, __state, __err_state, __pos); @@ -2222,25 +2768,37 @@ pub mod peg { })( ), ), + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"**\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } }; @@ -2248,6 +2806,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { let __choice_res = { let __seq_res = @@ -2284,20 +2843,31 @@ pub mod peg { })( ), ), + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"++\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } }; @@ -2305,6 +2875,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { let __choice_res = { let __seq_res = @@ -2317,7 +2888,10 @@ 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_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 :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"*\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } + } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } @@ -2326,6 +2900,9 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { let __choice_res = { let __seq_res = __parse_prefixed( @@ -2342,7 +2919,10 @@ 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) => { :: peg :: RuleResult :: Matched (__pos , (|| { Repeat { inner : Box :: new (e) , bound : BoundedRepeat :: Plus , sep : None } . at (sp) }) ()) } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"+\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } + } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed @@ -2353,6 +2933,9 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => __parse_prefixed( __input, __state, @@ -2391,15 +2974,24 @@ pub mod peg { (|| BoundedRepeat::Exact(n))(), ) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\">\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"<\""); ::peg::RuleResult::Failed @@ -2409,6 +3001,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { let __choice_res = match ::peg::ParseLiteral::parse_string_literal( __input, __pos, "<", @@ -2422,6 +3015,7 @@ pub mod peg { ::peg::RuleResult::Failed => { ::peg::RuleResult::Matched(__pos, None) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), }; match __seq_res { ::peg::RuleResult::Matched(__pos, min) => { @@ -2444,6 +3038,9 @@ pub mod peg { ::peg::RuleResult::Failed => { ::peg::RuleResult::Matched(__pos, None) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } }; match __seq_res { ::peg::RuleResult::Matched(__pos, max) => { @@ -2457,6 +3054,10 @@ pub mod peg { __pos, (|| BoundedRepeat::Both(min, max))(), ), + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state .mark_failure(__pos, "\">\""); @@ -2464,20 +3065,32 @@ pub mod peg { } } } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\",\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"<\""); ::peg::RuleResult::Failed @@ -2487,6 +3100,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { ::peg::RuleResult::Matched(__pos, (|| BoundedRepeat::None)()) } @@ -2507,17 +3121,20 @@ pub mod peg { match { let __choice_res = match __parse_INTEGER(__input, __state, __err_state, __pos) { ::peg::RuleResult::Matched(pos, _) => ::peg::RuleResult::Matched(pos, ()), + ::peg::RuleResult::Error(e) => ::peg::RuleResult::Error(e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, }; match __choice_res { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { match __parse_BRACE_GROUP(__input, __state, __err_state, __pos) { ::peg::RuleResult::Matched(pos, _) => { ::peg::RuleResult::Matched(pos, ()) } + ::peg::RuleResult::Error(e) => ::peg::RuleResult::Error(e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } @@ -2528,6 +3145,7 @@ pub mod peg { ::peg::ParseSlice::parse_slice(__input, str_start, __newpos), ), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), } } } @@ -2554,15 +3172,21 @@ pub mod peg { (|| MatchStrExpr(Box::new(expression)).at(sp))(), ) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"$\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } }; @@ -2570,6 +3194,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { let __choice_res = { let __seq_res = __parse_sp(__input, __state, __err_state, __pos); @@ -2588,15 +3213,23 @@ pub mod peg { ), ) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"&\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } }; @@ -2604,6 +3237,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { let __choice_res = { let __seq_res = __parse_sp(__input, __state, __err_state, __pos); @@ -2631,17 +3265,25 @@ pub mod peg { })( ), ), + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"!\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } }; @@ -2649,6 +3291,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { __parse_primary(__input, __state, __err_state, __pos) } @@ -2689,19 +3332,24 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { let __seq_res = { let mut __repeat_pos = __pos; + let mut __maybe_err = None; 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 __sep_res = match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "--") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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::Error(__e) => { + __maybe_err = Some(__e); + break; + } } }; let __step_res = __parse_precedence_level( @@ -2721,6 +3369,10 @@ pub mod peg { ::peg::RuleResult::Failed => { break; } + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } } ::peg::RuleResult::Matched( @@ -2728,7 +3380,11 @@ pub mod peg { __repeat_value, ) }; - match __seq_res { :: peg :: RuleResult :: Matched (__pos , levels) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "}") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { PrecedenceExpr { levels : levels } . 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 , levels) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "}") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { PrecedenceExpr { levels : levels } . at (sp) }) ()) } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"}\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } + } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"{\""); @@ -2736,18 +3392,27 @@ pub mod peg { } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"!\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"precedence\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } }; @@ -2755,120 +3420,57 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::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 , "position") { :: 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 , "(") { :: peg :: RuleResult :: Matched (__pos , __val) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ")") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { PositionExpr . 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 => { __err_state . mark_failure (__pos , "\"!\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"position\"") ; :: 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 , "position") { :: 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 , "(") { :: peg :: RuleResult :: Matched (__pos , __val) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ")") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { PositionExpr . at (sp) }) ()) } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\")\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"(\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"!\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"position\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } }; match __choice_res { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::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 , "quiet") { :: 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 , "{") { :: 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 , (|| { QuietExpr (Box :: new (e)) . at (sp) }) ()) } :: 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 => { __err_state . mark_failure (__pos , "\"quiet\"") ; :: 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 , "quiet") { :: 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 , "{") { :: 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 , (|| { QuietExpr (Box :: new (e)) . at (sp) }) ()) } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"}\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"{\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"!\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"quiet\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } }; match __choice_res { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::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 , "expected") { :: 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 , "(") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = __parse_LITERAL (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , s) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ")") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { FailExpr (s) . at (sp) }) ()) } :: 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 => { __err_state . mark_failure (__pos , "\"expected\"") ; :: 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 , "expected") { :: 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 , "(") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = __parse_LITERAL (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , s) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ")") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { FailExpr (s) . at (sp) }) ()) } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\")\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"(\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"!\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"expected\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } }; match __choice_res { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { 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_sp( - __input, - __state, - __err_state, - __pos, - ); - match __seq_res { - ::peg::RuleResult::Matched( - __pos, - sp, - ) => { - let __seq_res = __parse_IDENT( - __input, - __state, - __err_state, - __pos, - ); - match __seq_res { - ::peg::RuleResult::Matched( - __pos, - name, - ) => { - ::peg::RuleResult::Matched( - __pos, - (|| { - RuleExpr( - name, - Vec::new(), - ) - .at(sp) - })( - ), - ) - } - ::peg::RuleResult::Failed => { - ::peg::RuleResult::Failed - } - } - } - ::peg::RuleResult::Failed => { - ::peg::RuleResult::Failed - } - } - } - ::peg::RuleResult::Failed => { - ::peg::RuleResult::Failed - } - } + 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 , "error") { :: 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 , "{") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = __parse_LITERAL (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , s) => { { let __seq_res = __parse_sequence (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , seq) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "}") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { ErrorIfExpr (Box :: new (ActionExpr (vec ! [] , None) . at (sp)) , s , Box :: new (seq)) . at (sp) }) ()) } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"}\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"{\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"!\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"error\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } }; match __choice_res { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { let __choice_res = { let __seq_res = __parse_sp( @@ -2877,23 +3479,7 @@ pub mod peg { __err_state, __pos, ); - match __seq_res { - ::peg::RuleResult::Matched( - __pos, - sp, - ) => { - 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 = { 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_rule_arg (__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 , args) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ")") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { RuleExpr (name , args) . at (sp) }) ()) } :: 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 => { - ::peg::RuleResult::Failed - } - } + match __seq_res { :: peg :: RuleResult :: Matched (__pos , sp) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "error_if") { :: 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 , "{") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = __parse_sequence (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , seq1) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "|") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = __parse_LITERAL (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , s) => { { let __seq_res = __parse_sequence (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , seq2) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "}") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { ErrorIfExpr (Box :: new (seq1) , s , Box :: new (seq2)) . at (sp) }) ()) } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"}\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"|\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"{\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"!\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"error_if\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } }; match __choice_res { ::peg::RuleResult::Matched( @@ -2902,6 +3488,9 @@ pub mod peg { ) => ::peg::RuleResult::Matched( __pos, __value, ), + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { let __choice_res = { let __seq_res = __parse_sp( @@ -2910,24 +3499,7 @@ pub mod peg { __err_state, __pos, ); - match __seq_res { - ::peg::RuleResult::Matched( - __pos, - sp, - ) => { - let __seq_res = - __parse_LITERAL( - __input, - __state, - __err_state, - __pos, - ); - match __seq_res { :: peg :: RuleResult :: Matched (__pos , l) => { :: peg :: RuleResult :: Matched (__pos , (|| { LiteralExpr (l) . at (sp) }) ()) } :: peg :: RuleResult :: Failed => :: 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 , "error_unless") { :: 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 , "{") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = __parse_sequence (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , seq1) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "|") { :: peg :: RuleResult :: Matched (__pos , __val) => { { let __seq_res = __parse_LITERAL (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , s) => { { let __seq_res = __parse_sequence (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , seq2) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "}") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { ErrorUnlessExpr (Box :: new (seq1) , s , Box :: new (seq2)) . at (sp) }) ()) } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"}\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"|\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"{\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"!\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"error_unless\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } }; match __choice_res { ::peg::RuleResult::Matched( @@ -2936,17 +3508,25 @@ pub mod peg { ) => ::peg::RuleResult::Matched( __pos, __value, ), + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::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 , } + 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 :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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 :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: 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 :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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 :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , "___") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , __val) } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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 , :: peg :: RuleResult :: Error (..) => :: peg :: RuleResult :: Failed , } + }; + match __seq_res { :: peg :: RuleResult :: Matched (__pos , _) => { { let __seq_res = __parse_sp (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , sp) => { { let __seq_res = __parse_IDENT (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , name) => { :: peg :: RuleResult :: Matched (__pos , (|| { RuleExpr (name , Vec :: new ()) . at (sp) }) ()) } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: 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 } } } } } } } } } + match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: 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_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 = { let mut __repeat_pos = __pos ; let mut __maybe_err = None ; 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 :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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 :: Error (__e) => { __maybe_err = Some (__e) ; break } } } ; let __step_res = __parse_rule_arg (__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 :: Error (__e) => { __maybe_err = Some (__e) ; break ; } } } :: peg :: RuleResult :: Matched (__repeat_pos , __repeat_value) } ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , args) => { match :: peg :: ParseLiteral :: parse_string_literal (__input , __pos , ")") { :: peg :: RuleResult :: Matched (__pos , __val) => { :: peg :: RuleResult :: Matched (__pos , (|| { RuleExpr (name , args) . at (sp) }) ()) } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\")\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"(\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: 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_LITERAL (__input , __state , __err_state , __pos) ; match __seq_res { :: peg :: RuleResult :: Matched (__pos , l) => { :: peg :: RuleResult :: Matched (__pos , (|| { LiteralExpr (l) . at (sp) }) ()) } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: 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 :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: 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 :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\")\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"@\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: 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 :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: 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 :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"@\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: 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 :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"##\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } ; match __choice_res { :: peg :: RuleResult :: Matched (__pos , __value) => :: peg :: RuleResult :: Matched (__pos , __value) , :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: 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 :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\")\"") ; :: peg :: RuleResult :: Failed } } } :: peg :: RuleResult :: Error (__e) => :: peg :: RuleResult :: Error (__e) , :: peg :: RuleResult :: Failed => :: peg :: RuleResult :: Failed , } } } :: peg :: RuleResult :: Error (__e) => { __err_state . mark_error (__e) ; :: peg :: RuleResult :: Error (__e) } :: peg :: RuleResult :: Failed => { __err_state . mark_failure (__pos , "\"(\"") ; :: peg :: RuleResult :: Failed } } } } } } } } } } } } } } } } } } @@ -2983,15 +3563,24 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, (|| RuleArg::Peg(e))()) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\">\""); ::peg::RuleResult::Failed } } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"<\""); ::peg::RuleResult::Failed @@ -3001,11 +3590,13 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { let __seq_res = { let str_start = __pos; match { let mut __repeat_pos = __pos; + let mut __maybe_err = None; let mut __repeat_value = vec![]; loop { let __pos = __repeat_pos; @@ -3018,9 +3609,15 @@ pub mod peg { ::peg::RuleResult::Failed => { break; } + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } } - if __repeat_value.len() >= 1 { + if let Some(__e) = __maybe_err { + ::peg::RuleResult::Error(__e) + } else if __repeat_value.len() >= 1 { ::peg::RuleResult::Matched(__repeat_pos, ()) } else { ::peg::RuleResult::Failed @@ -3031,12 +3628,14 @@ pub mod peg { ::peg::ParseSlice::parse_slice(__input, str_start, __newpos), ), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), } }; match __seq_res { ::peg::RuleResult::Matched(__pos, tt) => { ::peg::RuleResult::Matched(__pos, (|| RuleArg::Rust(tt))()) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } @@ -3053,6 +3652,7 @@ pub mod peg { { let __seq_res = { let mut __repeat_pos = __pos; + let mut __maybe_err = None; let mut __repeat_value = vec![]; loop { let __pos = __repeat_pos; @@ -3065,9 +3665,15 @@ pub mod peg { ::peg::RuleResult::Failed => { break; } + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } } - if __repeat_value.len() >= 1 { + if let Some(__e) = __maybe_err { + ::peg::RuleResult::Error(__e) + } else if __repeat_value.len() >= 1 { ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) } else { ::peg::RuleResult::Failed @@ -3080,6 +3686,7 @@ pub mod peg { operators: operators, })(), ), + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } @@ -3097,6 +3704,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, span) => { let __seq_res = { let mut __repeat_pos = __pos; + let mut __maybe_err = None; let mut __repeat_value = vec![]; loop { let __pos = __repeat_pos; @@ -3109,6 +3717,10 @@ pub mod peg { ::peg::RuleResult::Failed => { break; } + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } } ::peg::RuleResult::Matched(__repeat_pos, __repeat_value) @@ -3128,12 +3740,15 @@ pub mod peg { })(), ) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } @@ -3160,6 +3775,10 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"pub\""); ::peg::RuleResult::Failed @@ -3169,12 +3788,17 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { let __choice_res = match ::peg::ParseLiteral::parse_string_literal(__input, __pos, "crate") { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"crate\""); ::peg::RuleResult::Failed @@ -3184,6 +3808,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { let __choice_res = match ::peg::ParseLiteral::parse_string_literal( __input, __pos, "rule", @@ -3191,6 +3816,10 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"rule\""); ::peg::RuleResult::Failed @@ -3200,6 +3829,7 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => { let __choice_res = match ::peg::ParseLiteral::parse_string_literal( @@ -3208,6 +3838,10 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"use\""); ::peg::RuleResult::Failed @@ -3217,6 +3851,9 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __value) => { ::peg::RuleResult::Matched(__pos, __value) } + ::peg::RuleResult::Error(__e) => { + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { match ::peg::ParseLiteral::parse_string_literal( __input, __pos, "type", @@ -3224,6 +3861,10 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, __val) => { ::peg::RuleResult::Matched(__pos, __val) } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"type\""); ::peg::RuleResult::Failed @@ -3251,12 +3892,14 @@ pub mod peg { __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::Error(e) => ::peg::RuleResult::Error(e), ::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, + ::peg::RuleResult::Error(..) => ::peg::RuleResult::Matched(__pos, ()), + ::peg::RuleResult::Matched(..) => __err_state.mark_failure(__pos, "mismatch"), } }; match __seq_res { @@ -3266,9 +3909,11 @@ pub mod peg { ::peg::RuleResult::Matched(__pos, i) => { ::peg::RuleResult::Matched(__pos, (|| i)()) } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } @@ -3320,13 +3965,19 @@ pub mod peg { ::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::Error(e) => ::peg::RuleResult::Error(e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, }; match __seq_res { ::peg::RuleResult::Matched(__pos, _) => ::peg::RuleResult::Matched(__pos, ()), + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } + ::peg::RuleResult::Error(__e) => { + __err_state.mark_error(__e); + ::peg::RuleResult::Error(__e) + } ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, "\"'\""); ::peg::RuleResult::Failed @@ -3342,6 +3993,7 @@ pub mod peg { #![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::Error(e) => ::peg::RuleResult::Error(e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } diff --git a/peg-macros/grammar.rustpeg b/peg-macros/grammar.rustpeg index 6d8337e..7999002 100644 --- a/peg-macros/grammar.rustpeg +++ b/peg-macros/grammar.rustpeg @@ -125,6 +125,9 @@ rule primary() -> SpannedExpr / sp:sp() "position" "!" "(" ")" { PositionExpr.at(sp) } / sp:sp() "quiet" "!" "{" e:expression() "}" { QuietExpr(Box::new(e)).at(sp) } / sp:sp() "expected" "!" "(" s:LITERAL() ")" { FailExpr(s).at(sp) } + / sp:sp() "error" "!" "{" s:LITERAL() seq:sequence() "}" { ErrorIfExpr(Box::new(ActionExpr(vec![], None).at(sp)), s, Box::new(seq)).at(sp) } + / sp:sp() "error_if" "!" "{" seq1:sequence() "|" s:LITERAL() seq2:sequence() "}" { ErrorIfExpr(Box::new(seq1), s, Box::new(seq2)).at(sp) } + / sp:sp() "error_unless" "!" "{" seq1:sequence() "|" s:LITERAL() seq2:sequence() "}" { ErrorUnlessExpr(Box::new(seq1), s, Box::new(seq2)).at(sp) } / &("_" / "__" / "___") sp:sp() name:IDENT() { RuleExpr(name, Vec::new()).at(sp) } / sp:sp() name:IDENT() "(" args:(rule_arg() ** ",") ")" { RuleExpr(name, args).at(sp) } / sp:sp() l:LITERAL() { LiteralExpr(l).at(sp) } diff --git a/peg-macros/lib.rs b/peg-macros/lib.rs index 6393788..7d799fd 100644 --- a/peg-macros/lib.rs +++ b/peg-macros/lib.rs @@ -20,7 +20,7 @@ mod translate; #[proc_macro] pub fn parser(input: proc_macro::TokenStream) -> proc_macro::TokenStream { let tokens = tokens::FlatTokenStream::new(input.into()); - let grammar = match grammar::peg::peg_grammar(&tokens) { + let grammar = match grammar::peg::peg_grammar(&tokens).into_result() { Ok(g) => g, Err(err) => { let msg = format!("expected {}", err.expected); diff --git a/peg-macros/translate.rs b/peg-macros/translate.rs index e4a8cc6..fd0bceb 100644 --- a/peg-macros/translate.rs +++ b/peg-macros/translate.rs @@ -227,6 +227,10 @@ fn compile_rule(context: &Context, rule: &Rule) -> TokenStream { ::peg::RuleResult::Failed => { println!("[PEG_TRACE] Failed to match rule `{}` at {}", #str_rule_name, loc); } + ::peg::RuleResult::Error(e) => { + let eloc = ::peg::Parse::position_repr(__input, e.location); + println!("[PEG_TRACE] Error matching rule `{}` at {}: {} at {}", #str_rule_name, loc, e.error, eloc); + } } __peg_result @@ -249,6 +253,7 @@ fn compile_rule(context: &Context, rule: &Rule) -> TokenStream { match &entry { &::peg::RuleResult::Matched(..) => println!("[PEG_TRACE] Cached match of rule {} at {}", #str_rule_name, loc), &Failed => println!("[PEG_TRACE] Cached fail of rule {} at {}", #str_rule_name, loc), + &::peg::RuleResult::Error(..) => println!("[PEG_TRACE] Cached error of rule {} at {}", #str_rule_name, loc), }; } } else { @@ -282,10 +287,16 @@ fn compile_rule(context: &Context, rule: &Rule) -> TokenStream { let __current_result = { #wrapped_body }; match __current_result { ::peg::RuleResult::Failed => break, + ::peg::RuleResult::Error(..) => { + __state.#cache_field.insert(__pos, __current_result.clone()); + __last_result = __current_result; + break + }, ::peg::RuleResult::Matched(__current_endpos, _) => match __last_result { ::peg::RuleResult::Matched(__last_endpos, _) if __current_endpos <= __last_endpos => break, - _ => { + ::peg::RuleResult::Error(..) => panic!(), // impossible; we would have broken on previous iteration + ::peg::RuleResult::Failed | ::peg::RuleResult::Matched(..) => { __state.#cache_field.insert(__pos, __current_result.clone()); __last_result = __current_result; }, @@ -308,7 +319,7 @@ fn compile_rule(context: &Context, rule: &Rule) -> TokenStream { } /// Compile a rule into the parsing function which will be exported. -/// Returns `Result`. +/// Returns `ParseResults`. fn compile_rule_export(context: &Context, rule: &Rule) -> TokenStream { let span = rule.span.resolved_at(Span::mixed_site()); @@ -339,7 +350,7 @@ fn compile_rule_export(context: &Context, rule: &Rule) -> TokenStream { quote_spanned! { span => #doc - #visibility fn #name<'input #(, #grammar_lifetime_params)* #(, #ty_params)*>(__input: #input_ty #extra_args_def #(, #rule_params)*) -> ::std::result::Result<#ret_ty, ::peg::error::ParseError>> { + #visibility fn #name<'input #(, #grammar_lifetime_params)* #(, #ty_params)*>(__input: #input_ty #extra_args_def #(, #rule_params)*) -> ::peg::ParseResults<#ret_ty, PositionRepr<#(#grammar_lifetime_params),*>> { #![allow(non_snake_case, unused)] let mut __err_state = ::peg::error::ErrorState::new(::peg::Parse::start(__input)); @@ -347,16 +358,19 @@ fn compile_rule_export(context: &Context, rule: &Rule) -> TokenStream { match #parse_fn(__input, &mut __state, &mut __err_state, ::peg::Parse::start(__input) #extra_args_call #(, #rule_params_call)*) { ::peg::RuleResult::Matched(__pos, __value) => { if #eof_check { - return Ok(__value) + return __err_state.into_matched(__value, __input) } else { __err_state.mark_failure(__pos, "EOF"); } } - _ => () + ::peg::RuleResult::Error(__e) => { + return __err_state.into_error(__e, __input) + } + ::peg::RuleResult::Failed => () } __state = ParseState::new(); - __err_state.reparse_for_error(); + __err_state.reparse_for_failure(); match #parse_fn(__input, &mut __state, &mut __err_state, ::peg::Parse::start(__input) #extra_args_call #(, #rule_params_call)*) { ::peg::RuleResult::Matched(__pos, __value) => { @@ -369,7 +383,7 @@ fn compile_rule_export(context: &Context, rule: &Rule) -> TokenStream { _ => () } - Err(__err_state.into_parse_error(__input)) + __err_state.into_failure(__input) } } } @@ -387,6 +401,7 @@ fn ordered_choice(span: Span, mut rs: impl DoubleEndedIterator ::peg::RuleResult::Matched(__pos, __value), + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => #fallback } }} @@ -421,6 +436,7 @@ fn compile_expr_continuation(context: &Context, e: &SpannedExpr, result_name: Op let __seq_res = #seq_res; match __seq_res { ::peg::RuleResult::Matched(__pos, #result_pat) => { #continuation } + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } }} @@ -431,9 +447,10 @@ fn compile_expr_continuation(context: &Context, e: &SpannedExpr, result_name: Op fn compile_literal_expr(s: &Literal, continuation: TokenStream) -> TokenStream { let span = s.span().resolved_at(Span::mixed_site()); let escaped_str = s.to_string(); - quote_spanned! { span => + quote_spanned! { span => match ::peg::ParseLiteral::parse_string_literal(__input, __pos, #s) { ::peg::RuleResult::Matched(__pos, __val) => { #continuation } + ::peg::RuleResult::Error(__e) => { __err_state.mark_error(__e); ::peg::RuleResult::Error(__e) } // unexpected, but do something sensible ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, #escaped_str); ::peg::RuleResult::Failed } } } @@ -456,7 +473,8 @@ fn compile_pattern_expr(pattern_group: &Group, result_name: Ident, success_res: #pattern => #in_set, _ => #not_in_set, } - ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, #pat_str); ::peg::RuleResult::Failed } + ::peg::RuleResult::Failed => { __err_state.mark_failure(__pos, #pat_str); ::peg::RuleResult::Failed }, + ::peg::RuleResult::Error(__e) => { __err_state.mark_error(__e); ::peg::RuleResult::Error(__e) }, // unexpected, but do something sensible } } } @@ -543,6 +561,7 @@ fn compile_expr(context: &Context, e: &SpannedExpr, result_used: bool) -> TokenS quote_spanned!{ span=> match #func(__input, __state, __err_state, __pos #extra_args_call #(, #rule_args_call)*){ ::peg::RuleResult::Matched(pos, _) => ::peg::RuleResult::Matched(pos, ()), + ::peg::RuleResult::Error(e) => ::peg::RuleResult::Error(e), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, } } @@ -567,6 +586,7 @@ fn compile_expr(context: &Context, e: &SpannedExpr, result_used: bool) -> TokenS match #optional_res { ::peg::RuleResult::Matched(__newpos, __value) => { ::peg::RuleResult::Matched(__newpos, Some(__value)) }, ::peg::RuleResult::Failed => { ::peg::RuleResult::Matched(__pos, None) }, + ::peg::RuleResult::Error(__e) => { ::peg::RuleResult::Error(__e) }, } } } else { @@ -574,6 +594,7 @@ fn compile_expr(context: &Context, e: &SpannedExpr, result_used: bool) -> TokenS match #optional_res { ::peg::RuleResult::Matched(__newpos, _) => { ::peg::RuleResult::Matched(__newpos, ()) }, ::peg::RuleResult::Failed => { ::peg::RuleResult::Matched(__pos, ()) }, + ::peg::RuleResult::Error(__e) => { ::peg::RuleResult::Error(__e) }, } } } @@ -597,6 +618,7 @@ fn compile_expr(context: &Context, e: &SpannedExpr, result_used: bool) -> TokenS match __sep_res { ::peg::RuleResult::Matched(__newpos, _) => { __newpos }, ::peg::RuleResult::Failed => break, + ::peg::RuleResult::Error(__e) => { __maybe_err = Some(__e); break } } }; } @@ -626,7 +648,10 @@ fn compile_expr(context: &Context, e: &SpannedExpr, result_used: bool) -> TokenS let result_check = if let Some(min) = min { quote_spanned!{ span=> - if __repeat_value.len() >= #min { + if let Some(__e) = __maybe_err { + ::peg::RuleResult::Error(__e) + } + else if __repeat_value.len() >= #min { ::peg::RuleResult::Matched(__repeat_pos, #result) } else { ::peg::RuleResult::Failed @@ -638,6 +663,7 @@ fn compile_expr(context: &Context, e: &SpannedExpr, result_used: bool) -> TokenS quote_spanned!{ span=> { let mut __repeat_pos = __pos; + let mut __maybe_err = None; #repeat_vec loop { @@ -655,6 +681,10 @@ fn compile_expr(context: &Context, e: &SpannedExpr, result_used: bool) -> TokenS ::peg::RuleResult::Failed => { break; } + ::peg::RuleResult::Error(__e) => { + __maybe_err = Some(__e); + break; + } } } @@ -671,6 +701,7 @@ fn compile_expr(context: &Context, e: &SpannedExpr, result_used: bool) -> TokenS match __assert_res { ::peg::RuleResult::Matched(_, __value) => ::peg::RuleResult::Matched(__pos, __value), ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + ::peg::RuleResult::Error(..) => ::peg::RuleResult::Failed, } }} } @@ -683,7 +714,8 @@ fn compile_expr(context: &Context, e: &SpannedExpr, result_used: bool) -> TokenS __err_state.suppress_fail -= 1; match __assert_res { ::peg::RuleResult::Failed => ::peg::RuleResult::Matched(__pos, ()), - ::peg::RuleResult::Matched(..) => ::peg::RuleResult::Failed, + ::peg::RuleResult::Error(..) => ::peg::RuleResult::Matched(__pos, ()), + ::peg::RuleResult::Matched(..) => __err_state.mark_failure(__pos, "mismatch"), } }} } @@ -717,6 +749,7 @@ fn compile_expr(context: &Context, e: &SpannedExpr, result_used: bool) -> TokenS match #inner { ::peg::RuleResult::Matched(__newpos, _) => { ::peg::RuleResult::Matched(__newpos, ::peg::ParseSlice::parse_slice(__input, str_start, __newpos)) }, ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), } }} } @@ -735,7 +768,66 @@ fn compile_expr(context: &Context, e: &SpannedExpr, result_used: bool) -> TokenS FailExpr(ref expected) => { quote_spanned! { span => { __err_state.mark_failure(__pos, #expected); ::peg::RuleResult::Failed }} } - + ErrorIfExpr(ref expr1, ref message, ref expr2) => { + let if_res = compile_expr(context, expr1, false); + let recover_res = compile_expr(context, expr2, result_used); + quote_spanned! { span => { + let __if_res = { #if_res }; + match __if_res { + ::peg::RuleResult::Failed => ::peg::RuleResult::Failed, + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), + ::peg::RuleResult::Matched(__newpos, _) => { + // Report error (if any) at start of `expr1`, then consume it by shadowing `__pos`. + let __parse_err = ::peg::error::ParseErr { error: #message, location: __pos }; + let __pos = __newpos; + if __err_state.suppress_fail == 0 { + __err_state.suppress_fail += 1; + let __recover_res = { #recover_res }; + __err_state.suppress_fail -= 1; + + match __recover_res { + ::peg::RuleResult::Matched(__newpos, __value) => { + __err_state.mark_error(__parse_err); + ::peg::RuleResult::Matched(__newpos, __value) + }, + ::peg::RuleResult::Failed | ::peg::RuleResult::Error(..) => ::peg::RuleResult::Error(__parse_err) + } + } else { + ::peg::RuleResult::Error(__parse_err) + } + }, + } + }} + } + ErrorUnlessExpr(ref expr1, ref message, ref expr2) => { + let unless_res = compile_expr(context, expr1, result_used); + let recover_res = compile_expr(context, expr2, result_used); + quote_spanned! { span => { + let __unless_res = { #unless_res }; + match __unless_res { + ::peg::RuleResult::Matched(__newpos, __value) => ::peg::RuleResult::Matched(__newpos, __value), + ::peg::RuleResult::Error(__e) => ::peg::RuleResult::Error(__e), + ::peg::RuleResult::Failed => { + let __parse_err = ::peg::error::ParseErr { error: #message, location: __pos }; + if __err_state.suppress_fail == 0 { + __err_state.suppress_fail += 1; + let __recover_res = { #recover_res }; + __err_state.suppress_fail -= 1; + + match __recover_res { + ::peg::RuleResult::Matched(__newpos, __value) => { + __err_state.mark_error(__parse_err); + ::peg::RuleResult::Matched(__newpos, __value) + }, + ::peg::RuleResult::Failed | ::peg::RuleResult::Error(..) => ::peg::RuleResult::Error(__parse_err) + } + } else { + ::peg::RuleResult::Error(__parse_err) + } + }, + } + }} + } PrecedenceExpr { ref levels } => { let mut pre_rules = Vec::new(); let mut level_code = Vec::new(); diff --git a/peg-runtime/error.rs b/peg-runtime/error.rs index cc017d8..49d5e55 100644 --- a/peg-runtime/error.rs +++ b/peg-runtime/error.rs @@ -1,7 +1,7 @@ //! Parse error reporting -use crate::{Parse, RuleResult}; -use std::collections::HashSet; +use crate::{Parse, RuleResult, ParseResults, ParseResult}; +use std::collections::{HashSet, BTreeSet}; use std::fmt::{self, Debug, Display}; /// A set of literals or names that failed to match @@ -15,6 +15,13 @@ impl ExpectedSet { pub fn tokens<'a>(&'a self) -> impl Iterator + 'a { self.expected.iter().map(|x| *x) } + + /// Construct a new singleton set. + pub(crate) fn singleton(error: &'static str) -> Self { + let mut expected = HashSet::new(); + expected.insert(error); + ExpectedSet { expected } + } } impl Display for ExpectedSet { @@ -38,6 +45,37 @@ impl Display for ExpectedSet { } } +/// A parse error raised by an `error!` expression. +#[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Hash)] +pub struct ParseErr { + /// The location at which the error occurred. + pub location: L, + + /// The error reported at that location. + pub error: &'static str, +} + +impl Copy for ParseErr {} + +impl Display for ParseErr { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> { + write!( + fmt, + "error at {}: {}", + self.location, self.error + ) + } +} + +impl ParseErr { + pub fn into_parseerror(self) -> ParseError { + ParseError { + location: self.location, + expected: ExpectedSet::singleton(self.error) + } + } +} + /// A parse failure. #[derive(PartialEq, Eq, Debug, Clone)] pub struct ParseError { @@ -65,20 +103,24 @@ impl ::std::error::Error for ParseError { } #[doc(hidden)] +#[derive(Debug)] pub struct ErrorState { - /// Furthest failure we've hit so far. + /// Furthest failure we've hit so far. Not used for parse errors. pub max_err_pos: usize, - /// Are we inside a lookahead/quiet block? If so, failure is disabled. + /// Are we inside a lookahead/quiet block? If so, failure/error and recovery rules are disabled. /// Non-zero => yes, to support nested blocks. pub suppress_fail: usize, /// Are we reparsing after a failure? If so, compute and store expected set of all alternative expectations - /// when we are at offset `max_err_pos`. - pub reparsing_on_error: bool, + /// when we are at offset `max_err_pos`. Not used for parse errors. + pub reparsing_on_failure: bool, - /// The set of tokens we expected to find when we hit the failure. Updated when `reparsing_on_error`. + /// The set of tokens we expected to find when we hit the failure. Updated when `reparsing_on_failure`. pub expected: ExpectedSet, + + /// The set of parse errors we have recovered from so far. + pub errors: BTreeSet>, } impl ErrorState { @@ -86,21 +128,22 @@ impl ErrorState { ErrorState { max_err_pos: initial_pos, suppress_fail: 0, - reparsing_on_error: false, + reparsing_on_failure: false, expected: ExpectedSet { expected: HashSet::new(), }, + errors: BTreeSet::new(), } } /// Set up for reparsing to record the details of the furthest failure. - pub fn reparse_for_error(&mut self) { + pub fn reparse_for_failure(&mut self) { self.suppress_fail = 0; - self.reparsing_on_error = true; + self.reparsing_on_failure = true; } #[inline(never)] - pub fn mark_failure_slow_path(&mut self, pos: usize, expected: &'static str) { + fn mark_failure_slow_path(&mut self, pos: usize, expected: &'static str) { if pos == self.max_err_pos { self.expected.expected.insert(expected); } @@ -110,7 +153,7 @@ impl ErrorState { #[inline(always)] pub fn mark_failure(&mut self, pos: usize, expected: &'static str) -> RuleResult<()> { if self.suppress_fail == 0 { - if self.reparsing_on_error { + if self.reparsing_on_failure { self.mark_failure_slow_path(pos, expected); } else if pos > self.max_err_pos { self.max_err_pos = pos; @@ -119,10 +162,50 @@ impl ErrorState { RuleResult::Failed } - pub fn into_parse_error(self, input: &I) -> ParseError { - ParseError { - location: Parse::position_repr(input, self.max_err_pos.into()), - expected: self.expected, + /// Flag an error. + #[inline(always)] + pub fn mark_error(&mut self, error: ParseErr) { + if self.suppress_fail == 0 { + self.errors.insert(error); } } + + /// Build `Matched` parse result. + pub fn into_matched(self, v: T, input: &I) -> ParseResults { + ParseResults { + result: ParseResult::Matched(v), + errors: errors_positioned_in(self.errors, input), + } + } + + /// Build `Failed` parse result. + pub fn into_failure(self, input: &I) -> ParseResults { + ParseResults { + result: ParseResult::Failed(ParseError { + expected: self.expected, + location: input.position_repr(self.max_err_pos) + }), + errors: errors_positioned_in(self.errors, input), + } + } + + /// Build `Error` parse result. + pub fn into_error(self, error: ParseErr, input: &I) -> ParseResults { + ParseResults { + result: ParseResult::Error(ParseErr { + location: input.position_repr(error.location), + error: error.error, + }), + errors: errors_positioned_in(self.errors, input), + } + } +} + +/// Calculate locations of set of parse errors. +fn errors_positioned_in(errors: impl IntoIterator>, input: &I) -> Vec> { + let mut errors_ret = vec![]; + for error in errors { + errors_ret.push(ParseErr { location: input.position_repr(error.location), error: error.error }) + } + errors_ret } diff --git a/peg-runtime/lib.rs b/peg-runtime/lib.rs index b351f24..209e202 100644 --- a/peg-runtime/lib.rs +++ b/peg-runtime/lib.rs @@ -4,10 +4,98 @@ pub mod error; mod slice; pub mod str; + +/// The public API of a parser: the result of the parse, and the set of errors +/// that were recovered from. +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct ParseResults { + /// The result of the parse. + pub result: ParseResult, + + /// The set of errors we recovered from during the parse. + pub errors: Vec>, +} + +impl Display for ParseResults { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> { + if self.errors.is_empty() { + write!(fmt, "{} with no errors.", self.result) + } else { + write!(fmt, "{} after recovery from ", self.result)?; + let mut first = true; + for error in &self.errors { + if first { + write!(fmt, "{}", error)?; + first = false; + } else { + write!(fmt, ", {}", error)?; + } + } + write!(fmt, ".") + } + } +} + +impl ParseResults { + /// Convert into a simple `Result`, treating recovery as failure. + pub fn into_result(self) -> Result> { + match (self.errors, self.result) { + (mut errors, _) if !errors.is_empty() => Err(errors.swap_remove(0).into_parseerror()), + (_, ParseResult::Matched(v)) => Ok(v), + (_, ParseResult::Failed(e)) => Err(e), + (_, ParseResult::Error(e)) => Err(e.into_parseerror()), + } + } + + /// Convert into a simple `Result`, ignoring any recovered errors.. + pub fn recover_result(self) -> Result> { + match self.result { + ParseResult::Matched(v) => Ok(v), + ParseResult::Failed(e) => Err(e), + ParseResult::Error(e) => Err(e.into_parseerror()), + } + } +} + +impl ParseResults { + /// Return the contained match, or panic on failure or error. + pub fn unwrap(self) -> T { + match self.result { + ParseResult::Matched(v) => v, + ParseResult::Failed(e) => panic!("parse failed: {}", e), + ParseResult::Error(e) => panic!("parse {}", e), + } + } +} + +/// The public result of a parser. +/// A parse may succeed, fail, or raise a named error. +#[derive(Clone, PartialEq, Eq, Debug)] +pub enum ParseResult { + /// Success + Matched(T), + + /// Failure + Failed(error::ParseError), + + /// Labelled error at location + Error(error::ParseErr), +} + +impl Display for ParseResult { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> { + match self { + ParseResult::Matched(v) => write!(fmt, "{}", v), + ParseResult::Failed(e) => write!(fmt, "{}", e), + ParseResult::Error(e) => write!(fmt, "{}", e), + } + } +} + /// The result type used internally in the parser. /// /// You'll only need this if implementing the `Parse*` traits for a custom input -/// type. The public API of a parser adapts errors to `std::result::Result`. +/// type. #[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)] pub enum RuleResult { /// Success, with final location @@ -15,6 +103,9 @@ pub enum RuleResult { /// Failure (furthest failure location is not yet known) Failed, + + /// Labelled error at location + Error(error::ParseErr), } /// A type that can be used as input to a parser. diff --git a/src/lib.rs b/src/lib.rs index ec9ae67..5bf79bb 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -15,7 +15,8 @@ //! * Helpful `rustc` error messages for errors in the grammar definition or the //! Rust code embedded within it //! * Rule-level tracing to debug grammars -//! +//! * Error recovery + //! ## Overview //! //! The `peg::parser!{}` macro encloses a `grammar NAME() for INPUT_TYPE { ... @@ -33,9 +34,17 @@ //! //! The macro expands to a Rust `mod` containing a function for each rule marked //! `pub` in the grammar. To parse an input sequence, call one of these -//! functions. The call returns a `Result` carrying either the -//! successfully parsed value returned by the rule, or a `ParseError` containing -//! the failure position and the set of tokens expected there. +//! functions. The call returns a `ParseResults`, which carries either the +//! successfully parsed value, the furthest failure, or an error, along with the +//! set of errors which have been recovered from (if any). +//! +//! * Use `unwrap()` to obtain the successful `T` or panic. +//! * Use `into_result()` to obtain a `Result`. +//! Failures and errors are combined, and recovery is treated as failure. +//! * Use `recover_result()` to obtain a `Result`. +//! Failures and errors are combined, and recovery can result in success. +//! * For full details, match on the `result` field and examine the set of +//! recovered errors in the `errors` field. //! //! ## Example //! @@ -53,7 +62,7 @@ //! } //! //! pub fn main() { -//! assert_eq!(list_parser::list("[1,1,2,3,5,8]"), Ok(vec![1, 1, 2, 3, 5, 8])); +//! assert_eq!(list_parser::list("[1,1,2,3,5,8]").into_result(), Ok(vec![1, 1, 2, 3, 5, 8])); //! } //! ``` //! @@ -123,6 +132,13 @@ //! error messages. //! * `expected!("something")` - fail to match, and report the specified string as expected //! at the current location. +//! * `error!{ "message" e2 }` - report error at this location, then attempt to recover +//! by matching the expression or sequence `e2` and returning its value. +//! If recovery is not required, use `!()` as the recovery expression. +//! * `error_if!{ e1 | "message" e2 }` - attempt to match the expression or sequence `e1`. +//! If it matches, report error at the start of `e1`, then attempt to recover as for `error!{}`. +//! * `error_unless!{ e1 | "message" e2 }` - attempt to match the expression or sequence `e1`. +//! If it does not match, report error, then attempt to recover as for `error!{}`. //! * `precedence!{ ... }` - Parse infix, prefix, or postfix expressions by precedence climbing. //! [(details)](#precedence-climbing) //! @@ -154,6 +170,50 @@ //! form `` (exact), `` (min), `<,m>` (max) or `` (range), where `n` and `m` are either //! integers, or a Rust `usize` expression enclosed in `{}`. //! +//! ### Errors +//! +//! Errors support recovery: they allow the parser to report an error but continue to parse the rest of the +//! input anyway. This means the parser can report more than one error at once, and can provide +//! a sensible parse of most of the input even when there are errors. +//! These are useful in applications like IDEs. +//! +//! There are three expressions for raising an error: +//! +//! * `error!{ "message" e2 }` is the simplest form. It reports an error with the given +//! message at the current location, then attempts to recover by parsing `e2` instead. +//! * `error_if!{ e1 | "message" e2 }` allows the error to be reported at an earlier +//! location. It attempts to parse `e1`; if it succeeds it reports an error with +//! the given message at the start of `e1`, then attempts to recover by parsing `e2` instead. +//! * `error_unless!{ e1 | "message" e2 }` is shorthand for a choice expression. +//! It is useful in order to report an error when an expression fails to match. +//! It attempts to parse `e1`; if it fails it reports an error with the given message +//! at the current location, then attempts to recover by parsing `e2` instead. +//! +//! Error handling works as follows: +//! +//! * When an error is reported, no further alternatives are tried: parsing immediately stops +//! at this point (unlike ordinary failure which causes the parser to try other choices). +//! * The reported error is added to the list of errors. +//! * Then the parser attempts to continue by matching the recovery expression. +//! The resulting value is returned as the result of the `error!` expression; +//! typically this is just a placeholder value of the right type. +//! If the recovery expression fails or encounters an error, recovery is abandoned +//! and the `error!` expression returns the indicated error (`"message"`). +//! +//! There is a worked example in `tests/run-pass/arithmetic_recovery.rs`. +//! +//! This mechanism is based on Sérgio Medeiros and Fabio Mascarenhas, +//! [_Syntax Error Recovery in Parsing Expression Grammars_](https://arxiv.org/abs/1806.11150) +//! and Sérgio Queiroz de Medeiros, Gilney de Azevedo Alvez Junior, and Fabio Mascarenhas, +//! [_Automatic Syntax Error Reporting and Recovery in Parsing Expression Grammars_](https://arxiv.org/abs/1905.02145). +//! The `error_unless!{}` form corresponds to the labelled-expression sugar in the paper. +//! `rust-peg` simplifies tracking the furthest failure position by observing that an error +//! is always reported over a failure even if a previous failure was further through the input; +//! thus there is no need to track the error location separately. +//! `rust-peg` treats failure or error of a recovery expression differently than Medeiros and +//! Mascarenhas - we report the original error (as if there was no recovery expression), +//! whereas Medeiros and Mascarenhas report the failure or error of the recovery expression. +//! //! ### Precedence climbing //! //! `precedence!{ rules... }` provides a convenient way to parse infix, prefix, and postfix diff --git a/tests/run-pass/arithmetic.rs b/tests/run-pass/arithmetic.rs index bf17c59..3b625d4 100644 --- a/tests/run-pass/arithmetic.rs +++ b/tests/run-pass/arithmetic.rs @@ -22,12 +22,12 @@ peg::parser!( grammar arithmetic() for str { }); fn main() { - assert_eq!(expression("1+1"), Ok(2)); - assert_eq!(expression("5*5"), Ok(25)); - assert_eq!(expression("222+3333"), Ok(3555)); - assert_eq!(expression("2+3*4"), Ok(14)); - assert_eq!(expression("(2+2)*3"), Ok(12)); - assert!(expression("(22+)+1").is_err()); - assert!(expression("1++1").is_err()); - assert!(expression("3)+1").is_err()); + assert_eq!(expression("1+1").into_result(), Ok(2)); + assert_eq!(expression("5*5").into_result(), Ok(25)); + assert_eq!(expression("222+3333").into_result(), Ok(3555)); + assert_eq!(expression("2+3*4").into_result(), Ok(14)); + assert_eq!(expression("(2+2)*3").into_result(), Ok(12)); + assert!(expression("(22+)+1").into_result().is_err()); + assert!(expression("1++1").into_result().is_err()); + assert!(expression("3)+1").into_result().is_err()); } diff --git a/tests/run-pass/arithmetic_ast.rs b/tests/run-pass/arithmetic_ast.rs index 267a2e7..355b9bd 100644 --- a/tests/run-pass/arithmetic_ast.rs +++ b/tests/run-pass/arithmetic_ast.rs @@ -35,29 +35,29 @@ grammar arithmetic() for str { }} fn main() { - assert_eq!(arithmetic::expression("1+1"), Ok(Expression::Sum( + assert_eq!(arithmetic::expression("1+1").into_result(), Ok(Expression::Sum( Box::new(Expression::Number(1)), Box::new(Expression::Number(1))) )); - assert_eq!(arithmetic::expression("5*5"), Ok(Expression::Product( + assert_eq!(arithmetic::expression("5*5").into_result(), Ok(Expression::Product( Box::new(Expression::Number(5)), Box::new(Expression::Number(5))) )); - assert_eq!(arithmetic::expression("2+3*4"), Ok(Expression::Sum( + assert_eq!(arithmetic::expression("2+3*4").into_result(), Ok(Expression::Sum( Box::new(Expression::Number(2)), Box::new(Expression::Product( Box::new(Expression::Number(3)), Box::new(Expression::Number(4)) )), ))); - assert_eq!(arithmetic::expression("(2+3) * 4"), Ok(Expression::Product( + assert_eq!(arithmetic::expression("(2+3) * 4").into_result(), Ok(Expression::Product( Box::new(Expression::Sum( Box::new(Expression::Number(2)), Box::new(Expression::Number(3)), )), Box::new(Expression::Number(4)) ))); - assert!(arithmetic::expression("(22+)+1").is_err()); - assert!(arithmetic::expression("1++1").is_err()); - assert!(arithmetic::expression("3)+1").is_err()); + assert!(arithmetic::expression("(22+)+1").into_result().is_err()); + assert!(arithmetic::expression("1++1").into_result().is_err()); + assert!(arithmetic::expression("3)+1").into_result().is_err()); } diff --git a/tests/run-pass/arithmetic_infix.rs b/tests/run-pass/arithmetic_infix.rs index a5a9beb..3f15eb7 100644 --- a/tests/run-pass/arithmetic_infix.rs +++ b/tests/run-pass/arithmetic_infix.rs @@ -22,10 +22,10 @@ peg::parser!( grammar arithmetic() for str { }); fn main() { - assert_eq!(arithmetic::calculate("3+3*3+3"), Ok(15)); - assert_eq!(arithmetic::calculate("2+2^2^2^2/2+2"), Ok(32772)); - assert_eq!(arithmetic::calculate("1024/2/2/2+1"), Ok(129)); - assert_eq!(arithmetic::calculate("1024/(1+1)/2/2+1"), Ok(129)); - assert_eq!(arithmetic::calculate("-1-2*-2"), Ok(3)); - assert_eq!(arithmetic::calculate("1+3!+1"), Ok(8)); + assert_eq!(arithmetic::calculate("3+3*3+3").into_result(), Ok(15)); + assert_eq!(arithmetic::calculate("2+2^2^2^2/2+2").into_result(), Ok(32772)); + assert_eq!(arithmetic::calculate("1024/2/2/2+1").into_result(), Ok(129)); + assert_eq!(arithmetic::calculate("1024/(1+1)/2/2+1").into_result(), Ok(129)); + assert_eq!(arithmetic::calculate("-1-2*-2").into_result(), Ok(3)); + assert_eq!(arithmetic::calculate("1+3!+1").into_result(), Ok(8)); } \ No newline at end of file diff --git a/tests/run-pass/arithmetic_infix_ast.rs b/tests/run-pass/arithmetic_infix_ast.rs index df48fc3..c2ec6dd 100644 --- a/tests/run-pass/arithmetic_infix_ast.rs +++ b/tests/run-pass/arithmetic_infix_ast.rs @@ -22,7 +22,7 @@ pub enum InfixAst { } fn main(){ - assert_eq!(arithmetic::expression("a + b `x` c").unwrap(), + assert_eq!(arithmetic::expression("a + b `x` c").into_result().unwrap(), InfixAst::Add( Box::new(InfixAst::Ident("a".to_owned())), Box::new(InfixAst::Op("x".to_owned(), diff --git a/tests/run-pass/arithmetic_infix_ast_span.rs b/tests/run-pass/arithmetic_infix_ast_span.rs index 918eb0a..4d7165b 100644 --- a/tests/run-pass/arithmetic_infix_ast_span.rs +++ b/tests/run-pass/arithmetic_infix_ast_span.rs @@ -29,7 +29,7 @@ pub enum Op { } fn main(){ - assert_eq!(arithmetic::expression("a+b*c").unwrap(), + assert_eq!(arithmetic::expression("a+b*c").into_result().unwrap(), Node { start: 0, end: 5, diff --git a/tests/run-pass/arithmetic_recovery.rs b/tests/run-pass/arithmetic_recovery.rs new file mode 100644 index 0000000..1641a4b --- /dev/null +++ b/tests/run-pass/arithmetic_recovery.rs @@ -0,0 +1,158 @@ +//! Example: How to use errors and parser recovery for a simple expression language. + +extern crate peg; +use arithmetic::expression; +use std::fmt::{Debug, Display}; + +peg::parser!( grammar arithmetic() for str { + pub rule expression() -> i64 + = + // The whole expression should just be a sum. If there's at least one + // character left over, report it and consume it. + _ v:sum() error_if!{ [_]+ | "unexpected content at end" }? { v } + // If we reach this alternative, we've not found anything at all + // (except possibly whitespace), so report that. + / error!{"empty expression" _} { 0 } + + rule sum() -> i64 + = l:product() "+" _ r:sum() { l+r } + / product() + + rule product() -> i64 + = + // If we see some common symbols, give a special error message explaining + // why they don't work. Then just treat them as if they were addition. + l:atom() ("*" / error_if!{ ['/' | '-' | '^'] | "unsupported operation" }) _ r:product() { l*r } + / atom() + + rule atom() -> i64 + = number() + // A parenthesised expression must end with `)`. If not, assume + // something has gone wrong with the expression and skip everything + // until we find that `)` (or EOF). This is likely to avoid a lot + // of spurious error messages - usually the `)` hasn't been forgotten, + // it's some error earlier. + / "(" _ v:sum() error_unless!{ ")" _ | "missing close paren" skip_to_rparen() } { v } + // Some other character that wasn't expected. Report it. + / error_if!{[_] | "expected atom" _} { 0 } + + rule number() -> i64 + = n:$(['0'..='9']+) _ { n.parse().unwrap() } + + rule _ = quiet!{ [' ' | '\r' | '\n' | '\t']* } + + /// Helper rule for recovery: skip to the next `)`, if any, skipping properly + /// over any balanced `(`...`)`. + rule skip_to_rparen() + = ("(" skip_to_rparen() / [^ '(' | ')'])* ")"? _ + +}); + +/// Check the errors and (recovered) value of the given parse result. +fn assert_recovered( + result: peg::ParseResults, + errors: Vec<&str>, + value: T, +) { + let pretty_result = result.to_string(); + let actual_errors: Vec = result.errors.iter().map(|e| e.to_string()).collect(); + let expected_errors: Vec = errors.iter().map(|e| e.to_string()).collect(); + let recovered_result = result.recover_result(); + assert_eq!( + recovered_result, + Ok(value), + "Should have recovered and got a result\nparsed: {}", + pretty_result + ); + assert_eq!( + actual_errors, expected_errors, + "Unexpected list of recovered errors\nparsed: {}", + pretty_result + ); +} + +fn main() { + assert_eq!(expression("1 + 1").into_result(), Ok(2)); + assert_eq!(expression("1 + 2 + 3").into_result(), Ok(6)); + assert_eq!(expression("5 * 5").into_result(), Ok(25)); + assert_eq!(expression("222 + 3333").into_result(), Ok(3555)); + assert_eq!(expression("2 + 3 * 4").into_result(), Ok(14)); + assert_eq!(expression("2 * 3 + 4").into_result(), Ok(10)); + assert_eq!(expression("(2 + 2) * 3").into_result(), Ok(12)); + assert!(expression("(22 + ) + 1").into_result().is_err()); + assert!(expression("1 + + 1").into_result().is_err()); + assert!(expression("3) + 1").into_result().is_err()); + + // Demonstrate that we spot the error, give a sensible message, + // and continue to give a result anyway. + // offset: 1: 1 2 3 4 + // 1234567890123456789012345678901234567890 + assert_recovered( + expression("1 + 1 1"), + vec!["error at 1:7: unexpected content at end"], + 2, + ); + assert_recovered( + expression("(1 + 1 1)"), + vec!["error at 1:8: missing close paren"], + 2, + ); + assert_recovered( + expression("12 * (5 + 5 a) + 1"), + vec!["error at 1:13: missing close paren"], + 121, + ); + assert_recovered( + expression("12 * (5 + 5 + a) + 1"), + vec!["error at 1:15: expected atom"], + 121, + ); + assert_recovered( + expression("12 * (5 + 5 + atom) + 1"), + vec![ + "error at 1:15: expected atom", + "error at 1:16: missing close paren", + ], + 121, + ); + // skips over nested parentheses + assert_recovered( + expression("12 * (5 + 5 a (thingy + wotsit) b) + 1"), + vec!["error at 1:13: missing close paren"], + 121, + ); + assert_recovered( + expression("12 * (5 + 5 (thingy + wotsit) b) + 1"), + vec!["error at 1:13: missing close paren"], + 121, + ); + // copes with unterminated parentheses + assert_recovered( + expression("12 * (5 + 5 (thingy + wotsit) + 1"), + vec!["error at 1:13: missing close paren"], + 120, + ); + assert_recovered( + expression("42 / 6"), + vec!["error at 1:4: unsupported operation"], + 252, + ); + assert_recovered( + expression(".1 + 10"), + vec![ + "error at 1:1: expected atom", + "error at 1:2: unexpected content at end", + ], + 0, + ); + assert_recovered( + expression("+1"), + vec![ + "error at 1:1: expected atom", + "error at 1:2: unexpected content at end", + ], + 0, + ); + assert_recovered(expression(""), vec!["error at 1:1: empty expression"], 0); + assert_recovered(expression(" "), vec!["error at 1:1: empty expression"], 0); +} diff --git a/tests/run-pass/arithmetic_with_left_recursion.rs b/tests/run-pass/arithmetic_with_left_recursion.rs index f22c1f8..09579f4 100644 --- a/tests/run-pass/arithmetic_with_left_recursion.rs +++ b/tests/run-pass/arithmetic_with_left_recursion.rs @@ -13,8 +13,8 @@ peg::parser!( grammar arithmetic() for str { }); fn main() { - assert_eq!(sum("1"), Ok(1)); - assert_eq!(sum("1+1"), Ok(2)); - assert_eq!(sum("1+1+1"), Ok(3)); - assert_eq!(sum("1+2+3"), Ok(6)); + assert_eq!(sum("1").into_result(), Ok(1)); + assert_eq!(sum("1+1").into_result(), Ok(2)); + assert_eq!(sum("1+1+1").into_result(), Ok(3)); + assert_eq!(sum("1+2+3").into_result(), Ok(6)); } diff --git a/tests/run-pass/borrow_from_input.rs b/tests/run-pass/borrow_from_input.rs index eb82728..9c63dc2 100644 --- a/tests/run-pass/borrow_from_input.rs +++ b/tests/run-pass/borrow_from_input.rs @@ -2,7 +2,7 @@ extern crate peg; peg::parser!(grammar borrows() for str { use std::borrow::{ToOwned, Cow}; - + pub rule borrowed() -> &'input str = $(['a'..='z']+) @@ -14,7 +14,7 @@ peg::parser!(grammar borrows() for str { use self::borrows::*; fn main() { - assert_eq!(borrowed("abcd"), Ok("abcd")); - assert_eq!(&*lifetime_parameter("abcd").unwrap(), "abcd"); - assert_eq!(&*lifetime_parameter("COW").unwrap(), "cow"); + assert_eq!(borrowed("abcd").into_result(), Ok("abcd")); + assert_eq!(&*lifetime_parameter("abcd").into_result().unwrap(), "abcd"); + assert_eq!(&*lifetime_parameter("COW").into_result().unwrap(), "cow"); } \ No newline at end of file diff --git a/tests/run-pass/bytes.rs b/tests/run-pass/bytes.rs index 911ca27..3a0c8de 100644 --- a/tests/run-pass/bytes.rs +++ b/tests/run-pass/bytes.rs @@ -9,5 +9,5 @@ parser!{ } fn main() { - assert_eq!(byteparser::commands(b">asdf\0>xyz\0"), Ok(vec![&b"asdf"[..], &b"xyz"[..]])); + assert_eq!(byteparser::commands(b">asdf\0>xyz\0").into_result(), Ok(vec![&b"asdf"[..], &b"xyz"[..]])); } diff --git a/tests/run-pass/conditional_block.rs b/tests/run-pass/conditional_block.rs index 9383fb7..f202c30 100644 --- a/tests/run-pass/conditional_block.rs +++ b/tests/run-pass/conditional_block.rs @@ -38,18 +38,18 @@ peg::parser!( grammar parse() for str { }); fn main() { - assert_eq!(parse::dec_byte("0"), Ok(0)); - assert_eq!(parse::dec_byte("255"), Ok(255)); - assert_eq!(parse::dec_byte("1"), Ok(1)); - assert!(parse::dec_byte("256").is_err()); - assert!(parse::dec_byte("1234").is_err()); - - assert!(parse::xml("").is_ok()); - assert!(parse::xml("").is_ok()); - assert!(parse::xml("").is_err()); - assert!(parse::xml("").is_err()); - - assert!(parse::return_early("a").unwrap_err().expected.tokens().any(|e| e == "number")); - assert!(parse::return_early("123").unwrap_err().expected.tokens().any(|e| e == "smaller number")); - assert_eq!(parse::return_early("99").unwrap(), 99); + assert_eq!(parse::dec_byte("0").into_result(), Ok(0)); + assert_eq!(parse::dec_byte("255").into_result(), Ok(255)); + assert_eq!(parse::dec_byte("1").into_result(), Ok(1)); + assert!(parse::dec_byte("256").into_result().is_err()); + assert!(parse::dec_byte("1234").into_result().is_err()); + + assert!(parse::xml("").into_result().is_ok()); + assert!(parse::xml("").into_result().is_ok()); + assert!(parse::xml("").into_result().is_err()); + assert!(parse::xml("").into_result().is_err()); + + assert!(parse::return_early("a").into_result().unwrap_err().expected.tokens().any(|e| e == "number")); + assert!(parse::return_early("123").into_result().unwrap_err().expected.tokens().any(|e| e == "smaller number")); + assert_eq!(parse::return_early("99").into_result().unwrap(), 99); } diff --git a/tests/run-pass/crate_import.rs b/tests/run-pass/crate_import.rs index fbdd3fc..7b5c919 100644 --- a/tests/run-pass/crate_import.rs +++ b/tests/run-pass/crate_import.rs @@ -16,5 +16,5 @@ mod types { fn main() { - assert_eq!(foo_parser::foo("foo"), Ok(crate::types::Foo)); + assert_eq!(foo_parser::foo("foo").into_result(), Ok(crate::types::Foo)); } diff --git a/tests/run-pass/errors.rs b/tests/run-pass/errors.rs index 9cdc66b..daf17c6 100644 --- a/tests/run-pass/errors.rs +++ b/tests/run-pass/errors.rs @@ -15,9 +15,9 @@ peg::parser!{ grammar parser() for str { fn main() { // errors at eof - assert_eq!(parser::one_letter("t"), Ok(())); + assert_eq!(parser::one_letter("t").into_result(), Ok(())); - let err = parser::one_letter("tt").unwrap_err(); + let err = parser::one_letter("tt").into_result().unwrap_err(); assert_eq!(err.location.line, 1); assert_eq!(err.location.column, 2); assert_eq!(err.location.offset, 1); @@ -28,7 +28,7 @@ fn main() { aaaa aaaaaa aaaabaaaa -"#).unwrap_err(); +"#).into_result().unwrap_err(); assert_eq!(err.location.line, 4); assert_eq!(err.location.column, 5); @@ -36,27 +36,27 @@ aaaabaaaa assert_eq!(format!("{}", err.expected), r#"one of "\n", "a", EOF"#); // error position reporting - let err = parser::error_pos("aab\n").unwrap_err(); + let err = parser::error_pos("aab\n").into_result().unwrap_err(); assert_eq!(err.location.line, 1); assert_eq!(err.location.column, 3); assert_eq!(err.location.offset, 2); assert_eq!(err.expected.to_string(), r#"one of "\n", "\r", "a", EOF"#); - let err = parser::error_pos("aa\naaaa\nbaaa\n").unwrap_err(); + let err = parser::error_pos("aa\naaaa\nbaaa\n").into_result().unwrap_err(); assert_eq!(err.location.line, 3); assert_eq!(err.location.column, 1); - let err = parser::error_pos("aa\naaaa\naaab\naa").unwrap_err(); + let err = parser::error_pos("aa\naaaa\naaab\naa").into_result().unwrap_err(); assert_eq!(err.location.line, 3); assert_eq!(err.location.column, 4); - let err = parser::error_pos("aa\r\naaaa\r\naaab\r\naa").unwrap_err(); + let err = parser::error_pos("aa\r\naaaa\r\naaab\r\naa").into_result().unwrap_err(); assert_eq!(err.location.line, 3); assert_eq!(err.location.column, 4); - parser::q("a1").unwrap(); - parser::q("a1b2").unwrap(); - let err = parser::q("a1bb").unwrap_err(); + parser::q("a1").into_result().unwrap(); + parser::q("a1b2").into_result().unwrap(); + let err = parser::q("a1bb").into_result().unwrap_err(); assert_eq!(err.location.offset, 2); assert_eq!(err.expected.to_string(), "one of EOF, letter followed by number"); } diff --git a/tests/run-pass/keyval.rs b/tests/run-pass/keyval.rs index 414c79d..b48742c 100644 --- a/tests/run-pass/keyval.rs +++ b/tests/run-pass/keyval.rs @@ -18,5 +18,5 @@ fn main() { let mut expected = HashMap::new(); expected.insert(1, 3); expected.insert(2, 4); - assert_eq!(keyval::keyvals("1:3\n2:4"), Ok(expected)); + assert_eq!(keyval::keyvals("1:3\n2:4").into_result(), Ok(expected)); } diff --git a/tests/run-pass/lifetimes.rs b/tests/run-pass/lifetimes.rs index 3be1521..d22f49d 100644 --- a/tests/run-pass/lifetimes.rs +++ b/tests/run-pass/lifetimes.rs @@ -25,7 +25,7 @@ fn main() { assert_eq!( tokenparser::program( &[Token(&input[0..1]), Token(&input[1..4]), Token(&input[4..5]), Token(&input[5..8]), Token(&input[8..9])], - ), + ).into_result(), Ok(vec!["one", "two"]) ); } diff --git a/tests/run-pass/memoization.rs b/tests/run-pass/memoization.rs index 44b0eaf..795b181 100644 --- a/tests/run-pass/memoization.rs +++ b/tests/run-pass/memoization.rs @@ -11,5 +11,5 @@ peg::parser!{ grammar memo() for str { }} fn main() { - assert_eq!(memo::parse("abc zzz"), Ok(())); + assert_eq!(memo::parse("abc zzz").into_result(), Ok(())); } diff --git a/tests/run-pass/no_eof.rs b/tests/run-pass/no_eof.rs index 77a4ddb..794793d 100644 --- a/tests/run-pass/no_eof.rs +++ b/tests/run-pass/no_eof.rs @@ -9,5 +9,5 @@ parser!{ } fn main() { - assert_eq!(g::foo(b"foobar"), Ok(())); + assert_eq!(g::foo(b"foobar").into_result(), Ok(())); } diff --git a/tests/run-pass/optional.rs b/tests/run-pass/optional.rs index af27e15..6f784b3 100644 --- a/tests/run-pass/optional.rs +++ b/tests/run-pass/optional.rs @@ -10,7 +10,7 @@ peg::parser!( grammar test_grammar() for str { use self::test_grammar::*; fn main() { - assert_eq!(options("abc"), Ok(None)); - assert_eq!(options("abcdef"), Ok(Some(()))); - assert!(options("def").is_err()); + assert_eq!(options("abc").into_result(), Ok(None)); + assert_eq!(options("abcdef").into_result(), Ok(Some(()))); + assert!(options("def").into_result().is_err()); } \ No newline at end of file diff --git a/tests/run-pass/pattern.rs b/tests/run-pass/pattern.rs index 63ec4ae..f8078f8 100644 --- a/tests/run-pass/pattern.rs +++ b/tests/run-pass/pattern.rs @@ -7,12 +7,12 @@ peg::parser!( grammar test() for str { }); fn main() { - assert!(test::alphanumeric("azAZ09").is_ok()); - assert!(test::alphanumeric("@").is_err()); + assert!(test::alphanumeric("azAZ09").into_result().is_ok()); + assert!(test::alphanumeric("@").into_result().is_err()); - assert_eq!(test::inverted_pat("(asdf)"), Ok("asdf")); + assert_eq!(test::inverted_pat("(asdf)").into_result(), Ok("asdf")); - assert_eq!(test::capture("x"), Ok('x')); - assert_eq!(test::capture2("a1"), Ok(('a', '1'))); + assert_eq!(test::capture("x").into_result(), Ok('x')); + assert_eq!(test::capture2("a1").into_result(), Ok(('a', '1'))); } diff --git a/tests/run-pass/pos_neg_assert.rs b/tests/run-pass/pos_neg_assert.rs index 43739e5..727cf2b 100644 --- a/tests/run-pass/pos_neg_assert.rs +++ b/tests/run-pass/pos_neg_assert.rs @@ -12,15 +12,15 @@ peg::parser!( grammar lookahead() for str { fn main() { // negative lookahead - assert!(lookahead::consonants("qwrty").is_ok()); - assert!(lookahead::consonants("rust").is_err()); + assert!(lookahead::consonants("qwrty").into_result().is_ok()); + assert!(lookahead::consonants("rust").into_result().is_err()); // expected characters in negative lookahead should not be reported in parse error messages - let err = lookahead::neg_lookahead_err("ac").err().unwrap(); + let err = lookahead::neg_lookahead_err("ac").into_result().err().unwrap(); assert_eq!(err.expected.tokens().count(), 1, "expected set includes: {}", err.expected); assert_eq!(err.location.offset, 1); // positive lookahead - assert_eq!(lookahead::lookahead_result("abcd"), Ok("abc")); - assert!(lookahead::lookahead_result("abc").is_err()); + assert_eq!(lookahead::lookahead_result("abcd").into_result(), Ok("abc")); + assert!(lookahead::lookahead_result("abc").into_result().is_err()); } diff --git a/tests/run-pass/position.rs b/tests/run-pass/position.rs index 3fe7cca..20dc035 100644 --- a/tests/run-pass/position.rs +++ b/tests/run-pass/position.rs @@ -8,5 +8,5 @@ peg::parser!(grammar test_grammar() for str { use self::test_grammar::*; fn main() { - assert_eq!(position("aaaabbb").unwrap(), (0, 4, 7)); + assert_eq!(position("aaaabbb").into_result().unwrap(), (0, 4, 7)); } diff --git a/tests/run-pass/recovery.rs b/tests/run-pass/recovery.rs new file mode 100644 index 0000000..25bc01b --- /dev/null +++ b/tests/run-pass/recovery.rs @@ -0,0 +1,106 @@ +extern crate peg; + +// The sample grammar from the paper https://arxiv.org/abs/1806.11150 +peg::parser!(grammar test_grammar() for str { + rule _ = quiet!{ [' ' | '\r' | '\n' | '\t']* } + rule name() = ['a'..='z' | 'A'..='Z' | '_'] ['a'..='z' | 'A'..='Z' | '0'..='9' | '_']* + rule number() = ['0'..='9']+ + pub rule prog() + = "public" _ "class" _ name() _ "{" _ "public" _ "static" _ "void" _ "main" _ "(" _ "String" _ "[" _ "]" _ name() _ ")" _ block_stmt() _ "}" _ + rule block_stmt() = "{" _ (stmt() _)* _ error_unless!{ "}" | "missing end of block" skip_to_rcur() } + rule skip_to_rcur() = ("{" skip_to_rcur() / [^ '{' | '}'])* "}" + rule stmt() = if_stmt() / while_stmt() / print_stmt() / dec_stmt() / assign_stmt() / block_stmt() + rule if_stmt() = "if" _ "(" _ exp() _ ")" _ stmt() _ ("else" _ stmt() _)? + rule while_stmt() = "while" _ "(" _ exp() _ ")" _ stmt() + rule dec_stmt() = "int" _ name() _ ( "=" _ exp() _)? ";" + rule assign_stmt() = name() _ "=" _ exp() _ error_unless!{ ";" | "missing semicolon in assignment" } + rule print_stmt() = "System.out.println" _ "(" _ exp() _ ")" _ ";" / "provoke_error" error!{"provoked error" [^';']* ";"} + rule exp() = rel_exp() _ ("==" _ rel_exp() _)* + rule rel_exp() = add_exp() _ ("<" _ add_exp() _)* + rule add_exp() = mul_exp() _ (['+' | '-'] _ mul_exp() _)* + rule mul_exp() = atom_exp() _ (['*' | '/'] _ atom_exp() _)* + rule atom_exp() = "(" _ exp() _ ")" / number() / name() +}); + +use std::fmt::Debug; +use self::test_grammar::*; +use peg::{ParseResults, ParseResult}; +use peg::error::{ParseError, ParseErr}; + +fn expect_failed(results: ParseResults) -> (ParseError, Vec>) { + match results { + ParseResults { result: ParseResult::Failed(fail), errors } => (fail, errors), + r => panic!("Unexpected {:?}", r), + } +} + +fn expect_error(results: ParseResults) -> (ParseErr, Vec>) { + match results { + ParseResults { result: ParseResult::Error(error), errors } => (error, errors), + r => panic!("Unexpected {:?}", r), + } +} + +fn main() { + let input = concat!( + "public class Example {\n", + " public static void main(String[] args) {\n", + " int n = 5;\n", + " int f = 1;\n", + " while (0 < n) {\n", + " f = f * n;\n", + " n = n - 1\n", + " };\n", + " System.out.println(f);\n", + " }\n", + "}\n" + ); + + // Parses successfully, but recovers from two errors. + let r = prog(input); + assert_eq!(r.clone().unwrap(), ()); + assert_eq!(r.errors.len(), 2); + assert_eq!(r.errors[0].location.line, 8); + assert_eq!(r.errors[0].location.column, 5); + assert_eq!(r.errors[0].error, "missing semicolon in assignment"); + assert_eq!(r.errors[1].location.line, 8); + assert_eq!(r.errors[1].location.column, 6); + assert_eq!(r.errors[1].error, "missing end of block"); + + // Alter input slightly to fail on first line. + // No rule to recover from this, so the parse fails. + let input2 = input.replace("public", "private"); + let (fail, errors) = expect_failed(prog(&input2)); + assert_eq!(fail.location.line, 1); + assert_eq!(fail.location.column, 1); + assert_eq!(format!("{}", fail.expected), r#""public""#); + assert_eq!(errors, vec![]); + + // Alter input slightly to strip last two closing braces. + // Recovers from missing semicolon, but then when the block is not closed + // the recovery rule cannot find a '}' to close the block, + // so it returns an error. + let input3 = input.replace("}\n}\n", ""); + let (error, errors) = expect_error(prog(&input3)); + assert_eq!(error.location.line, 8); + assert_eq!(error.location.column, 6); + assert_eq!(error.error, "missing end of block"); + assert_eq!(errors.len(), 1); + assert_eq!(errors[0].error, "missing semicolon in assignment"); + + // Provoke an error using the error! expression. + // Parses successfully, but recovers from three errors. + let input4 = input.replace("int f = 1", "provoke_error with a bunch of stuff that goes here"); + let r = prog(&input4); + assert_eq!(r.clone().unwrap(), ()); + assert_eq!(r.errors.len(), 3); + assert_eq!(r.errors[0].location.line, 4); + assert_eq!(r.errors[0].location.column, 18); + assert_eq!(r.errors[0].error, "provoked error"); + assert_eq!(r.errors[1].location.line, 8); + assert_eq!(r.errors[1].location.column, 5); + assert_eq!(r.errors[1].error, "missing semicolon in assignment"); + assert_eq!(r.errors[2].location.line, 8); + assert_eq!(r.errors[2].location.column, 6); + assert_eq!(r.errors[2].error, "missing end of block"); +} diff --git a/tests/run-pass/renamed_imports.rs b/tests/run-pass/renamed_imports.rs index 1ab673f..825d31a 100644 --- a/tests/run-pass/renamed_imports.rs +++ b/tests/run-pass/renamed_imports.rs @@ -11,5 +11,5 @@ peg::parser!(grammar test_grammar() for str { use self::test_grammar::*; fn main() { - assert_eq!(renamed_imports("").unwrap(), (42, 42)); + assert_eq!(renamed_imports("").into_result().unwrap(), (42, 42)); } \ No newline at end of file diff --git a/tests/run-pass/repeats.rs b/tests/run-pass/repeats.rs index 2277299..28b28a6 100644 --- a/tests/run-pass/repeats.rs +++ b/tests/run-pass/repeats.rs @@ -32,32 +32,32 @@ peg::parser!( grammar repeats() for str { use repeats::*; fn main() { - assert_eq!(list("5"), Ok(vec![5])); - assert_eq!(list("1,2,3,4"), Ok(vec![1,2,3,4])); - - assert!(repeat_n("123").is_err()); - assert_eq!(repeat_n("1234"), Ok(vec![1,2,3,4])); - assert!(repeat_n("12345").is_err()); - - assert!(repeat_min("").is_err()); - assert!(repeat_min("1").is_err()); - assert_eq!(repeat_min("12"), Ok(vec![1,2])); - assert_eq!(repeat_min("123"), Ok(vec![1,2,3])); - - assert_eq!(repeat_max(""), Ok(vec![])); - assert_eq!(repeat_max("1"), Ok(vec![1])); - assert_eq!(repeat_max("12"), Ok(vec![1,2])); - assert!(repeat_max("123").is_err()); - - assert!(repeat_min_max("").is_err()); - assert!(repeat_min_max("1").is_err()); - assert_eq!(repeat_min_max("12"), Ok(vec![1,2])); - assert_eq!(repeat_min_max("123"), Ok(vec![1,2,3])); - assert!(repeat_min_max("1234").is_err()); - - assert!(repeat_sep_3("1,2").is_err()); - assert!(repeat_sep_3("1,2,3,4").is_err()); - assert_eq!(repeat_sep_3("1,2,3"), Ok(vec![1,2,3])); - - assert_eq!(repeat_variable("1a3abc222"), Ok(vec!["a", "abc", "22"])); + assert_eq!(list("5").into_result(), Ok(vec![5])); + assert_eq!(list("1,2,3,4").into_result(), Ok(vec![1,2,3,4])); + + assert!(repeat_n("123").into_result().is_err()); + assert_eq!(repeat_n("1234").into_result(), Ok(vec![1,2,3,4])); + assert!(repeat_n("12345").into_result().is_err()); + + assert!(repeat_min("").into_result().is_err()); + assert!(repeat_min("1").into_result().is_err()); + assert_eq!(repeat_min("12").into_result(), Ok(vec![1,2])); + assert_eq!(repeat_min("123").into_result(), Ok(vec![1,2,3])); + + assert_eq!(repeat_max("").into_result(), Ok(vec![])); + assert_eq!(repeat_max("1").into_result(), Ok(vec![1])); + assert_eq!(repeat_max("12").into_result(), Ok(vec![1,2])); + assert!(repeat_max("123").into_result().is_err()); + + assert!(repeat_min_max("").into_result().is_err()); + assert!(repeat_min_max("1").into_result().is_err()); + assert_eq!(repeat_min_max("12").into_result(), Ok(vec![1,2])); + assert_eq!(repeat_min_max("123").into_result(), Ok(vec![1,2,3])); + assert!(repeat_min_max("1234").into_result().is_err()); + + assert!(repeat_sep_3("1,2").into_result().is_err()); + assert!(repeat_sep_3("1,2,3,4").into_result().is_err()); + assert_eq!(repeat_sep_3("1,2,3").into_result(), Ok(vec![1,2,3])); + + assert_eq!(repeat_variable("1a3abc222").into_result(), Ok(vec!["a", "abc", "22"])); } \ No newline at end of file diff --git a/tests/run-pass/rule_args.rs b/tests/run-pass/rule_args.rs index 3ee698d..9d1670f 100644 --- a/tests/run-pass/rule_args.rs +++ b/tests/run-pass/rule_args.rs @@ -16,11 +16,11 @@ peg::parser!( grammar ra() for str { rule ident() = ['a'..='z']+ rule _ = [' ']* pub rule ifelse() = keyword("if") _ ident() _ keyword("then") _ ident() _ keyword("else") _ ident() - + pub rule repeated_a(i: usize) = ['a']*<{i}> rule i(literal: &'static str) = input:$([_]*<{literal.len()}>) {? if input.eq_ignore_ascii_case(literal) { Ok(()) } else { Err(literal) } } - + pub rule test_i() = i("foo") i("bar") rule recursive(r: rule<()>) = " " recursive(r) // Issue #226 @@ -36,19 +36,19 @@ peg::parser!( grammar ra() for str { use ra::*; fn main() { - assert_eq!(list("1,2,3,4"), Ok(vec![1,2,3,4])); - assert_eq!(array("[1,1,2,3,5,]"), Ok(vec![1,1,2,3,5])); + assert_eq!(list("1,2,3,4").into_result(), Ok(vec![1,2,3,4])); + assert_eq!(array("[1,1,2,3,5,]").into_result(), Ok(vec![1,1,2,3,5])); - assert!(ifelse("if foo then x else y").is_ok()); - assert!(ifelse("iffoothenxelsey").is_err()); + assert!(ifelse("if foo then x else y").into_result().is_ok()); + assert!(ifelse("iffoothenxelsey").into_result().is_err()); - assert!(repeated_a("aa", 2).is_ok()); - assert!(repeated_a("aaa", 2).is_err()); - assert!(repeated_a("aaaaa", 5).is_ok()); + assert!(repeated_a("aa", 2).into_result().is_ok()); + assert!(repeated_a("aaa", 2).into_result().is_err()); + assert!(repeated_a("aaaaa", 5).into_result().is_ok()); - assert!(test_i("fOoBaR").is_ok()); - assert!(test_i("fOoBaZ").is_err()); - assert!(test_i("fOoX").is_err()); + assert!(test_i("fOoBaR").into_result().is_ok()); + assert!(test_i("fOoBaZ").into_result().is_err()); + assert!(test_i("fOoX").into_result().is_err()); - use_complex_args("").ok(); + use_complex_args("").into_result().ok(); } \ No newline at end of file diff --git a/tests/run-pass/test-hygiene.rs b/tests/run-pass/test-hygiene.rs index d22d166..9bb394c 100644 --- a/tests/run-pass/test-hygiene.rs +++ b/tests/run-pass/test-hygiene.rs @@ -23,6 +23,6 @@ realpeg::parser!{ } fn main() { - assert_eq!(p::number("12345"), Ok(12345.0)) + assert_eq!(p::number("12345").into_result(), Ok(12345.0)) } diff --git a/tests/run-pass/tokens.rs b/tests/run-pass/tokens.rs index 46efdfc..747870a 100644 --- a/tests/run-pass/tokens.rs +++ b/tests/run-pass/tokens.rs @@ -13,5 +13,5 @@ peg::parser!{ } fn main() { - assert_eq!(tokenparser::list(&[Token::Open, Token::Number(5), Token::Comma, Token::Number(7), Token::Close]), Ok((5, 7))); + assert_eq!(tokenparser::list(&[Token::Open, Token::Number(5), Token::Comma, Token::Number(7), Token::Close]).into_result(), Ok((5, 7))); } diff --git a/tests/run-pass/utf8.rs b/tests/run-pass/utf8.rs index e0c8905..af1f0e0 100644 --- a/tests/run-pass/utf8.rs +++ b/tests/run-pass/utf8.rs @@ -11,5 +11,5 @@ use self::test_grammar::*; // threw an ugly panic!() when we compared unequal character // boundaries.. this popped up while parsing unicode fn main() { - assert!(boundaries("f↙↙↙↙").is_err()); + assert!(boundaries("f↙↙↙↙").into_result().is_err()); }