[INFO] fetching crate rust-jexl3 0.1.1...
[INFO] checking rust-jexl3-0.1.1 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] extracting crate rust-jexl3 0.1.1 into /workspace/builds/worker-5-tc2/source
[INFO] started tweaking crates.io crate rust-jexl3 0.1.1
[INFO] removed 0 missing examples
[INFO] removed 0 missing tests
[INFO] finished tweaking crates.io crate rust-jexl3 0.1.1
[INFO] tweaked toml for crates.io crate rust-jexl3 0.1.1 written to /workspace/builds/worker-5-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate rust-jexl3 0.1.1 on toolchain a5689b034ad287112f709693384a37f1377eb9cc
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate rust-jexl3 0.1.1 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr] warning: `package.homepage` is redundant with `package.repository`
[INFO] [stderr]   --> Cargo.toml:56:12
[INFO] [stderr]    |
[INFO] [stderr] 56 | homepage = "https://github.com/Junsung-Kim/rust-jexl3"
[INFO] [stderr]    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 61 | repository = "https://github.com/Junsung-Kim/rust-jexl3"
[INFO] [stderr]    |              -------------------------------------------
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::redundant_homepage` is set to `warn` by default
[INFO] [stderr] help: consider removing `package.homepage`
[INFO] [stderr] warning: `rust-jexl3` (manifest) generated 1 warning
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 82308f961bd46803deaae22fcf575eda6775d5a9da076c3845b98aae7b91e998
[INFO] running `Command { std: "docker" "start" "82308f961bd46803deaae22fcf575eda6775d5a9da076c3845b98aae7b91e998", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "82308f961bd46803deaae22fcf575eda6775d5a9da076c3845b98aae7b91e998", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-w" "/opt/rustwide/workdir" "--user" "0:0" "82308f961bd46803deaae22fcf575eda6775d5a9da076c3845b98aae7b91e998" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "82308f961bd46803deaae22fcf575eda6775d5a9da076c3845b98aae7b91e998", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-w" "/opt/rustwide/workdir" "--user" "0:0" "82308f961bd46803deaae22fcf575eda6775d5a9da076c3845b98aae7b91e998" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr] warning: `package.homepage` is redundant with `package.repository`
[INFO] [stderr]   --> Cargo.toml:56:12
[INFO] [stderr]    |
[INFO] [stderr] 56 | homepage = "https://github.com/Junsung-Kim/rust-jexl3"
[INFO] [stderr]    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 61 | repository = "https://github.com/Junsung-Kim/rust-jexl3"
[INFO] [stderr]    |              -------------------------------------------
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::redundant_homepage` is set to `warn` by default
[INFO] [stderr] help: consider removing `package.homepage`
[INFO] [stderr] warning: `rust-jexl3` (manifest) generated 1 warning
[INFO] [stderr]     Checking memchr v2.8.3
[INFO] [stderr]     Checking regex-syntax v0.8.11
[INFO] [stderr]     Checking num-integer v0.1.47
[INFO] [stderr]     Checking num-bigint v0.5.1
[INFO] [stderr]     Checking aho-corasick v1.1.5
[INFO] [stderr]     Checking regex-automata v0.4.18
[INFO] [stderr]     Checking fancy-regex v0.14.0
[INFO] [stderr]     Checking rust-jexl3 v0.1.1 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]   --> src/parser/parser_gen.rs:28:83
[INFO] [stdout]    |
[INFO] [stdout] 28 |             if match self.jj_2_1(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]    |                                                                                   ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 28 -             if match self.jj_2_1(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 28 +             if match self.jj_2_1(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 28 -             if match self.jj_2_1(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 28 +             if match self.jj_2_1(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]   --> src/parser/parser_gen.rs:32:82
[INFO] [stdout]    |
[INFO] [stdout] 32 |             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]    |                                                                                  ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 32 -             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 32 +             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 32 -             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 32 +             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]   --> src/parser/parser_gen.rs:34:94
[INFO] [stdout]    |
[INFO] [stdout] 34 |         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]    |                                                                                              ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 34 -         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 34 +         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 34 -         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 34 +         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]   --> src/parser/parser_gen.rs:38:103
[INFO] [stdout]    |
[INFO] [stdout] 38 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]    |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 38 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 38 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 38 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 38 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]   --> src/parser/parser_gen.rs:75:79
[INFO] [stdout]    |
[INFO] [stdout] 75 |         if match self.jj_2_2(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]    |                                                                               ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 75 -         if match self.jj_2_2(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 75 +         if match self.jj_2_2(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 75 -         if match self.jj_2_2(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 75 +         if match self.jj_2_2(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]   --> src/parser/parser_gen.rs:76:83
[INFO] [stdout]    |
[INFO] [stdout] 76 |             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]    |                                                                                   ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 76 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 76 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 76 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 76 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]   --> src/parser/parser_gen.rs:79:94
[INFO] [stdout]    |
[INFO] [stdout] 79 |         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]    |                                                                                              ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 79 -         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 79 +         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 79 -         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 79 +         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]   --> src/parser/parser_gen.rs:83:103
[INFO] [stdout]    |
[INFO] [stdout] 83 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]    |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 83 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 83 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 83 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 83 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:119:99
[INFO] [stdout]     |
[INFO] [stdout] 119 |         t = match self.jj_consume_token(ANNOTATION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 119 -         t = match self.jj_consume_token(ANNOTATION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 119 +         t = match self.jj_consume_token(ANNOTATION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 119 -         t = match self.jj_consume_token(ANNOTATION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 119 +         t = match self.jj_consume_token(ANNOTATION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:120:88
[INFO] [stdout]     |
[INFO] [stdout] 120 |         if match self.jj_2_3(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                        ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 120 -         if match self.jj_2_3(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 120 +         if match self.jj_2_3(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 120 -         if match self.jj_2_3(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 120 +         if match self.jj_2_3(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:121:82
[INFO] [stdout]     |
[INFO] [stdout] 121 |             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 121 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 121 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 121 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 121 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:127:103
[INFO] [stdout]     |
[INFO] [stdout] 127 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 127 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 127 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 127 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 127 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:162:83
[INFO] [stdout]     |
[INFO] [stdout] 162 |             match self.annotation() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 162 -             match self.annotation() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 162 +             match self.annotation() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 162 -             match self.annotation() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 162 +             match self.annotation() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:163:92
[INFO] [stdout]     |
[INFO] [stdout] 163 |             if match self.jj_2_4(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 163 -             if match self.jj_2_4(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 163 +             if match self.jj_2_4(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 163 -             if match self.jj_2_4(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 163 +             if match self.jj_2_4(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:171:86
[INFO] [stdout]     |
[INFO] [stdout] 171 |                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 171 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 171 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 171 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 171 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:175:91
[INFO] [stdout]     |
[INFO] [stdout] 175 |                     if match self.jj_2_5(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 175 -                     if match self.jj_2_5(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 175 +                     if match self.jj_2_5(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 175 -                     if match self.jj_2_5(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 175 +                     if match self.jj_2_5(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:176:94
[INFO] [stdout]     |
[INFO] [stdout] 176 |                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 176 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 176 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 176 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 176 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:178:111
[INFO] [stdout]     |
[INFO] [stdout] 178 |                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 178 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 178 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 178 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 178 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:284:99
[INFO] [stdout]     |
[INFO] [stdout] 284 |         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 284 -         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 284 +         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 284 -         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 284 +         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:287:83
[INFO] [stdout]     |
[INFO] [stdout] 287 |             if match self.jj_2_8(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 287 -             if match self.jj_2_8(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 287 +             if match self.jj_2_8(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 287 -             if match self.jj_2_8(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 287 +             if match self.jj_2_8(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:291:82
[INFO] [stdout]     |
[INFO] [stdout] 291 |             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 291 -             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 291 +             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 291 -             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 291 +             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:294:99
[INFO] [stdout]     |
[INFO] [stdout] 294 |         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 294 -         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 294 +         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 294 -         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 294 +         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:332:83
[INFO] [stdout]     |
[INFO] [stdout] 332 |             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 332 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 332 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 332 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 332 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:375:95
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 375 -         let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 375 +         let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 375 -         let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 375 +         let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:376:99
[INFO] [stdout]     |
[INFO] [stdout] 376 |         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 376 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 376 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 376 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 376 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:377:79
[INFO] [stdout]     |
[INFO] [stdout] 377 |         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 377 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 377 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 377 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 377 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:378:99
[INFO] [stdout]     |
[INFO] [stdout] 378 |         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 378 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 378 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 378 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 378 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:382:86
[INFO] [stdout]     |
[INFO] [stdout] 382 |                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 382 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 382 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 382 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 382 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:386:92
[INFO] [stdout]     |
[INFO] [stdout] 386 |                     if match self.jj_2_10(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 386 -                     if match self.jj_2_10(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 386 +                     if match self.jj_2_10(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 -                     if match self.jj_2_10(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 386 +                     if match self.jj_2_10(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:387:94
[INFO] [stdout]     |
[INFO] [stdout] 387 |                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 387 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 387 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 387 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 387 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:389:111
[INFO] [stdout]     |
[INFO] [stdout] 389 |                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 389 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 389 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 389 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 389 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:396:84
[INFO] [stdout]     |
[INFO] [stdout] 396 |             if match self.jj_2_11(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 396 -             if match self.jj_2_11(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 396 +             if match self.jj_2_11(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 396 -             if match self.jj_2_11(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 396 +             if match self.jj_2_11(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:400:101
[INFO] [stdout]     |
[INFO] [stdout] 400 |             let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                     ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 400 -             let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 400 +             let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 400 -             let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 400 +             let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:401:99
[INFO] [stdout]     |
[INFO] [stdout] 401 |             let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 401 -             let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 401 +             let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 401 -             let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 401 +             let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:402:103
[INFO] [stdout]     |
[INFO] [stdout] 402 |             let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 402 -             let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 402 +             let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 402 -             let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 402 +             let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:403:83
[INFO] [stdout]     |
[INFO] [stdout] 403 |             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 403 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 403 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 403 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 403 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:404:103
[INFO] [stdout]     |
[INFO] [stdout] 404 |             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 404 -             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 404 +             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 404 -             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 404 +             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:408:90
[INFO] [stdout]     |
[INFO] [stdout] 408 |                         match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                          ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 408 -                         match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 408 +                         match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 408 -                         match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 408 +                         match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:412:96
[INFO] [stdout]     |
[INFO] [stdout] 412 |                         if match self.jj_2_12(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 412 -                         if match self.jj_2_12(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 412 +                         if match self.jj_2_12(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 412 -                         if match self.jj_2_12(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 412 +                         if match self.jj_2_12(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:413:98
[INFO] [stdout]     |
[INFO] [stdout] 413 | ...                   match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 413 -                             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 413 +                             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 413 -                             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 413 +                             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:415:115
[INFO] [stdout]     |
[INFO] [stdout] 415 | ...                   let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 415 -                             let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 415 +                             let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 415 -                             let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 415 +                             let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:425:109
[INFO] [stdout]     |
[INFO] [stdout] 425 |                     let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 425 -                     let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 425 +                     let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 425 -                     let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 425 +                     let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:429:98
[INFO] [stdout]     |
[INFO] [stdout] 429 | ...                   match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                        ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 429 -                                 match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 429 +                                 match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 429 -                                 match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 429 +                                 match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:433:104
[INFO] [stdout]     |
[INFO] [stdout] 433 | ...                   if match self.jj_2_13(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 433 -                                 if match self.jj_2_13(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 433 +                                 if match self.jj_2_13(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 433 -                                 if match self.jj_2_13(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 433 +                                 if match self.jj_2_13(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:434:106
[INFO] [stdout]     |
[INFO] [stdout] 434 | ...                   match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 434 -                                     match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 434 +                                     match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 434 -                                     match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 434 +                                     match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:436:123
[INFO] [stdout]     |
[INFO] [stdout] 436 | ...                   let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 436 -                                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 436 +                                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 436 -                                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 436 +                                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:479:98
[INFO] [stdout]     |
[INFO] [stdout] 479 |         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 479 -         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 479 +         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 479 -         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 479 +         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:480:99
[INFO] [stdout]     |
[INFO] [stdout] 480 |         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 480 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 480 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 480 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 480 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:481:79
[INFO] [stdout]     |
[INFO] [stdout] 481 |         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 481 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 481 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 481 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 481 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:482:99
[INFO] [stdout]     |
[INFO] [stdout] 482 |         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 482 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 482 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 482 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 482 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:487:86
[INFO] [stdout]     |
[INFO] [stdout] 487 |                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 487 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 487 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 487 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 487 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:491:92
[INFO] [stdout]     |
[INFO] [stdout] 491 |                     if match self.jj_2_14(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 491 -                     if match self.jj_2_14(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 491 +                     if match self.jj_2_14(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 491 -                     if match self.jj_2_14(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 491 +                     if match self.jj_2_14(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:492:94
[INFO] [stdout]     |
[INFO] [stdout] 492 |                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 492 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 492 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 492 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 492 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:494:111
[INFO] [stdout]     |
[INFO] [stdout] 494 |                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 494 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 494 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 494 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 494 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:503:103
[INFO] [stdout]     |
[INFO] [stdout] 503 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 503 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 503 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 503 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 503 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:537:95
[INFO] [stdout]     |
[INFO] [stdout] 537 |         let _ = match self.jj_consume_token(DO) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 537 -         let _ = match self.jj_consume_token(DO) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 537 +         let _ = match self.jj_consume_token(DO) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 537 -         let _ = match self.jj_consume_token(DO) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 537 +         let _ = match self.jj_consume_token(DO) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:542:86
[INFO] [stdout]     |
[INFO] [stdout] 542 |                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 542 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 542 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 542 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 542 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:546:92
[INFO] [stdout]     |
[INFO] [stdout] 546 |                     if match self.jj_2_15(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 546 -                     if match self.jj_2_15(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 546 +                     if match self.jj_2_15(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 546 -                     if match self.jj_2_15(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 546 +                     if match self.jj_2_15(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:547:94
[INFO] [stdout]     |
[INFO] [stdout] 547 |                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 547 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 547 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 547 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 547 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:549:111
[INFO] [stdout]     |
[INFO] [stdout] 549 |                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 549 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 549 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 549 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 549 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:555:98
[INFO] [stdout]     |
[INFO] [stdout] 555 |         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 555 -         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 555 +         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 555 -         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 555 +         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:556:99
[INFO] [stdout]     |
[INFO] [stdout] 556 |         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 556 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 556 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 556 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 556 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:557:79
[INFO] [stdout]     |
[INFO] [stdout] 557 |         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 557 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 557 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 557 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 557 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:558:99
[INFO] [stdout]     |
[INFO] [stdout] 558 |         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 558 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 558 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 558 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 558 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:562:103
[INFO] [stdout]     |
[INFO] [stdout] 562 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 562 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 562 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 562 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 562 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:596:99
[INFO] [stdout]     |
[INFO] [stdout] 596 |         let _ = match self.jj_consume_token(RETURN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 596 -         let _ = match self.jj_consume_token(RETURN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 596 +         let _ = match self.jj_consume_token(RETURN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 596 -         let _ = match self.jj_consume_token(RETURN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 596 +         let _ = match self.jj_consume_token(RETURN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:597:89
[INFO] [stdout]     |
[INFO] [stdout] 597 |         match self.expression_statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 597 -         match self.expression_statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 597 +         match self.expression_statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 597 -         match self.expression_statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 597 +         match self.expression_statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:630:97
[INFO] [stdout]     |
[INFO] [stdout] 630 |         t = match self.jj_consume_token(CONTINUE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 630 -         t = match self.jj_consume_token(CONTINUE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 630 +         t = match self.jj_consume_token(CONTINUE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 630 -         t = match self.jj_consume_token(CONTINUE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 630 +         t = match self.jj_consume_token(CONTINUE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:634:103
[INFO] [stdout]     |
[INFO] [stdout] 634 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 634 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 634 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 634 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 634 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:636:51
[INFO] [stdout]     |
[INFO] [stdout] 636 |         if self.loop_count == 0 { break 'try1 Err(self.throw_parsing_exception(false, Some(t)).into()); }
[INFO] [stdout]     |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 636 -         if self.loop_count == 0 { break 'try1 Err(self.throw_parsing_exception(false, Some(t)).into()); }
[INFO] [stdout] 636 +         if self.loop_count == 0 { break 'try1 Err(self.throw_parsing_exception(false, Some(t))); }
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 636 -         if self.loop_count == 0 { break 'try1 Err(self.throw_parsing_exception(false, Some(t)).into()); }
[INFO] [stdout] 636 +         if self.loop_count == 0 { break 'try1 Err(<PErr as Into<_>>::into(self.throw_parsing_exception(false, Some(t)))); }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:661:94
[INFO] [stdout]     |
[INFO] [stdout] 661 |         t = match self.jj_consume_token(BREAK) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 661 -         t = match self.jj_consume_token(BREAK) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 661 +         t = match self.jj_consume_token(BREAK) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 661 -         t = match self.jj_consume_token(BREAK) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 661 +         t = match self.jj_consume_token(BREAK) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:665:103
[INFO] [stdout]     |
[INFO] [stdout] 665 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 665 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 665 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 665 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 665 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:667:51
[INFO] [stdout]     |
[INFO] [stdout] 667 |         if self.loop_count == 0 { break 'try1 Err(self.throw_parsing_exception(false, Some(t)).into()); }
[INFO] [stdout]     |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 667 -         if self.loop_count == 0 { break 'try1 Err(self.throw_parsing_exception(false, Some(t)).into()); }
[INFO] [stdout] 667 +         if self.loop_count == 0 { break 'try1 Err(self.throw_parsing_exception(false, Some(t))); }
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 667 -         if self.loop_count == 0 { break 'try1 Err(self.throw_parsing_exception(false, Some(t)).into()); }
[INFO] [stdout] 667 +         if self.loop_count == 0 { break 'try1 Err(<PErr as Into<_>>::into(self.throw_parsing_exception(false, Some(t)))); }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:692:96
[INFO] [stdout]     |
[INFO] [stdout] 692 |         let _ = match self.jj_consume_token(FOR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 692 -         let _ = match self.jj_consume_token(FOR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 692 +         let _ = match self.jj_consume_token(FOR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 692 -         let _ = match self.jj_consume_token(FOR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 692 +         let _ = match self.jj_consume_token(FOR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:693:99
[INFO] [stdout]     |
[INFO] [stdout] 693 |         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 693 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 693 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 693 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 693 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:694:81
[INFO] [stdout]     |
[INFO] [stdout] 694 |         match self.for_each_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 694 -         match self.for_each_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 694 +         match self.for_each_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 694 -         match self.for_each_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 694 +         match self.for_each_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:695:98
[INFO] [stdout]     |
[INFO] [stdout] 695 |         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 695 -         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 695 +         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 695 -         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 695 +         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:696:79
[INFO] [stdout]     |
[INFO] [stdout] 696 |         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 696 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 696 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 696 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 696 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:697:99
[INFO] [stdout]     |
[INFO] [stdout] 697 |         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 697 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 697 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 697 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 697 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:702:86
[INFO] [stdout]     |
[INFO] [stdout] 702 |                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 702 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 702 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 702 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 702 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:706:92
[INFO] [stdout]     |
[INFO] [stdout] 706 |                     if match self.jj_2_16(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 706 -                     if match self.jj_2_16(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 706 +                     if match self.jj_2_16(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 706 -                     if match self.jj_2_16(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 706 +                     if match self.jj_2_16(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:707:94
[INFO] [stdout]     |
[INFO] [stdout] 707 |                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 707 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 707 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 707 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 707 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:709:111
[INFO] [stdout]     |
[INFO] [stdout] 709 |                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 709 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 709 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 709 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 709 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:718:103
[INFO] [stdout]     |
[INFO] [stdout] 718 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 718 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 718 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 718 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 718 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:756:108
[INFO] [stdout]     |
[INFO] [stdout] 756 |                     let _ = match self.jj_consume_token(VAR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 756 -                     let _ = match self.jj_consume_token(VAR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 756 +                     let _ = match self.jj_consume_token(VAR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 756 -                     let _ = match self.jj_consume_token(VAR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 756 +                     let _ = match self.jj_consume_token(VAR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:757:92
[INFO] [stdout]     |
[INFO] [stdout] 757 |                     match self.declare_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 757 -                     match self.declare_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 757 +                     match self.declare_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 757 -                     match self.declare_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 757 +                     match self.declare_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:761:95
[INFO] [stdout]     |
[INFO] [stdout] 761 |                     match self.identifier(true) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 761 -                     match self.identifier(true) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 761 +                     match self.identifier(true) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 761 -                     match self.identifier(true) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 761 +                     match self.identifier(true) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:765:107
[INFO] [stdout]     |
[INFO] [stdout] 765 |                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 765 -                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 765 +                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 765 -                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 765 +                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:807:91
[INFO] [stdout]     |
[INFO] [stdout] 807 |                     match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]     |                                                                                           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 807 -                     match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 807 +                     match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 807 -                     match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 807 +                     match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:846:99
[INFO] [stdout]     |
[INFO] [stdout] 846 |         t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 846 -         t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 846 +         t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 846 -         t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 846 +         t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:850:103
[INFO] [stdout]     |
[INFO] [stdout] 850 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 850 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 850 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 850 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 850 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:852:95
[INFO] [stdout]     |
[INFO] [stdout] 852 |         match self.declare_variable(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 852 -         match self.declare_variable(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 852 +         match self.declare_variable(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 852 -         match self.declare_variable(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 852 +         match self.declare_variable(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:992:95
[INFO] [stdout]     |
[INFO] [stdout] 992 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]     |                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 992 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 992 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 992 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 992 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1023:95
[INFO] [stdout]      |
[INFO] [stdout] 1023 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout]      |                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1023 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 1023 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1023 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 1023 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1054:95
[INFO] [stdout]      |
[INFO] [stdout] 1054 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout]      |                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1054 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 1054 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1054 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 1054 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1085:95
[INFO] [stdout]      |
[INFO] [stdout] 1085 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout]      |                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1085 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout] 1085 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1085 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout] 1085 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1116:95
[INFO] [stdout]      |
[INFO] [stdout] 1116 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout]      |                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1116 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout] 1116 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1116 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout] 1116 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1147:95
[INFO] [stdout]      |
[INFO] [stdout] 1147 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout]      |                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1147 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 1147 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1147 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 1147 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1178:95
[INFO] [stdout]      |
[INFO] [stdout] 1178 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout]      |                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1178 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout] 1178 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1178 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout] 1178 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1209:95
[INFO] [stdout]      |
[INFO] [stdout] 1209 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try9 Err(__e.into()) };
[INFO] [stdout]      |                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1209 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try9 Err(__e.into()) };
[INFO] [stdout] 1209 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try9 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1209 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try9 Err(__e.into()) };
[INFO] [stdout] 1209 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try9 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1240:96
[INFO] [stdout]      |
[INFO] [stdout] 1240 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1240 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(__e.into()) };
[INFO] [stdout] 1240 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1240 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(__e.into()) };
[INFO] [stdout] 1240 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1291:103
[INFO] [stdout]      |
[INFO] [stdout] 1291 | ...                   match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout]      |                                                                                             ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1291 -                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 1291 +                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1291 -                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 1291 +                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1322:103
[INFO] [stdout]      |
[INFO] [stdout] 1322 | ...                   match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout]      |                                                                                             ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1322 -                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 1322 +                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1322 -                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 1322 +                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1353:103
[INFO] [stdout]      |
[INFO] [stdout] 1353 | ...                   match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout]      |                                                                                             ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1353 -                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout] 1353 +                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1353 -                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout] 1353 +                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1427:99
[INFO] [stdout]      |
[INFO] [stdout] 1427 |             match self.conditional_and_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1427 -             match self.conditional_and_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 1427 +             match self.conditional_and_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1427 -             match self.conditional_and_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 1427 +             match self.conditional_and_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1488:96
[INFO] [stdout]      |
[INFO] [stdout] 1488 |             match self.inclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1488 -             match self.inclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 1488 +             match self.inclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1488 -             match self.inclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 1488 +             match self.inclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1534:96
[INFO] [stdout]      |
[INFO] [stdout] 1534 |             match self.exclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1534 -             match self.exclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 1534 +             match self.exclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1534 -             match self.exclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 1534 +             match self.exclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1580:87
[INFO] [stdout]      |
[INFO] [stdout] 1580 |             match self.and_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]      |                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1580 -             match self.and_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 1580 +             match self.and_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1580 -             match self.and_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 1580 +             match self.and_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1626:92
[INFO] [stdout]      |
[INFO] [stdout] 1626 |             match self.equality_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]      |                                                                                            ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1626 -             match self.equality_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 1626 +             match self.equality_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1626 -             match self.equality_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 1626 +             match self.equality_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1682:114
[INFO] [stdout]      |
[INFO] [stdout] 1682 | ...                   match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                        ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1682 -                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 1682 +                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1682 -                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 1682 +                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1728:114
[INFO] [stdout]      |
[INFO] [stdout] 1728 | ...                   match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                        ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1728 -                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout] 1728 +                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1728 -                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout] 1728 +                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1759:114
[INFO] [stdout]      |
[INFO] [stdout] 1759 | ...                   match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                        ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1759 -                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 1759 +                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1759 -                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 1759 +                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1828:112
[INFO] [stdout]      |
[INFO] [stdout] 1828 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1828 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 1828 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1828 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 1828 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1874:112
[INFO] [stdout]      |
[INFO] [stdout] 1874 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1874 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout] 1874 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1874 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout] 1874 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1920:112
[INFO] [stdout]      |
[INFO] [stdout] 1920 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1920 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout] 1920 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1920 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout] 1920 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1966:113
[INFO] [stdout]      |
[INFO] [stdout] 1966 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1966 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(__e.into()) };
[INFO] [stdout] 1966 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1966 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(__e.into()) };
[INFO] [stdout] 1966 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1997:113
[INFO] [stdout]      |
[INFO] [stdout] 1997 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try11 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1997 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try11 Err(__e.into()) };
[INFO] [stdout] 1997 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try11 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1997 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try11 Err(__e.into()) };
[INFO] [stdout] 1997 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try11 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2028:113
[INFO] [stdout]      |
[INFO] [stdout] 2028 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try12 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2028 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try12 Err(__e.into()) };
[INFO] [stdout] 2028 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try12 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2028 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try12 Err(__e.into()) };
[INFO] [stdout] 2028 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try12 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2059:113
[INFO] [stdout]      |
[INFO] [stdout] 2059 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try13 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2059 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try13 Err(__e.into()) };
[INFO] [stdout] 2059 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try13 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2059 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try13 Err(__e.into()) };
[INFO] [stdout] 2059 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try13 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2090:113
[INFO] [stdout]      |
[INFO] [stdout] 2090 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try14 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2090 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try14 Err(__e.into()) };
[INFO] [stdout] 2090 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try14 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2090 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try14 Err(__e.into()) };
[INFO] [stdout] 2090 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try14 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2121:113
[INFO] [stdout]      |
[INFO] [stdout] 2121 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try15 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2121 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try15 Err(__e.into()) };
[INFO] [stdout] 2121 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try15 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2121 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try15 Err(__e.into()) };
[INFO] [stdout] 2121 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try15 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2152:113
[INFO] [stdout]      |
[INFO] [stdout] 2152 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try16 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2152 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try16 Err(__e.into()) };
[INFO] [stdout] 2152 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try16 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2152 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try16 Err(__e.into()) };
[INFO] [stdout] 2152 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try16 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2208:110
[INFO] [stdout]      |
[INFO] [stdout] 2208 |                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                              ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2208 -                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 2208 +                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2208 -                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 2208 +                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2239:110
[INFO] [stdout]      |
[INFO] [stdout] 2239 |                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                              ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2239 -                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 2239 +                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2239 -                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 2239 +                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2296:101
[INFO] [stdout]      |
[INFO] [stdout] 2296 |                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2296 -                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 2296 +                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2296 -                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 2296 +                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2342:101
[INFO] [stdout]      |
[INFO] [stdout] 2342 |                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2342 -                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout] 2342 +                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2342 -                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout] 2342 +                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2388:101
[INFO] [stdout]      |
[INFO] [stdout] 2388 |                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2388 -                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 2388 +                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2388 -                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 2388 +                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2433:97
[INFO] [stdout]      |
[INFO] [stdout] 2433 |                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2433 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 2433 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2433 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 2433 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2464:97
[INFO] [stdout]      |
[INFO] [stdout] 2464 |                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2464 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 2464 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2464 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 2464 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2495:97
[INFO] [stdout]      |
[INFO] [stdout] 2495 |                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2495 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 2495 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2495 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 2495 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2541:97
[INFO] [stdout]      |
[INFO] [stdout] 2541 |                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2541 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout] 2541 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2541 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout] 2541 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2572:97
[INFO] [stdout]      |
[INFO] [stdout] 2572 |                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2572 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 2572 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2572 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 2572 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2603:97
[INFO] [stdout]      |
[INFO] [stdout] 2603 |                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2603 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout] 2603 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2603 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout] 2603 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2651:111
[INFO] [stdout]      |
[INFO] [stdout] 2651 |                     t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2651 -                     t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2651 +                     t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2651 -                     t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2651 +                     t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2655:115
[INFO] [stdout]      |
[INFO] [stdout] 2655 |                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2655 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2655 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2655 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2655 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2661:109
[INFO] [stdout]      |
[INFO] [stdout] 2661 |                     t = match self.jj_consume_token(REGISTER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                             ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2661 -                     t = match self.jj_consume_token(REGISTER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2661 +                     t = match self.jj_consume_token(REGISTER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2661 -                     t = match self.jj_consume_token(REGISTER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2661 +                     t = match self.jj_consume_token(REGISTER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2665:115
[INFO] [stdout]      |
[INFO] [stdout] 2665 |                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2665 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2665 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2665 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2665 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2671:107
[INFO] [stdout]      |
[INFO] [stdout] 2671 |                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                           ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2671 -                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2671 +                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2671 -                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2671 +                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2701:100
[INFO] [stdout]      |
[INFO] [stdout] 2701 |         ns = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2701 -         ns = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2701 +         ns = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2701 -         ns = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2701 +         ns = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2702:98
[INFO] [stdout]      |
[INFO] [stdout] 2702 |         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                  ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2702 -         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2702 +         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2702 -         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2702 +         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2703:100
[INFO] [stdout]      |
[INFO] [stdout] 2703 |         id = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2703 -         id = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2703 +         id = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2703 -         id = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2703 +         id = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2707:103
[INFO] [stdout]      |
[INFO] [stdout] 2707 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2707 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2707 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2707 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2707 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2779:104
[INFO] [stdout]      |
[INFO] [stdout] 2779 |         let _ = match self.jj_consume_token(NAN_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                        ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2779 -         let _ = match self.jj_consume_token(NAN_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2779 +         let _ = match self.jj_consume_token(NAN_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2779 -         let _ = match self.jj_consume_token(NAN_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2779 +         let _ = match self.jj_consume_token(NAN_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2783:103
[INFO] [stdout]      |
[INFO] [stdout] 2783 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2783 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2783 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2783 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2783 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2785:91
[INFO] [stdout]      |
[INFO] [stdout] 2785 |         match self.set_real(jjtn000, "NaN") { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                           ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2785 -         match self.set_real(jjtn000, "NaN") { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2785 +         match self.set_real(jjtn000, "NaN") { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2785 -         match self.set_real(jjtn000, "NaN") { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2785 +         match self.set_real(jjtn000, "NaN") { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2809:97
[INFO] [stdout]      |
[INFO] [stdout] 2809 |         let _ = match self.jj_consume_token(NULL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2809 -         let _ = match self.jj_consume_token(NULL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2809 +         let _ = match self.jj_consume_token(NULL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2809 -         let _ = match self.jj_consume_token(NULL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2809 +         let _ = match self.jj_consume_token(NULL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2836:109
[INFO] [stdout]      |
[INFO] [stdout] 2836 |                     let _ = match self.jj_consume_token(TRUE) { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                             ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2836 -                     let _ = match self.jj_consume_token(TRUE) { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 2836 +                     let _ = match self.jj_consume_token(TRUE) { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2836 -                     let _ = match self.jj_consume_token(TRUE) { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 2836 +                     let _ = match self.jj_consume_token(TRUE) { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2858:110
[INFO] [stdout]      |
[INFO] [stdout] 2858 |                     let _ = match self.jj_consume_token(FALSE) { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                              ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2858 -                     let _ = match self.jj_consume_token(FALSE) { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 2858 +                     let _ = match self.jj_consume_token(FALSE) { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2858 -                     let _ = match self.jj_consume_token(FALSE) { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 2858 +                     let _ = match self.jj_consume_token(FALSE) { Ok(__v) => __v, Err(__e) => break 'try3 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2891:104
[INFO] [stdout]      |
[INFO] [stdout] 2891 |         t = match self.jj_consume_token(INTEGER_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                        ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2891 -         t = match self.jj_consume_token(INTEGER_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2891 +         t = match self.jj_consume_token(INTEGER_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2891 -         t = match self.jj_consume_token(INTEGER_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2891 +         t = match self.jj_consume_token(INTEGER_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2895:103
[INFO] [stdout]      |
[INFO] [stdout] 2895 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2895 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2895 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2895 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2895 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2897:120
[INFO] [stdout]      |
[INFO] [stdout] 2897 | ...   { let __s = self.image(t); match self.set_natural(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) }; }
[INFO] [stdout]      |                                                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2897 -         { let __s = self.image(t); match self.set_natural(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) }; }
[INFO] [stdout] 2897 +         { let __s = self.image(t); match self.set_natural(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) }; }
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2897 -         { let __s = self.image(t); match self.set_natural(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) }; }
[INFO] [stdout] 2897 +         { let __s = self.image(t); match self.set_natural(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) }; }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2922:102
[INFO] [stdout]      |
[INFO] [stdout] 2922 |         t = match self.jj_consume_token(FLOAT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2922 -         t = match self.jj_consume_token(FLOAT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2922 +         t = match self.jj_consume_token(FLOAT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2922 -         t = match self.jj_consume_token(FLOAT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2922 +         t = match self.jj_consume_token(FLOAT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2926:103
[INFO] [stdout]      |
[INFO] [stdout] 2926 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2926 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2926 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2926 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2926 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2928:117
[INFO] [stdout]      |
[INFO] [stdout] 2928 |         { let __s = self.image(t); match self.set_real(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) }; }
[INFO] [stdout]      |                                                                                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2928 -         { let __s = self.image(t); match self.set_real(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) }; }
[INFO] [stdout] 2928 +         { let __s = self.image(t); match self.set_real(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) }; }
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2928 -         { let __s = self.image(t); match self.set_real(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) }; }
[INFO] [stdout] 2928 +         { let __s = self.image(t); match self.set_real(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) }; }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2953:103
[INFO] [stdout]      |
[INFO] [stdout] 2953 |         t = match self.jj_consume_token(STRING_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2953 -         t = match self.jj_consume_token(STRING_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2953 +         t = match self.jj_consume_token(STRING_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2953 -         t = match self.jj_consume_token(STRING_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2953 +         t = match self.jj_consume_token(STRING_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2957:103
[INFO] [stdout]      |
[INFO] [stdout] 2957 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2957 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2957 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2957 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2957 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2984:101
[INFO] [stdout]      |
[INFO] [stdout] 2984 |         t = match self.jj_consume_token(JXLT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2984 -         t = match self.jj_consume_token(JXLT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2984 +         t = match self.jj_consume_token(JXLT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2984 -         t = match self.jj_consume_token(JXLT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2984 +         t = match self.jj_consume_token(JXLT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2988:103
[INFO] [stdout]      |
[INFO] [stdout] 2988 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2988 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2988 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2988 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2988 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3015:102
[INFO] [stdout]      |
[INFO] [stdout] 3015 |         t = match self.jj_consume_token(REGEX_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3015 -         t = match self.jj_consume_token(REGEX_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3015 +         t = match self.jj_consume_token(REGEX_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3015 -         t = match self.jj_consume_token(REGEX_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3015 +         t = match self.jj_consume_token(REGEX_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3019:103
[INFO] [stdout]      |
[INFO] [stdout] 3019 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3019 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3019 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3019 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3019 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3021:96
[INFO] [stdout]      |
[INFO] [stdout] 3021 |         match self.set_regex_literal(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3021 -         match self.set_regex_literal(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3021 +         match self.set_regex_literal(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3021 -         match self.set_regex_literal(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3021 +         match self.set_regex_literal(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3045:100
[INFO] [stdout]      |
[INFO] [stdout] 3045 |         let _ = match self.jj_consume_token(ELIPSIS) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3045 -         let _ = match self.jj_consume_token(ELIPSIS) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3045 +         let _ = match self.jj_consume_token(ELIPSIS) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3045 -         let _ = match self.jj_consume_token(ELIPSIS) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3045 +         let _ = match self.jj_consume_token(ELIPSIS) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3069:101
[INFO] [stdout]      |
[INFO] [stdout] 3069 |         let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3069 -         let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3069 +         let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3069 -         let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3069 +         let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3073:97
[INFO] [stdout]      |
[INFO] [stdout] 3073 |                     match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3073 -                     match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3073 +                     match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3073 -                     match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3073 +                     match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3077:92
[INFO] [stdout]      |
[INFO] [stdout] 3077 |                     if match self.jj_2_22(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]      |                                                                                            ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3077 -                     if match self.jj_2_22(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3077 +                     if match self.jj_2_22(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3077 -                     if match self.jj_2_22(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3077 +                     if match self.jj_2_22(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3078:95
[INFO] [stdout]      |
[INFO] [stdout] 3078 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3078 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3078 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3078 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3078 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3080:100
[INFO] [stdout]      |
[INFO] [stdout] 3080 | ...                   if match self.jj_2_21(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]      |                                                                                              ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3080 -                             if match self.jj_2_21(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3080 +                             if match self.jj_2_21(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3080 -                             if match self.jj_2_21(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3080 +                             if match self.jj_2_21(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3084:118
[INFO] [stdout]      |
[INFO] [stdout] 3084 | ...                   let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3084 -                             let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3084 +                             let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3084 -                             let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3084 +                             let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3085:99
[INFO] [stdout]      |
[INFO] [stdout] 3085 | ...                   match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                             ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3085 -                             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3085 +                             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3085 -                             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3085 +                             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3092:122
[INFO] [stdout]      |
[INFO] [stdout] 3092 | ...                   let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3092 -                                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3092 +                                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3092 -                                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3092 +                                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3093:109
[INFO] [stdout]      |
[INFO] [stdout] 3093 | ...                   match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3093 -                                 match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3093 +                                 match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3093 -                                 match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3093 +                                 match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3103:101
[INFO] [stdout]      |
[INFO] [stdout] 3103 |         let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3103 -         let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3103 +         let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3103 -         let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3103 +         let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3135:99
[INFO] [stdout]      |
[INFO] [stdout] 3135 |         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3135 -         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3135 +         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3135 -         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3135 +         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3136:80
[INFO] [stdout]      |
[INFO] [stdout] 3136 |         if match self.jj_2_23(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]      |                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3136 -         if match self.jj_2_23(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3136 +         if match self.jj_2_23(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3136 -         if match self.jj_2_23(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3136 +         if match self.jj_2_23(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3137:82
[INFO] [stdout]      |
[INFO] [stdout] 3137 |             match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                  ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3137 -             match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3137 +             match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3137 -             match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3137 +             match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3149:106
[INFO] [stdout]      |
[INFO] [stdout] 3149 |                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3149 -                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3149 +                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3149 -                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3149 +                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3150:86
[INFO] [stdout]      |
[INFO] [stdout] 3150 |                 match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3150 -                 match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3150 +                 match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3150 -                 match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3150 +                 match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3156:114
[INFO] [stdout]      |
[INFO] [stdout] 3156 |                         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                  ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3156 -                         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3156 +                         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3156 -                         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3156 +                         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3160:111
[INFO] [stdout]      |
[INFO] [stdout] 3160 |                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3160 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3160 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3160 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3160 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3166:99
[INFO] [stdout]      |
[INFO] [stdout] 3166 |         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3166 -         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3166 +         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3166 -         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3166 +         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3198:79
[INFO] [stdout]      |
[INFO] [stdout] 3198 |         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3198 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3198 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3198 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3198 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3199:98
[INFO] [stdout]      |
[INFO] [stdout] 3199 |         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                  ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3199 -         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3199 +         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3199 -         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3199 +         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3200:79
[INFO] [stdout]      |
[INFO] [stdout] 3200 |         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3200 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3200 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3200 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3200 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3232:99
[INFO] [stdout]      |
[INFO] [stdout] 3232 |         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3232 -         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3232 +         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3232 -         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3232 +         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3233:80
[INFO] [stdout]      |
[INFO] [stdout] 3233 |         if match self.jj_2_24(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]      |                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3233 -         if match self.jj_2_24(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3233 +         if match self.jj_2_24(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3233 -         if match self.jj_2_24(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3233 +         if match self.jj_2_24(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3234:83
[INFO] [stdout]      |
[INFO] [stdout] 3234 |             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3234 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3234 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3234 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3234 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3246:106
[INFO] [stdout]      |
[INFO] [stdout] 3246 |                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3246 -                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3246 +                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3246 -                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3246 +                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3247:87
[INFO] [stdout]      |
[INFO] [stdout] 3247 |                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3247 -                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3247 +                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3247 -                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3247 +                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3251:99
[INFO] [stdout]      |
[INFO] [stdout] 3251 |         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3251 -         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3251 +         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3251 -         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3251 +         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3283:99
[INFO] [stdout]      |
[INFO] [stdout] 3283 |         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3283 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3283 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3283 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3283 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3284:80
[INFO] [stdout]      |
[INFO] [stdout] 3284 |         if match self.jj_2_25(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]      |                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3284 -         if match self.jj_2_25(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3284 +         if match self.jj_2_25(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3284 -         if match self.jj_2_25(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3284 +         if match self.jj_2_25(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3285:83
[INFO] [stdout]      |
[INFO] [stdout] 3285 |             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3285 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3285 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3285 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3285 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3297:106
[INFO] [stdout]      |
[INFO] [stdout] 3297 |                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3297 -                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3297 +                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3297 -                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3297 +                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3298:87
[INFO] [stdout]      |
[INFO] [stdout] 3298 |                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3298 -                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3298 +                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3298 -                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3298 +                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3302:99
[INFO] [stdout]      |
[INFO] [stdout] 3302 |         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3302 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3302 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3302 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3302 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3356:82
[INFO] [stdout]      |
[INFO] [stdout] 3356 |             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                  ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3356 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3356 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3356 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3356 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3385:82
[INFO] [stdout]      |
[INFO] [stdout] 3385 |             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]      |                                                                                  ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3385 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 3385 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3385 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 3385 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3421:96
[INFO] [stdout]      |
[INFO] [stdout] 3421 |         let _ = match self.jj_consume_token(NEW) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3421 -         let _ = match self.jj_consume_token(NEW) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3421 +         let _ = match self.jj_consume_token(NEW) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3421 -         let _ = match self.jj_consume_token(NEW) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3421 +         let _ = match self.jj_consume_token(NEW) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3422:99
[INFO] [stdout]      |
[INFO] [stdout] 3422 |         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3422 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3422 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3422 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3422 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3423:79
[INFO] [stdout]      |
[INFO] [stdout] 3423 |         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3423 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3423 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3423 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3423 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3435:102
[INFO] [stdout]      |
[INFO] [stdout] 3435 |             let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3435 -             let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3435 +             let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3435 -             let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3435 +             let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3436:83
[INFO] [stdout]      |
[INFO] [stdout] 3436 |             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3436 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3436 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3436 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3436 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3438:99
[INFO] [stdout]      |
[INFO] [stdout] 3438 |         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3438 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3438 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3438 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3438 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3562:113
[INFO] [stdout]      |
[INFO] [stdout] 3562 |                     let _ = match self.jj_consume_token(FUNCTION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3562 -                     let _ = match self.jj_consume_token(FUNCTION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3562 +                     let _ = match self.jj_consume_token(FUNCTION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3562 -                     let _ = match self.jj_consume_token(FUNCTION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3562 +                     let _ = match self.jj_consume_token(FUNCTION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3563:91
[INFO] [stdout]      |
[INFO] [stdout] 3563 |                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                           ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3563 -                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3563 +                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3563 -                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3563 +                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3564:86
[INFO] [stdout]      |
[INFO] [stdout] 3564 |                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3564 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3564 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3564 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3564 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3568:115
[INFO] [stdout]      |
[INFO] [stdout] 3568 |                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3568 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3568 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3568 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3568 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3575:91
[INFO] [stdout]      |
[INFO] [stdout] 3575 |                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                           ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3575 -                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3575 +                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3575 -                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3575 +                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3576:111
[INFO] [stdout]      |
[INFO] [stdout] 3576 |                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3576 -                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3576 +                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3576 -                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3576 +                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3577:86
[INFO] [stdout]      |
[INFO] [stdout] 3577 |                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3577 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3577 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3577 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3577 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3581:115
[INFO] [stdout]      |
[INFO] [stdout] 3581 |                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3581 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3581 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3581 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3581 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3588:90
[INFO] [stdout]      |
[INFO] [stdout] 3588 |                     match self.parameter() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3588 -                     match self.parameter() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3588 +                     match self.parameter() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3588 -                     match self.parameter() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3588 +                     match self.parameter() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3589:111
[INFO] [stdout]      |
[INFO] [stdout] 3589 |                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3589 -                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3589 +                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3589 -                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3589 +                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3590:86
[INFO] [stdout]      |
[INFO] [stdout] 3590 |                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3590 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3590 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3590 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3590 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3594:115
[INFO] [stdout]      |
[INFO] [stdout] 3594 |                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3594 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3594 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3594 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3594 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3600:107
[INFO] [stdout]      |
[INFO] [stdout] 3600 |                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                           ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3600 -                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3600 +                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3600 -                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3600 +                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3755:127
[INFO] [stdout]      |
[INFO] [stdout] 3755 | ...                   match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3755 -                                     match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 3755 +                                     match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3755 -                                     match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 3755 +                                     match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try3 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3783:127
[INFO] [stdout]      |
[INFO] [stdout] 3783 | ...                   match self.jjtree_close_node_scope(jjtn002) { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3783 -                                     match self.jjtree_close_node_scope(jjtn002) { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 3783 +                                     match self.jjtree_close_node_scope(jjtn002) { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3783 -                                     match self.jjtree_close_node_scope(jjtn002) { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 3783 +                                     match self.jjtree_close_node_scope(jjtn002) { Ok(__v) => __v, Err(__e) => break 'try4 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3811:127
[INFO] [stdout]      |
[INFO] [stdout] 3811 | ...                   match self.jjtree_close_node_scope(jjtn003) { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3811 -                                     match self.jjtree_close_node_scope(jjtn003) { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout] 3811 +                                     match self.jjtree_close_node_scope(jjtn003) { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3811 -                                     match self.jjtree_close_node_scope(jjtn003) { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout] 3811 +                                     match self.jjtree_close_node_scope(jjtn003) { Ok(__v) => __v, Err(__e) => break 'try5 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3851:127
[INFO] [stdout]      |
[INFO] [stdout] 3851 | ...                   match self.jjtree_close_node_scope(jjtn004) { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3851 -                                     match self.jjtree_close_node_scope(jjtn004) { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 3851 +                                     match self.jjtree_close_node_scope(jjtn004) { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3851 -                                     match self.jjtree_close_node_scope(jjtn004) { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 3851 +                                     match self.jjtree_close_node_scope(jjtn004) { Ok(__v) => __v, Err(__e) => break 'try7 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3879:127
[INFO] [stdout]      |
[INFO] [stdout] 3879 | ...                   match self.jjtree_close_node_scope(jjtn005) { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3879 -                                     match self.jjtree_close_node_scope(jjtn005) { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout] 3879 +                                     match self.jjtree_close_node_scope(jjtn005) { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3879 -                                     match self.jjtree_close_node_scope(jjtn005) { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout] 3879 +                                     match self.jjtree_close_node_scope(jjtn005) { Ok(__v) => __v, Err(__e) => break 'try8 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3907:127
[INFO] [stdout]      |
[INFO] [stdout] 3907 | ...                   match self.jjtree_close_node_scope(jjtn006) { Ok(__v) => __v, Err(__e) => break 'try9 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3907 -                                     match self.jjtree_close_node_scope(jjtn006) { Ok(__v) => __v, Err(__e) => break 'try9 Err(__e.into()) };
[INFO] [stdout] 3907 +                                     match self.jjtree_close_node_scope(jjtn006) { Ok(__v) => __v, Err(__e) => break 'try9 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3907 -                                     match self.jjtree_close_node_scope(jjtn006) { Ok(__v) => __v, Err(__e) => break 'try9 Err(__e.into()) };
[INFO] [stdout] 3907 +                                     match self.jjtree_close_node_scope(jjtn006) { Ok(__v) => __v, Err(__e) => break 'try9 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3950:105
[INFO] [stdout]      |
[INFO] [stdout] 3950 |             let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                         ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3950 -             let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3950 +             let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3950 -             let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3950 +             let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3951:83
[INFO] [stdout]      |
[INFO] [stdout] 3951 |             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3951 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3951 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3951 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3951 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3952:105
[INFO] [stdout]      |
[INFO] [stdout] 3952 |             let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                         ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3952 -             let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3952 +             let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3952 -             let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3952 +             let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4010:99
[INFO] [stdout]      |
[INFO] [stdout] 4010 |         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4010 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4010 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4010 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4010 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4011:79
[INFO] [stdout]      |
[INFO] [stdout] 4011 |         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4011 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4011 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4011 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4011 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4017:103
[INFO] [stdout]      |
[INFO] [stdout] 4017 |             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4017 -             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 4017 +             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4017 -             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 4017 +             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4023:107
[INFO] [stdout]      |
[INFO] [stdout] 4023 |                 match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                           ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4023 -                 match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4023 +                 match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4023 -                 match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4023 +                 match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4032:93
[INFO] [stdout]      |
[INFO] [stdout] 4032 |             if match self.jj_2_34(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]      |                                                                                             ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4032 -             if match self.jj_2_34(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 4032 +             if match self.jj_2_34(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4032 -             if match self.jj_2_34(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 4032 +             if match self.jj_2_34(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4036:82
[INFO] [stdout]      |
[INFO] [stdout] 4036 |             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                  ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4036 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4036 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4036 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4036 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4110:82
[INFO] [stdout]      |
[INFO] [stdout] 4110 |         match self.member_access() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                  ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4110 -         match self.member_access() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4110 +         match self.member_access() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4110 -         match self.member_access() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4110 +         match self.member_access() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4112:82
[INFO] [stdout]      |
[INFO] [stdout] 4112 |             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                  ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4112 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4112 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4112 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4112 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4113:93
[INFO] [stdout]      |
[INFO] [stdout] 4113 |             if match self.jj_2_44(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]      |                                                                                             ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4113 -             if match self.jj_2_44(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 4113 +             if match self.jj_2_44(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4113 -             if match self.jj_2_44(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 4113 +             if match self.jj_2_44(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4170:87
[INFO] [stdout]      |
[INFO] [stdout] 4170 |         match self.primary_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4170 -         match self.primary_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4170 +         match self.primary_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4170 -         match self.primary_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4170 +         match self.primary_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4172:84
[INFO] [stdout]      |
[INFO] [stdout] 4172 |             if match self.jj_2_46(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]      |                                                                                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4172 -             if match self.jj_2_46(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 4172 +             if match self.jj_2_46(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4172 -             if match self.jj_2_46(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 4172 +             if match self.jj_2_46(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4176:90
[INFO] [stdout]      |
[INFO] [stdout] 4176 |             match self.member_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4176 -             match self.member_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4176 +             match self.member_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4176 -             match self.member_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4176 +             match self.member_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `rust-jexl3` (lib test) due to 237 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]   --> src/parser/parser_gen.rs:28:83
[INFO] [stdout]    |
[INFO] [stdout] 28 |             if match self.jj_2_1(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]    |                                                                                   ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 28 -             if match self.jj_2_1(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 28 +             if match self.jj_2_1(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 28 -             if match self.jj_2_1(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 28 +             if match self.jj_2_1(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]   --> src/parser/parser_gen.rs:32:82
[INFO] [stdout]    |
[INFO] [stdout] 32 |             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]    |                                                                                  ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 32 -             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 32 +             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 32 -             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 32 +             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]   --> src/parser/parser_gen.rs:34:94
[INFO] [stdout]    |
[INFO] [stdout] 34 |         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]    |                                                                                              ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 34 -         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 34 +         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 34 -         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 34 +         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]   --> src/parser/parser_gen.rs:38:103
[INFO] [stdout]    |
[INFO] [stdout] 38 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]    |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 38 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 38 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 38 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 38 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]   --> src/parser/parser_gen.rs:75:79
[INFO] [stdout]    |
[INFO] [stdout] 75 |         if match self.jj_2_2(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]    |                                                                               ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 75 -         if match self.jj_2_2(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 75 +         if match self.jj_2_2(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 75 -         if match self.jj_2_2(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 75 +         if match self.jj_2_2(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]   --> src/parser/parser_gen.rs:76:83
[INFO] [stdout]    |
[INFO] [stdout] 76 |             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]    |                                                                                   ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 76 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 76 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 76 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 76 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]   --> src/parser/parser_gen.rs:79:94
[INFO] [stdout]    |
[INFO] [stdout] 79 |         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]    |                                                                                              ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 79 -         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 79 +         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 79 -         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 79 +         let _ = match self.jj_consume_token(0) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]   --> src/parser/parser_gen.rs:83:103
[INFO] [stdout]    |
[INFO] [stdout] 83 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]    |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 83 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 83 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 83 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 83 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:119:99
[INFO] [stdout]     |
[INFO] [stdout] 119 |         t = match self.jj_consume_token(ANNOTATION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 119 -         t = match self.jj_consume_token(ANNOTATION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 119 +         t = match self.jj_consume_token(ANNOTATION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 119 -         t = match self.jj_consume_token(ANNOTATION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 119 +         t = match self.jj_consume_token(ANNOTATION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:120:88
[INFO] [stdout]     |
[INFO] [stdout] 120 |         if match self.jj_2_3(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                        ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 120 -         if match self.jj_2_3(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 120 +         if match self.jj_2_3(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 120 -         if match self.jj_2_3(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 120 +         if match self.jj_2_3(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:121:82
[INFO] [stdout]     |
[INFO] [stdout] 121 |             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 121 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 121 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 121 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 121 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:127:103
[INFO] [stdout]     |
[INFO] [stdout] 127 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 127 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 127 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 127 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 127 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:162:83
[INFO] [stdout]     |
[INFO] [stdout] 162 |             match self.annotation() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 162 -             match self.annotation() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 162 +             match self.annotation() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 162 -             match self.annotation() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 162 +             match self.annotation() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:163:92
[INFO] [stdout]     |
[INFO] [stdout] 163 |             if match self.jj_2_4(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 163 -             if match self.jj_2_4(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 163 +             if match self.jj_2_4(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 163 -             if match self.jj_2_4(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 163 +             if match self.jj_2_4(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:171:86
[INFO] [stdout]     |
[INFO] [stdout] 171 |                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 171 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 171 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 171 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 171 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:175:91
[INFO] [stdout]     |
[INFO] [stdout] 175 |                     if match self.jj_2_5(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 175 -                     if match self.jj_2_5(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 175 +                     if match self.jj_2_5(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 175 -                     if match self.jj_2_5(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 175 +                     if match self.jj_2_5(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:176:94
[INFO] [stdout]     |
[INFO] [stdout] 176 |                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 176 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 176 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 176 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 176 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:178:111
[INFO] [stdout]     |
[INFO] [stdout] 178 |                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 178 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 178 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 178 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 178 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:284:99
[INFO] [stdout]     |
[INFO] [stdout] 284 |         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 284 -         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 284 +         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 284 -         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 284 +         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:287:83
[INFO] [stdout]     |
[INFO] [stdout] 287 |             if match self.jj_2_8(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 287 -             if match self.jj_2_8(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 287 +             if match self.jj_2_8(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 287 -             if match self.jj_2_8(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 287 +             if match self.jj_2_8(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:291:82
[INFO] [stdout]     |
[INFO] [stdout] 291 |             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 291 -             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 291 +             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 291 -             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 291 +             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:294:99
[INFO] [stdout]     |
[INFO] [stdout] 294 |         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 294 -         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 294 +         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 294 -         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 294 +         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:332:83
[INFO] [stdout]     |
[INFO] [stdout] 332 |             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 332 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 332 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 332 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 332 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:375:95
[INFO] [stdout]     |
[INFO] [stdout] 375 |         let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 375 -         let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 375 +         let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 375 -         let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 375 +         let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:376:99
[INFO] [stdout]     |
[INFO] [stdout] 376 |         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 376 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 376 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 376 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 376 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:377:79
[INFO] [stdout]     |
[INFO] [stdout] 377 |         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 377 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 377 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 377 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 377 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:378:99
[INFO] [stdout]     |
[INFO] [stdout] 378 |         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 378 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 378 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 378 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 378 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:382:86
[INFO] [stdout]     |
[INFO] [stdout] 382 |                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 382 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 382 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 382 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 382 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:386:92
[INFO] [stdout]     |
[INFO] [stdout] 386 |                     if match self.jj_2_10(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 386 -                     if match self.jj_2_10(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 386 +                     if match self.jj_2_10(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 386 -                     if match self.jj_2_10(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 386 +                     if match self.jj_2_10(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:387:94
[INFO] [stdout]     |
[INFO] [stdout] 387 |                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 387 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 387 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 387 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 387 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:389:111
[INFO] [stdout]     |
[INFO] [stdout] 389 |                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 389 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 389 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 389 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 389 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:396:84
[INFO] [stdout]     |
[INFO] [stdout] 396 |             if match self.jj_2_11(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                    ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 396 -             if match self.jj_2_11(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 396 +             if match self.jj_2_11(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 396 -             if match self.jj_2_11(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 396 +             if match self.jj_2_11(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:400:101
[INFO] [stdout]     |
[INFO] [stdout] 400 |             let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                     ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 400 -             let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 400 +             let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 400 -             let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 400 +             let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:401:99
[INFO] [stdout]     |
[INFO] [stdout] 401 |             let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 401 -             let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 401 +             let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 401 -             let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 401 +             let _ = match self.jj_consume_token(IF) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:402:103
[INFO] [stdout]     |
[INFO] [stdout] 402 |             let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 402 -             let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 402 +             let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 402 -             let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 402 +             let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:403:83
[INFO] [stdout]     |
[INFO] [stdout] 403 |             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 403 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 403 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 403 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 403 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:404:103
[INFO] [stdout]     |
[INFO] [stdout] 404 |             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 404 -             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 404 +             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 404 -             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 404 +             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:408:90
[INFO] [stdout]     |
[INFO] [stdout] 408 |                         match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                          ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 408 -                         match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 408 +                         match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 408 -                         match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 408 +                         match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:412:96
[INFO] [stdout]     |
[INFO] [stdout] 412 |                         if match self.jj_2_12(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 412 -                         if match self.jj_2_12(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 412 +                         if match self.jj_2_12(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 412 -                         if match self.jj_2_12(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 412 +                         if match self.jj_2_12(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:413:98
[INFO] [stdout]     |
[INFO] [stdout] 413 | ...                   match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 413 -                             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 413 +                             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 413 -                             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 413 +                             match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:415:115
[INFO] [stdout]     |
[INFO] [stdout] 415 | ...                   let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 415 -                             let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 415 +                             let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 415 -                             let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 415 +                             let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:425:109
[INFO] [stdout]     |
[INFO] [stdout] 425 |                     let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 425 -                     let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 425 +                     let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 425 -                     let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 425 +                     let _ = match self.jj_consume_token(ELSE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:429:98
[INFO] [stdout]     |
[INFO] [stdout] 429 | ...                   match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                        ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 429 -                                 match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 429 +                                 match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 429 -                                 match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 429 +                                 match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:433:104
[INFO] [stdout]     |
[INFO] [stdout] 433 | ...                   if match self.jj_2_13(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 433 -                                 if match self.jj_2_13(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 433 +                                 if match self.jj_2_13(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 433 -                                 if match self.jj_2_13(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 433 +                                 if match self.jj_2_13(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:434:106
[INFO] [stdout]     |
[INFO] [stdout] 434 | ...                   match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 434 -                                     match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 434 +                                     match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 434 -                                     match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 434 +                                     match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:436:123
[INFO] [stdout]     |
[INFO] [stdout] 436 | ...                   let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                             ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 436 -                                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 436 +                                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 436 -                                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 436 +                                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:479:98
[INFO] [stdout]     |
[INFO] [stdout] 479 |         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 479 -         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 479 +         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 479 -         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 479 +         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:480:99
[INFO] [stdout]     |
[INFO] [stdout] 480 |         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 480 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 480 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 480 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 480 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:481:79
[INFO] [stdout]     |
[INFO] [stdout] 481 |         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 481 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 481 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 481 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 481 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:482:99
[INFO] [stdout]     |
[INFO] [stdout] 482 |         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 482 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 482 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 482 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 482 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:487:86
[INFO] [stdout]     |
[INFO] [stdout] 487 |                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 487 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 487 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 487 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 487 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:491:92
[INFO] [stdout]     |
[INFO] [stdout] 491 |                     if match self.jj_2_14(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 491 -                     if match self.jj_2_14(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 491 +                     if match self.jj_2_14(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 491 -                     if match self.jj_2_14(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 491 +                     if match self.jj_2_14(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:492:94
[INFO] [stdout]     |
[INFO] [stdout] 492 |                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 492 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 492 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 492 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 492 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:494:111
[INFO] [stdout]     |
[INFO] [stdout] 494 |                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 494 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 494 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 494 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 494 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:503:103
[INFO] [stdout]     |
[INFO] [stdout] 503 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 503 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 503 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 503 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 503 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:537:95
[INFO] [stdout]     |
[INFO] [stdout] 537 |         let _ = match self.jj_consume_token(DO) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 537 -         let _ = match self.jj_consume_token(DO) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 537 +         let _ = match self.jj_consume_token(DO) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 537 -         let _ = match self.jj_consume_token(DO) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 537 +         let _ = match self.jj_consume_token(DO) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:542:86
[INFO] [stdout]     |
[INFO] [stdout] 542 |                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 542 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 542 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 542 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 542 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:546:92
[INFO] [stdout]     |
[INFO] [stdout] 546 |                     if match self.jj_2_15(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 546 -                     if match self.jj_2_15(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 546 +                     if match self.jj_2_15(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 546 -                     if match self.jj_2_15(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 546 +                     if match self.jj_2_15(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:547:94
[INFO] [stdout]     |
[INFO] [stdout] 547 |                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 547 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 547 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 547 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 547 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:549:111
[INFO] [stdout]     |
[INFO] [stdout] 549 |                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 549 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 549 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 549 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 549 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:555:98
[INFO] [stdout]     |
[INFO] [stdout] 555 |         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 555 -         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 555 +         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 555 -         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 555 +         let _ = match self.jj_consume_token(WHILE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:556:99
[INFO] [stdout]     |
[INFO] [stdout] 556 |         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 556 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 556 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 556 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 556 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:557:79
[INFO] [stdout]     |
[INFO] [stdout] 557 |         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 557 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 557 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 557 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 557 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:558:99
[INFO] [stdout]     |
[INFO] [stdout] 558 |         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 558 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 558 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 558 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 558 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:562:103
[INFO] [stdout]     |
[INFO] [stdout] 562 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 562 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 562 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 562 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 562 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:596:99
[INFO] [stdout]     |
[INFO] [stdout] 596 |         let _ = match self.jj_consume_token(RETURN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 596 -         let _ = match self.jj_consume_token(RETURN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 596 +         let _ = match self.jj_consume_token(RETURN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 596 -         let _ = match self.jj_consume_token(RETURN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 596 +         let _ = match self.jj_consume_token(RETURN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:597:89
[INFO] [stdout]     |
[INFO] [stdout] 597 |         match self.expression_statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                         ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 597 -         match self.expression_statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 597 +         match self.expression_statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 597 -         match self.expression_statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 597 +         match self.expression_statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:630:97
[INFO] [stdout]     |
[INFO] [stdout] 630 |         t = match self.jj_consume_token(CONTINUE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 630 -         t = match self.jj_consume_token(CONTINUE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 630 +         t = match self.jj_consume_token(CONTINUE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 630 -         t = match self.jj_consume_token(CONTINUE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 630 +         t = match self.jj_consume_token(CONTINUE) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:634:103
[INFO] [stdout]     |
[INFO] [stdout] 634 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 634 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 634 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 634 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 634 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:636:51
[INFO] [stdout]     |
[INFO] [stdout] 636 |         if self.loop_count == 0 { break 'try1 Err(self.throw_parsing_exception(false, Some(t)).into()); }
[INFO] [stdout]     |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 636 -         if self.loop_count == 0 { break 'try1 Err(self.throw_parsing_exception(false, Some(t)).into()); }
[INFO] [stdout] 636 +         if self.loop_count == 0 { break 'try1 Err(self.throw_parsing_exception(false, Some(t))); }
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 636 -         if self.loop_count == 0 { break 'try1 Err(self.throw_parsing_exception(false, Some(t)).into()); }
[INFO] [stdout] 636 +         if self.loop_count == 0 { break 'try1 Err(<PErr as Into<_>>::into(self.throw_parsing_exception(false, Some(t)))); }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:661:94
[INFO] [stdout]     |
[INFO] [stdout] 661 |         t = match self.jj_consume_token(BREAK) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 661 -         t = match self.jj_consume_token(BREAK) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 661 +         t = match self.jj_consume_token(BREAK) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 661 -         t = match self.jj_consume_token(BREAK) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 661 +         t = match self.jj_consume_token(BREAK) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:665:103
[INFO] [stdout]     |
[INFO] [stdout] 665 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 665 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 665 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 665 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 665 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:667:51
[INFO] [stdout]     |
[INFO] [stdout] 667 |         if self.loop_count == 0 { break 'try1 Err(self.throw_parsing_exception(false, Some(t)).into()); }
[INFO] [stdout]     |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 667 -         if self.loop_count == 0 { break 'try1 Err(self.throw_parsing_exception(false, Some(t)).into()); }
[INFO] [stdout] 667 +         if self.loop_count == 0 { break 'try1 Err(self.throw_parsing_exception(false, Some(t))); }
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 667 -         if self.loop_count == 0 { break 'try1 Err(self.throw_parsing_exception(false, Some(t)).into()); }
[INFO] [stdout] 667 +         if self.loop_count == 0 { break 'try1 Err(<PErr as Into<_>>::into(self.throw_parsing_exception(false, Some(t)))); }
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:692:96
[INFO] [stdout]     |
[INFO] [stdout] 692 |         let _ = match self.jj_consume_token(FOR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 692 -         let _ = match self.jj_consume_token(FOR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 692 +         let _ = match self.jj_consume_token(FOR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 692 -         let _ = match self.jj_consume_token(FOR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 692 +         let _ = match self.jj_consume_token(FOR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:693:99
[INFO] [stdout]     |
[INFO] [stdout] 693 |         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 693 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 693 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 693 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 693 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:694:81
[INFO] [stdout]     |
[INFO] [stdout] 694 |         match self.for_each_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 694 -         match self.for_each_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 694 +         match self.for_each_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 694 -         match self.for_each_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 694 +         match self.for_each_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:695:98
[INFO] [stdout]     |
[INFO] [stdout] 695 |         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                  ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 695 -         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 695 +         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 695 -         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 695 +         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:696:79
[INFO] [stdout]     |
[INFO] [stdout] 696 |         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 696 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 696 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 696 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 696 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:697:99
[INFO] [stdout]     |
[INFO] [stdout] 697 |         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 697 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 697 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 697 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 697 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:702:86
[INFO] [stdout]     |
[INFO] [stdout] 702 |                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 702 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 702 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 702 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 702 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:706:92
[INFO] [stdout]     |
[INFO] [stdout] 706 |                     if match self.jj_2_16(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 706 -                     if match self.jj_2_16(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 706 +                     if match self.jj_2_16(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 706 -                     if match self.jj_2_16(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 706 +                     if match self.jj_2_16(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:707:94
[INFO] [stdout]     |
[INFO] [stdout] 707 |                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                              ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 707 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 707 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 707 -                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 707 +                         match self.statement() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:709:111
[INFO] [stdout]     |
[INFO] [stdout] 709 |                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 709 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 709 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 709 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 709 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:718:103
[INFO] [stdout]     |
[INFO] [stdout] 718 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 718 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 718 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 718 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 718 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:756:108
[INFO] [stdout]     |
[INFO] [stdout] 756 |                     let _ = match self.jj_consume_token(VAR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 756 -                     let _ = match self.jj_consume_token(VAR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 756 +                     let _ = match self.jj_consume_token(VAR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 756 -                     let _ = match self.jj_consume_token(VAR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 756 +                     let _ = match self.jj_consume_token(VAR) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:757:92
[INFO] [stdout]     |
[INFO] [stdout] 757 |                     match self.declare_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                            ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 757 -                     match self.declare_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 757 +                     match self.declare_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 757 -                     match self.declare_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 757 +                     match self.declare_var() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:761:95
[INFO] [stdout]     |
[INFO] [stdout] 761 |                     match self.identifier(true) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 761 -                     match self.identifier(true) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 761 +                     match self.identifier(true) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 761 -                     match self.identifier(true) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 761 +                     match self.identifier(true) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:765:107
[INFO] [stdout]     |
[INFO] [stdout] 765 |                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 765 -                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 765 +                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 765 -                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 765 +                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:807:91
[INFO] [stdout]     |
[INFO] [stdout] 807 |                     match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]     |                                                                                           ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 807 -                     match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 807 +                     match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 807 -                     match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 807 +                     match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:846:99
[INFO] [stdout]     |
[INFO] [stdout] 846 |         t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 846 -         t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 846 +         t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 846 -         t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 846 +         t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:850:103
[INFO] [stdout]     |
[INFO] [stdout] 850 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 850 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 850 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 850 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 850 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:852:95
[INFO] [stdout]     |
[INFO] [stdout] 852 |         match self.declare_variable(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]     |                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 852 -         match self.declare_variable(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 852 +         match self.declare_variable(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 852 -         match self.declare_variable(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 852 +         match self.declare_variable(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]    --> src/parser/parser_gen.rs:992:95
[INFO] [stdout]     |
[INFO] [stdout] 992 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]     |                                                                                               ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 992 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 992 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 992 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 992 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1023:95
[INFO] [stdout]      |
[INFO] [stdout] 1023 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout]      |                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1023 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 1023 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1023 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 1023 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1054:95
[INFO] [stdout]      |
[INFO] [stdout] 1054 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout]      |                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1054 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 1054 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1054 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 1054 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1085:95
[INFO] [stdout]      |
[INFO] [stdout] 1085 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout]      |                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1085 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout] 1085 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1085 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout] 1085 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1116:95
[INFO] [stdout]      |
[INFO] [stdout] 1116 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout]      |                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1116 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout] 1116 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1116 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout] 1116 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1147:95
[INFO] [stdout]      |
[INFO] [stdout] 1147 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout]      |                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1147 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 1147 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1147 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 1147 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1178:95
[INFO] [stdout]      |
[INFO] [stdout] 1178 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout]      |                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1178 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout] 1178 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1178 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout] 1178 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1209:95
[INFO] [stdout]      |
[INFO] [stdout] 1209 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try9 Err(__e.into()) };
[INFO] [stdout]      |                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1209 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try9 Err(__e.into()) };
[INFO] [stdout] 1209 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try9 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1209 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try9 Err(__e.into()) };
[INFO] [stdout] 1209 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try9 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1240:96
[INFO] [stdout]      |
[INFO] [stdout] 1240 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1240 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(__e.into()) };
[INFO] [stdout] 1240 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1240 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(__e.into()) };
[INFO] [stdout] 1240 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1291:103
[INFO] [stdout]      |
[INFO] [stdout] 1291 | ...                   match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout]      |                                                                                             ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1291 -                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 1291 +                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1291 -                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 1291 +                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1322:103
[INFO] [stdout]      |
[INFO] [stdout] 1322 | ...                   match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout]      |                                                                                             ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1322 -                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 1322 +                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1322 -                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 1322 +                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1353:103
[INFO] [stdout]      |
[INFO] [stdout] 1353 | ...                   match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout]      |                                                                                             ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1353 -                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout] 1353 +                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1353 -                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout] 1353 +                                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1427:99
[INFO] [stdout]      |
[INFO] [stdout] 1427 |             match self.conditional_and_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1427 -             match self.conditional_and_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 1427 +             match self.conditional_and_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1427 -             match self.conditional_and_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 1427 +             match self.conditional_and_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1488:96
[INFO] [stdout]      |
[INFO] [stdout] 1488 |             match self.inclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1488 -             match self.inclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 1488 +             match self.inclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1488 -             match self.inclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 1488 +             match self.inclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1534:96
[INFO] [stdout]      |
[INFO] [stdout] 1534 |             match self.exclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1534 -             match self.exclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 1534 +             match self.exclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1534 -             match self.exclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 1534 +             match self.exclusive_or_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1580:87
[INFO] [stdout]      |
[INFO] [stdout] 1580 |             match self.and_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]      |                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1580 -             match self.and_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 1580 +             match self.and_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1580 -             match self.and_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 1580 +             match self.and_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1626:92
[INFO] [stdout]      |
[INFO] [stdout] 1626 |             match self.equality_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]      |                                                                                            ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1626 -             match self.equality_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 1626 +             match self.equality_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1626 -             match self.equality_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 1626 +             match self.equality_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1682:114
[INFO] [stdout]      |
[INFO] [stdout] 1682 | ...                   match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                        ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1682 -                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 1682 +                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1682 -                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 1682 +                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1728:114
[INFO] [stdout]      |
[INFO] [stdout] 1728 | ...                   match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                        ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1728 -                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout] 1728 +                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1728 -                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout] 1728 +                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1759:114
[INFO] [stdout]      |
[INFO] [stdout] 1759 | ...                   match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                        ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1759 -                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 1759 +                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1759 -                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 1759 +                                 match self.relational_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1828:112
[INFO] [stdout]      |
[INFO] [stdout] 1828 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1828 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 1828 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1828 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 1828 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1874:112
[INFO] [stdout]      |
[INFO] [stdout] 1874 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1874 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout] 1874 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1874 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout] 1874 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1920:112
[INFO] [stdout]      |
[INFO] [stdout] 1920 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1920 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout] 1920 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1920 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout] 1920 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1966:113
[INFO] [stdout]      |
[INFO] [stdout] 1966 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1966 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(__e.into()) };
[INFO] [stdout] 1966 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1966 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(__e.into()) };
[INFO] [stdout] 1966 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try10 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:1997:113
[INFO] [stdout]      |
[INFO] [stdout] 1997 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try11 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1997 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try11 Err(__e.into()) };
[INFO] [stdout] 1997 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try11 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1997 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try11 Err(__e.into()) };
[INFO] [stdout] 1997 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try11 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2028:113
[INFO] [stdout]      |
[INFO] [stdout] 2028 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try12 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2028 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try12 Err(__e.into()) };
[INFO] [stdout] 2028 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try12 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2028 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try12 Err(__e.into()) };
[INFO] [stdout] 2028 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try12 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2059:113
[INFO] [stdout]      |
[INFO] [stdout] 2059 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try13 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2059 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try13 Err(__e.into()) };
[INFO] [stdout] 2059 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try13 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2059 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try13 Err(__e.into()) };
[INFO] [stdout] 2059 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try13 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2090:113
[INFO] [stdout]      |
[INFO] [stdout] 2090 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try14 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2090 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try14 Err(__e.into()) };
[INFO] [stdout] 2090 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try14 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2090 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try14 Err(__e.into()) };
[INFO] [stdout] 2090 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try14 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2121:113
[INFO] [stdout]      |
[INFO] [stdout] 2121 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try15 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2121 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try15 Err(__e.into()) };
[INFO] [stdout] 2121 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try15 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2121 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try15 Err(__e.into()) };
[INFO] [stdout] 2121 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try15 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2152:113
[INFO] [stdout]      |
[INFO] [stdout] 2152 | ...                   match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try16 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2152 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try16 Err(__e.into()) };
[INFO] [stdout] 2152 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try16 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2152 -                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try16 Err(__e.into()) };
[INFO] [stdout] 2152 +                                 match self.additive_expression() { Ok(__v) => __v, Err(__e) => break 'try16 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2208:110
[INFO] [stdout]      |
[INFO] [stdout] 2208 |                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                              ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2208 -                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 2208 +                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2208 -                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 2208 +                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2239:110
[INFO] [stdout]      |
[INFO] [stdout] 2239 |                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                              ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2239 -                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 2239 +                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2239 -                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 2239 +                         match self.multiplicative_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2296:101
[INFO] [stdout]      |
[INFO] [stdout] 2296 |                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2296 -                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 2296 +                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2296 -                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 2296 +                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2342:101
[INFO] [stdout]      |
[INFO] [stdout] 2342 |                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2342 -                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout] 2342 +                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2342 -                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout] 2342 +                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try5 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2388:101
[INFO] [stdout]      |
[INFO] [stdout] 2388 |                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2388 -                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 2388 +                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2388 -                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 2388 +                         match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2433:97
[INFO] [stdout]      |
[INFO] [stdout] 2433 |                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2433 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 2433 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2433 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 2433 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2464:97
[INFO] [stdout]      |
[INFO] [stdout] 2464 |                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2464 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 2464 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2464 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 2464 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try3 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2495:97
[INFO] [stdout]      |
[INFO] [stdout] 2495 |                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2495 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 2495 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2495 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 2495 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try4 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2541:97
[INFO] [stdout]      |
[INFO] [stdout] 2541 |                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2541 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout] 2541 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2541 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(__e.into()) };
[INFO] [stdout] 2541 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try6 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2572:97
[INFO] [stdout]      |
[INFO] [stdout] 2572 |                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2572 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 2572 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2572 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 2572 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try7 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2603:97
[INFO] [stdout]      |
[INFO] [stdout] 2603 |                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2603 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout] 2603 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2603 -                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout] 2603 +                     match self.unary_expression() { Ok(__v) => __v, Err(__e) => break 'try8 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2651:111
[INFO] [stdout]      |
[INFO] [stdout] 2651 |                     t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2651 -                     t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2651 +                     t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2651 -                     t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2651 +                     t = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2655:115
[INFO] [stdout]      |
[INFO] [stdout] 2655 |                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2655 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2655 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2655 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2655 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2661:109
[INFO] [stdout]      |
[INFO] [stdout] 2661 |                     t = match self.jj_consume_token(REGISTER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                             ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2661 -                     t = match self.jj_consume_token(REGISTER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2661 +                     t = match self.jj_consume_token(REGISTER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2661 -                     t = match self.jj_consume_token(REGISTER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2661 +                     t = match self.jj_consume_token(REGISTER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2665:115
[INFO] [stdout]      |
[INFO] [stdout] 2665 |                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2665 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2665 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2665 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2665 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2671:107
[INFO] [stdout]      |
[INFO] [stdout] 2671 |                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                           ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2671 -                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2671 +                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2671 -                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2671 +                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2701:100
[INFO] [stdout]      |
[INFO] [stdout] 2701 |         ns = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2701 -         ns = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2701 +         ns = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2701 -         ns = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2701 +         ns = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2702:98
[INFO] [stdout]      |
[INFO] [stdout] 2702 |         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                  ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2702 -         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2702 +         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2702 -         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2702 +         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2703:100
[INFO] [stdout]      |
[INFO] [stdout] 2703 |         id = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2703 -         id = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2703 +         id = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2703 -         id = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2703 +         id = match self.jj_consume_token(IDENTIFIER) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2707:103
[INFO] [stdout]      |
[INFO] [stdout] 2707 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2707 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2707 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2707 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2707 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2779:104
[INFO] [stdout]      |
[INFO] [stdout] 2779 |         let _ = match self.jj_consume_token(NAN_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                        ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2779 -         let _ = match self.jj_consume_token(NAN_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2779 +         let _ = match self.jj_consume_token(NAN_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2779 -         let _ = match self.jj_consume_token(NAN_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2779 +         let _ = match self.jj_consume_token(NAN_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2783:103
[INFO] [stdout]      |
[INFO] [stdout] 2783 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2783 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2783 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2783 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2783 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2785:91
[INFO] [stdout]      |
[INFO] [stdout] 2785 |         match self.set_real(jjtn000, "NaN") { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                           ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2785 -         match self.set_real(jjtn000, "NaN") { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2785 +         match self.set_real(jjtn000, "NaN") { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2785 -         match self.set_real(jjtn000, "NaN") { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2785 +         match self.set_real(jjtn000, "NaN") { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2809:97
[INFO] [stdout]      |
[INFO] [stdout] 2809 |         let _ = match self.jj_consume_token(NULL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2809 -         let _ = match self.jj_consume_token(NULL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2809 +         let _ = match self.jj_consume_token(NULL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2809 -         let _ = match self.jj_consume_token(NULL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2809 +         let _ = match self.jj_consume_token(NULL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2836:109
[INFO] [stdout]      |
[INFO] [stdout] 2836 |                     let _ = match self.jj_consume_token(TRUE) { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                             ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2836 -                     let _ = match self.jj_consume_token(TRUE) { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 2836 +                     let _ = match self.jj_consume_token(TRUE) { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2836 -                     let _ = match self.jj_consume_token(TRUE) { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 2836 +                     let _ = match self.jj_consume_token(TRUE) { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2858:110
[INFO] [stdout]      |
[INFO] [stdout] 2858 |                     let _ = match self.jj_consume_token(FALSE) { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                              ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2858 -                     let _ = match self.jj_consume_token(FALSE) { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 2858 +                     let _ = match self.jj_consume_token(FALSE) { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2858 -                     let _ = match self.jj_consume_token(FALSE) { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 2858 +                     let _ = match self.jj_consume_token(FALSE) { Ok(__v) => __v, Err(__e) => break 'try3 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2891:104
[INFO] [stdout]      |
[INFO] [stdout] 2891 |         t = match self.jj_consume_token(INTEGER_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                        ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2891 -         t = match self.jj_consume_token(INTEGER_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2891 +         t = match self.jj_consume_token(INTEGER_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2891 -         t = match self.jj_consume_token(INTEGER_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2891 +         t = match self.jj_consume_token(INTEGER_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2895:103
[INFO] [stdout]      |
[INFO] [stdout] 2895 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2895 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2895 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2895 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2895 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2897:120
[INFO] [stdout]      |
[INFO] [stdout] 2897 | ...   { let __s = self.image(t); match self.set_natural(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) }; }
[INFO] [stdout]      |                                                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2897 -         { let __s = self.image(t); match self.set_natural(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) }; }
[INFO] [stdout] 2897 +         { let __s = self.image(t); match self.set_natural(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) }; }
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2897 -         { let __s = self.image(t); match self.set_natural(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) }; }
[INFO] [stdout] 2897 +         { let __s = self.image(t); match self.set_natural(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) }; }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2922:102
[INFO] [stdout]      |
[INFO] [stdout] 2922 |         t = match self.jj_consume_token(FLOAT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2922 -         t = match self.jj_consume_token(FLOAT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2922 +         t = match self.jj_consume_token(FLOAT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2922 -         t = match self.jj_consume_token(FLOAT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2922 +         t = match self.jj_consume_token(FLOAT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2926:103
[INFO] [stdout]      |
[INFO] [stdout] 2926 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2926 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2926 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2926 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2926 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2928:117
[INFO] [stdout]      |
[INFO] [stdout] 2928 |         { let __s = self.image(t); match self.set_real(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) }; }
[INFO] [stdout]      |                                                                                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2928 -         { let __s = self.image(t); match self.set_real(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) }; }
[INFO] [stdout] 2928 +         { let __s = self.image(t); match self.set_real(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) }; }
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2928 -         { let __s = self.image(t); match self.set_real(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) }; }
[INFO] [stdout] 2928 +         { let __s = self.image(t); match self.set_real(jjtn000, &__s) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) }; }
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2953:103
[INFO] [stdout]      |
[INFO] [stdout] 2953 |         t = match self.jj_consume_token(STRING_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2953 -         t = match self.jj_consume_token(STRING_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2953 +         t = match self.jj_consume_token(STRING_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2953 -         t = match self.jj_consume_token(STRING_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2953 +         t = match self.jj_consume_token(STRING_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2957:103
[INFO] [stdout]      |
[INFO] [stdout] 2957 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2957 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2957 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2957 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2957 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2984:101
[INFO] [stdout]      |
[INFO] [stdout] 2984 |         t = match self.jj_consume_token(JXLT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2984 -         t = match self.jj_consume_token(JXLT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2984 +         t = match self.jj_consume_token(JXLT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2984 -         t = match self.jj_consume_token(JXLT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2984 +         t = match self.jj_consume_token(JXLT_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:2988:103
[INFO] [stdout]      |
[INFO] [stdout] 2988 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2988 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2988 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2988 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 2988 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3015:102
[INFO] [stdout]      |
[INFO] [stdout] 3015 |         t = match self.jj_consume_token(REGEX_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3015 -         t = match self.jj_consume_token(REGEX_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3015 +         t = match self.jj_consume_token(REGEX_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3015 -         t = match self.jj_consume_token(REGEX_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3015 +         t = match self.jj_consume_token(REGEX_LITERAL) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3019:103
[INFO] [stdout]      |
[INFO] [stdout] 3019 |             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3019 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3019 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3019 -             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3019 +             match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3021:96
[INFO] [stdout]      |
[INFO] [stdout] 3021 |         match self.set_regex_literal(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3021 -         match self.set_regex_literal(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3021 +         match self.set_regex_literal(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3021 -         match self.set_regex_literal(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3021 +         match self.set_regex_literal(jjtn000, t) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3045:100
[INFO] [stdout]      |
[INFO] [stdout] 3045 |         let _ = match self.jj_consume_token(ELIPSIS) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3045 -         let _ = match self.jj_consume_token(ELIPSIS) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3045 +         let _ = match self.jj_consume_token(ELIPSIS) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3045 -         let _ = match self.jj_consume_token(ELIPSIS) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3045 +         let _ = match self.jj_consume_token(ELIPSIS) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3069:101
[INFO] [stdout]      |
[INFO] [stdout] 3069 |         let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3069 -         let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3069 +         let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3069 -         let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3069 +         let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3073:97
[INFO] [stdout]      |
[INFO] [stdout] 3073 |                     match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3073 -                     match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3073 +                     match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3073 -                     match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3073 +                     match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3077:92
[INFO] [stdout]      |
[INFO] [stdout] 3077 |                     if match self.jj_2_22(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]      |                                                                                            ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3077 -                     if match self.jj_2_22(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3077 +                     if match self.jj_2_22(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3077 -                     if match self.jj_2_22(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3077 +                     if match self.jj_2_22(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3078:95
[INFO] [stdout]      |
[INFO] [stdout] 3078 |                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3078 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3078 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3078 -                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3078 +                         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3080:100
[INFO] [stdout]      |
[INFO] [stdout] 3080 | ...                   if match self.jj_2_21(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]      |                                                                                              ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3080 -                             if match self.jj_2_21(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3080 +                             if match self.jj_2_21(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3080 -                             if match self.jj_2_21(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3080 +                             if match self.jj_2_21(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3084:118
[INFO] [stdout]      |
[INFO] [stdout] 3084 | ...                   let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3084 -                             let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3084 +                             let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3084 -                             let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3084 +                             let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3085:99
[INFO] [stdout]      |
[INFO] [stdout] 3085 | ...                   match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                             ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3085 -                             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3085 +                             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3085 -                             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3085 +                             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3092:122
[INFO] [stdout]      |
[INFO] [stdout] 3092 | ...                   let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3092 -                                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3092 +                                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3092 -                                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3092 +                                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3093:109
[INFO] [stdout]      |
[INFO] [stdout] 3093 | ...                   match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3093 -                                 match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3093 +                                 match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3093 -                                 match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3093 +                                 match self.extended_literal() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3103:101
[INFO] [stdout]      |
[INFO] [stdout] 3103 |         let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                     ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3103 -         let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3103 +         let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3103 -         let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3103 +         let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3135:99
[INFO] [stdout]      |
[INFO] [stdout] 3135 |         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3135 -         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3135 +         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3135 -         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3135 +         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3136:80
[INFO] [stdout]      |
[INFO] [stdout] 3136 |         if match self.jj_2_23(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]      |                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3136 -         if match self.jj_2_23(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3136 +         if match self.jj_2_23(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3136 -         if match self.jj_2_23(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3136 +         if match self.jj_2_23(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3137:82
[INFO] [stdout]      |
[INFO] [stdout] 3137 |             match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                  ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3137 -             match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3137 +             match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3137 -             match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3137 +             match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3149:106
[INFO] [stdout]      |
[INFO] [stdout] 3149 |                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3149 -                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3149 +                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3149 -                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3149 +                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3150:86
[INFO] [stdout]      |
[INFO] [stdout] 3150 |                 match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3150 -                 match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3150 +                 match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3150 -                 match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3150 +                 match self.map_entry() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3156:114
[INFO] [stdout]      |
[INFO] [stdout] 3156 |                         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                  ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3156 -                         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3156 +                         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3156 -                         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3156 +                         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3160:111
[INFO] [stdout]      |
[INFO] [stdout] 3160 |                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3160 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3160 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3160 -                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3160 +                         let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3166:99
[INFO] [stdout]      |
[INFO] [stdout] 3166 |         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3166 -         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3166 +         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3166 -         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3166 +         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3198:79
[INFO] [stdout]      |
[INFO] [stdout] 3198 |         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3198 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3198 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3198 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3198 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3199:98
[INFO] [stdout]      |
[INFO] [stdout] 3199 |         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                  ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3199 -         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3199 +         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3199 -         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3199 +         let _ = match self.jj_consume_token(COLON) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3200:79
[INFO] [stdout]      |
[INFO] [stdout] 3200 |         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3200 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3200 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3200 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3200 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3232:99
[INFO] [stdout]      |
[INFO] [stdout] 3232 |         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3232 -         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3232 +         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3232 -         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3232 +         let _ = match self.jj_consume_token(LCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3233:80
[INFO] [stdout]      |
[INFO] [stdout] 3233 |         if match self.jj_2_24(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]      |                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3233 -         if match self.jj_2_24(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3233 +         if match self.jj_2_24(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3233 -         if match self.jj_2_24(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3233 +         if match self.jj_2_24(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3234:83
[INFO] [stdout]      |
[INFO] [stdout] 3234 |             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3234 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3234 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3234 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3234 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3246:106
[INFO] [stdout]      |
[INFO] [stdout] 3246 |                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3246 -                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3246 +                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3246 -                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3246 +                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3247:87
[INFO] [stdout]      |
[INFO] [stdout] 3247 |                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3247 -                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3247 +                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3247 -                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3247 +                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3251:99
[INFO] [stdout]      |
[INFO] [stdout] 3251 |         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3251 -         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3251 +         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3251 -         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3251 +         let _ = match self.jj_consume_token(RCURLY) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3283:99
[INFO] [stdout]      |
[INFO] [stdout] 3283 |         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3283 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3283 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3283 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3283 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3284:80
[INFO] [stdout]      |
[INFO] [stdout] 3284 |         if match self.jj_2_25(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]      |                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3284 -         if match self.jj_2_25(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3284 +         if match self.jj_2_25(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3284 -         if match self.jj_2_25(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 3284 +         if match self.jj_2_25(1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3285:83
[INFO] [stdout]      |
[INFO] [stdout] 3285 |             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3285 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3285 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3285 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3285 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3297:106
[INFO] [stdout]      |
[INFO] [stdout] 3297 |                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3297 -                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3297 +                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3297 -                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3297 +                 let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3298:87
[INFO] [stdout]      |
[INFO] [stdout] 3298 |                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3298 -                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3298 +                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3298 -                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3298 +                 match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3302:99
[INFO] [stdout]      |
[INFO] [stdout] 3302 |         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3302 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3302 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3302 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3302 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3356:82
[INFO] [stdout]      |
[INFO] [stdout] 3356 |             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                  ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3356 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3356 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3356 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3356 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3385:82
[INFO] [stdout]      |
[INFO] [stdout] 3385 |             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]      |                                                                                  ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3385 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 3385 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3385 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 3385 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3421:96
[INFO] [stdout]      |
[INFO] [stdout] 3421 |         let _ = match self.jj_consume_token(NEW) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3421 -         let _ = match self.jj_consume_token(NEW) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3421 +         let _ = match self.jj_consume_token(NEW) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3421 -         let _ = match self.jj_consume_token(NEW) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3421 +         let _ = match self.jj_consume_token(NEW) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3422:99
[INFO] [stdout]      |
[INFO] [stdout] 3422 |         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3422 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3422 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3422 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3422 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3423:79
[INFO] [stdout]      |
[INFO] [stdout] 3423 |         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3423 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3423 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3423 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3423 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3435:102
[INFO] [stdout]      |
[INFO] [stdout] 3435 |             let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3435 -             let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3435 +             let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3435 -             let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3435 +             let _ = match self.jj_consume_token(COMMA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3436:83
[INFO] [stdout]      |
[INFO] [stdout] 3436 |             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3436 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3436 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3436 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3436 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3438:99
[INFO] [stdout]      |
[INFO] [stdout] 3438 |         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3438 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3438 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3438 -         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3438 +         let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3562:113
[INFO] [stdout]      |
[INFO] [stdout] 3562 |                     let _ = match self.jj_consume_token(FUNCTION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3562 -                     let _ = match self.jj_consume_token(FUNCTION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3562 +                     let _ = match self.jj_consume_token(FUNCTION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3562 -                     let _ = match self.jj_consume_token(FUNCTION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3562 +                     let _ = match self.jj_consume_token(FUNCTION) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3563:91
[INFO] [stdout]      |
[INFO] [stdout] 3563 |                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                           ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3563 -                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3563 +                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3563 -                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3563 +                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3564:86
[INFO] [stdout]      |
[INFO] [stdout] 3564 |                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3564 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3564 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3564 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3564 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3568:115
[INFO] [stdout]      |
[INFO] [stdout] 3568 |                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3568 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3568 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3568 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3568 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3575:91
[INFO] [stdout]      |
[INFO] [stdout] 3575 |                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                           ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3575 -                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3575 +                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3575 -                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3575 +                     match self.parameters() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3576:111
[INFO] [stdout]      |
[INFO] [stdout] 3576 |                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3576 -                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3576 +                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3576 -                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3576 +                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3577:86
[INFO] [stdout]      |
[INFO] [stdout] 3577 |                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3577 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3577 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3577 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3577 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3581:115
[INFO] [stdout]      |
[INFO] [stdout] 3581 |                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3581 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3581 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3581 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3581 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3588:90
[INFO] [stdout]      |
[INFO] [stdout] 3588 |                     match self.parameter() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3588 -                     match self.parameter() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3588 +                     match self.parameter() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3588 -                     match self.parameter() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3588 +                     match self.parameter() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3589:111
[INFO] [stdout]      |
[INFO] [stdout] 3589 |                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3589 -                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3589 +                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3589 -                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3589 +                     let _ = match self.jj_consume_token(LAMBDA) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3590:86
[INFO] [stdout]      |
[INFO] [stdout] 3590 |                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                      ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3590 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3590 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3590 -                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3590 +                     match self.block() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3594:115
[INFO] [stdout]      |
[INFO] [stdout] 3594 |                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3594 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3594 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3594 -                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3594 +                         match self.jjtree_close_node_scope(jjtn000) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3600:107
[INFO] [stdout]      |
[INFO] [stdout] 3600 |                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                           ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3600 -                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3600 +                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3600 -                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3600 +                     let _ = match self.jj_consume_token(-1) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3755:127
[INFO] [stdout]      |
[INFO] [stdout] 3755 | ...                   match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3755 -                                     match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 3755 +                                     match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3755 -                                     match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try3 Err(__e.into()) };
[INFO] [stdout] 3755 +                                     match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try3 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3783:127
[INFO] [stdout]      |
[INFO] [stdout] 3783 | ...                   match self.jjtree_close_node_scope(jjtn002) { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3783 -                                     match self.jjtree_close_node_scope(jjtn002) { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 3783 +                                     match self.jjtree_close_node_scope(jjtn002) { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3783 -                                     match self.jjtree_close_node_scope(jjtn002) { Ok(__v) => __v, Err(__e) => break 'try4 Err(__e.into()) };
[INFO] [stdout] 3783 +                                     match self.jjtree_close_node_scope(jjtn002) { Ok(__v) => __v, Err(__e) => break 'try4 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3811:127
[INFO] [stdout]      |
[INFO] [stdout] 3811 | ...                   match self.jjtree_close_node_scope(jjtn003) { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3811 -                                     match self.jjtree_close_node_scope(jjtn003) { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout] 3811 +                                     match self.jjtree_close_node_scope(jjtn003) { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3811 -                                     match self.jjtree_close_node_scope(jjtn003) { Ok(__v) => __v, Err(__e) => break 'try5 Err(__e.into()) };
[INFO] [stdout] 3811 +                                     match self.jjtree_close_node_scope(jjtn003) { Ok(__v) => __v, Err(__e) => break 'try5 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3851:127
[INFO] [stdout]      |
[INFO] [stdout] 3851 | ...                   match self.jjtree_close_node_scope(jjtn004) { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3851 -                                     match self.jjtree_close_node_scope(jjtn004) { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 3851 +                                     match self.jjtree_close_node_scope(jjtn004) { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3851 -                                     match self.jjtree_close_node_scope(jjtn004) { Ok(__v) => __v, Err(__e) => break 'try7 Err(__e.into()) };
[INFO] [stdout] 3851 +                                     match self.jjtree_close_node_scope(jjtn004) { Ok(__v) => __v, Err(__e) => break 'try7 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3879:127
[INFO] [stdout]      |
[INFO] [stdout] 3879 | ...                   match self.jjtree_close_node_scope(jjtn005) { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3879 -                                     match self.jjtree_close_node_scope(jjtn005) { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout] 3879 +                                     match self.jjtree_close_node_scope(jjtn005) { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3879 -                                     match self.jjtree_close_node_scope(jjtn005) { Ok(__v) => __v, Err(__e) => break 'try8 Err(__e.into()) };
[INFO] [stdout] 3879 +                                     match self.jjtree_close_node_scope(jjtn005) { Ok(__v) => __v, Err(__e) => break 'try8 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3907:127
[INFO] [stdout]      |
[INFO] [stdout] 3907 | ...                   match self.jjtree_close_node_scope(jjtn006) { Ok(__v) => __v, Err(__e) => break 'try9 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                                 ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3907 -                                     match self.jjtree_close_node_scope(jjtn006) { Ok(__v) => __v, Err(__e) => break 'try9 Err(__e.into()) };
[INFO] [stdout] 3907 +                                     match self.jjtree_close_node_scope(jjtn006) { Ok(__v) => __v, Err(__e) => break 'try9 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3907 -                                     match self.jjtree_close_node_scope(jjtn006) { Ok(__v) => __v, Err(__e) => break 'try9 Err(__e.into()) };
[INFO] [stdout] 3907 +                                     match self.jjtree_close_node_scope(jjtn006) { Ok(__v) => __v, Err(__e) => break 'try9 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3950:105
[INFO] [stdout]      |
[INFO] [stdout] 3950 |             let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                         ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3950 -             let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3950 +             let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3950 -             let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3950 +             let _ = match self.jj_consume_token(LBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3951:83
[INFO] [stdout]      |
[INFO] [stdout] 3951 |             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3951 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3951 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3951 -             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3951 +             match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:3952:105
[INFO] [stdout]      |
[INFO] [stdout] 3952 |             let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                         ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 3952 -             let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3952 +             let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 3952 -             let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 3952 +             let _ = match self.jj_consume_token(RBRACKET) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4010:99
[INFO] [stdout]      |
[INFO] [stdout] 4010 |         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                   ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4010 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4010 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4010 -         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4010 +         let _ = match self.jj_consume_token(LPAREN) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4011:79
[INFO] [stdout]      |
[INFO] [stdout] 4011 |         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                               ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4011 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4011 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4011 -         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4011 +         match self.expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4017:103
[INFO] [stdout]      |
[INFO] [stdout] 4017 |             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4017 -             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 4017 +             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4017 -             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try2 Err(__e.into()) };
[INFO] [stdout] 4017 +             let _ = match self.jj_consume_token(RPAREN) { Ok(__v) => __v, Err(__e) => break 'try2 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4023:107
[INFO] [stdout]      |
[INFO] [stdout] 4023 |                 match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                                           ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4023 -                 match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4023 +                 match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4023 -                 match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4023 +                 match self.jjtree_close_node_scope(jjtn001) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4032:93
[INFO] [stdout]      |
[INFO] [stdout] 4032 |             if match self.jj_2_34(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]      |                                                                                             ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4032 -             if match self.jj_2_34(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 4032 +             if match self.jj_2_34(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4032 -             if match self.jj_2_34(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 4032 +             if match self.jj_2_34(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4036:82
[INFO] [stdout]      |
[INFO] [stdout] 4036 |             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                  ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4036 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4036 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4036 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4036 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4110:82
[INFO] [stdout]      |
[INFO] [stdout] 4110 |         match self.member_access() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                  ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4110 -         match self.member_access() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4110 +         match self.member_access() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4110 -         match self.member_access() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4110 +         match self.member_access() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4112:82
[INFO] [stdout]      |
[INFO] [stdout] 4112 |             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                  ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4112 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4112 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4112 -             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4112 +             match self.arguments() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4113:93
[INFO] [stdout]      |
[INFO] [stdout] 4113 |             if match self.jj_2_44(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]      |                                                                                             ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4113 -             if match self.jj_2_44(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 4113 +             if match self.jj_2_44(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4113 -             if match self.jj_2_44(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 4113 +             if match self.jj_2_44(2147483647) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4170:87
[INFO] [stdout]      |
[INFO] [stdout] 4170 |         match self.primary_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                       ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4170 -         match self.primary_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4170 +         match self.primary_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4170 -         match self.primary_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4170 +         match self.primary_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4172:84
[INFO] [stdout]      |
[INFO] [stdout] 4172 |             if match self.jj_2_46(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout]      |                                                                                    ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4172 -             if match self.jj_2_46(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 4172 +             if match self.jj_2_46(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) } {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4172 -             if match self.jj_2_46(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) } {
[INFO] [stdout] 4172 +             if match self.jj_2_46(2) { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) } {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `PErr`
[INFO] [stdout]     --> src/parser/parser_gen.rs:4176:90
[INFO] [stdout]      |
[INFO] [stdout] 4176 |             match self.member_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout]      |                                                                                          ^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4176 -             match self.member_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4176 +             match self.member_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e) };
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4176 -             match self.member_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(__e.into()) };
[INFO] [stdout] 4176 +             match self.member_expression() { Ok(__v) => __v, Err(__e) => break 'try1 Err(<PErr as Into<_>>::into(__e)) };
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `rust-jexl3` (lib) due to 237 previous errors
[INFO] [stderr] warning: unused dependency `log`
[INFO] [stderr]  --> Cargo.toml:4:15
[INFO] [stderr]   |
[INFO] [stderr] 4 | [dependencies.log]
[INFO] [stderr]   |               ^^^^
[INFO] [stderr]   |
[INFO] [stderr]   = note: `cargo::unused_dependencies` is set to `warn` by default
[INFO] [stderr] help: consider removing the dependency on `log`
[INFO] [stderr] warning: `rust-jexl3` (manifest) generated 1 warning
[INFO] running `Command { std: "docker" "inspect" "82308f961bd46803deaae22fcf575eda6775d5a9da076c3845b98aae7b91e998", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "82308f961bd46803deaae22fcf575eda6775d5a9da076c3845b98aae7b91e998", kill_on_drop: false }`
[INFO] [stdout] 82308f961bd46803deaae22fcf575eda6775d5a9da076c3845b98aae7b91e998
