[INFO] cloning repository https://github.com/Junsung-Kim/rust-jexl3 [INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/Junsung-Kim/rust-jexl3" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FJunsung-Kim%2Frust-jexl3", kill_on_drop: false }` [INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FJunsung-Kim%2Frust-jexl3'... [INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }` [INFO] [stdout] 5f58e093da9c80d7c1e7fdf84d7434a92137250a [INFO] checking Junsung-Kim/rust-jexl3 against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4 [INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FJunsung-Kim%2Frust-jexl3" "/workspace/builds/worker-4-tc2/source", kill_on_drop: false }` [INFO] [stderr] Cloning into '/workspace/builds/worker-4-tc2/source'... [INFO] [stderr] done. [INFO] started tweaking git repo https://github.com/Junsung-Kim/rust-jexl3 [INFO] finished tweaking git repo https://github.com/Junsung-Kim/rust-jexl3 [INFO] tweaked toml for git repo https://github.com/Junsung-Kim/rust-jexl3 written to /workspace/builds/worker-4-tc2/source/Cargo.toml [INFO] validating manifest of git repo https://github.com/Junsung-Kim/rust-jexl3 on toolchain 52995a223f2919dd3e2e427231db90a257350ded [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }` [INFO] crate git repo https://github.com/Junsung-Kim/rust-jexl3 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" "+52995a223f2919dd3e2e427231db90a257350ded" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] [stderr] warning: `package.homepage` is redundant with `package.repository` [INFO] [stderr] --> Cargo.toml:17:12 [INFO] [stderr] | [INFO] [stderr] 17 | homepage = "https://github.com/Junsung-Kim/rust-jexl3" [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 22 | 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] [stderr] Blocking waiting for file lock on package cache [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-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] ccc9480141bfd932f184c2bef4634d9883ff3ae978cf7510b66ae4a5ab8df3e8 [INFO] running `Command { std: "docker" "start" "ccc9480141bfd932f184c2bef4634d9883ff3ae978cf7510b66ae4a5ab8df3e8", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "ccc9480141bfd932f184c2bef4634d9883ff3ae978cf7510b66ae4a5ab8df3e8", 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" "ccc9480141bfd932f184c2bef4634d9883ff3ae978cf7510b66ae4a5ab8df3e8" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "ccc9480141bfd932f184c2bef4634d9883ff3ae978cf7510b66ae4a5ab8df3e8", 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" "ccc9480141bfd932f184c2bef4634d9883ff3ae978cf7510b66ae4a5ab8df3e8" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "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:17:12 [INFO] [stderr] | [INFO] [stderr] 17 | homepage = "https://github.com/Junsung-Kim/rust-jexl3" [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 22 | 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] Compiling num-traits v0.2.19 [INFO] [stderr] Checking regex-syntax v0.8.11 [INFO] [stderr] Checking log v0.4.34 [INFO] [stderr] Checking num-integer v0.1.47 [INFO] [stderr] Checking num-bigint v0.5.1 [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 Into for T` blanket implementation and type inference, which is 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::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 Into for T` blanket implementation and type inference, which is 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::into(__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 Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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(>::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:3:1 [INFO] [stderr] | [INFO] [stderr] 3 | log = "0.4" [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" "ccc9480141bfd932f184c2bef4634d9883ff3ae978cf7510b66ae4a5ab8df3e8", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "ccc9480141bfd932f184c2bef4634d9883ff3ae978cf7510b66ae4a5ab8df3e8", kill_on_drop: false }` [INFO] [stdout] ccc9480141bfd932f184c2bef4634d9883ff3ae978cf7510b66ae4a5ab8df3e8