[INFO] cloning repository https://github.com/stenbror/ActiveOberon2019
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/stenbror/ActiveOberon2019" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fstenbror%2FActiveOberon2019", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fstenbror%2FActiveOberon2019'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] b3b5abb7f8bd1f724765dce1a5e59fc54e60192c
[INFO] checking stenbror/ActiveOberon2019 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fstenbror%2FActiveOberon2019" "/workspace/builds/worker-2-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-2-tc2/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/stenbror/ActiveOberon2019
[INFO] finished tweaking git repo https://github.com/stenbror/ActiveOberon2019
[INFO] tweaked toml for git repo https://github.com/stenbror/ActiveOberon2019 written to /workspace/builds/worker-2-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/stenbror/ActiveOberon2019 on toolchain a5689b034ad287112f709693384a37f1377eb9cc
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate git repo https://github.com/stenbror/ActiveOberon2019 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-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] bb9743a8e582d6bbfdc2660c80031d2c7de412d6f6f787c28eb68e47af537477
[INFO] running `Command { std: "docker" "start" "bb9743a8e582d6bbfdc2660c80031d2c7de412d6f6f787c28eb68e47af537477", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "bb9743a8e582d6bbfdc2660c80031d2c7de412d6f6f787c28eb68e47af537477", 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" "bb9743a8e582d6bbfdc2660c80031d2c7de412d6f6f787c28eb68e47af537477" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "bb9743a8e582d6bbfdc2660c80031d2c7de412d6f6f787c28eb68e47af537477", 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" "bb9743a8e582d6bbfdc2660c80031d2c7de412d6f6f787c28eb68e47af537477" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling semver v1.0.23
[INFO] [stderr]    Compiling time-core v0.1.2
[INFO] [stderr]     Checking inline_colorization v0.1.6
[INFO] [stderr]    Compiling proc-macro2 v1.0.86
[INFO] [stderr]    Compiling deranged v0.3.11
[INFO] [stderr]    Compiling time-macros v0.2.18
[INFO] [stderr]    Compiling rustc_version v0.4.0
[INFO] [stderr]    Compiling quote v1.0.36
[INFO] [stderr]    Compiling time v0.3.36
[INFO] [stderr]    Compiling compile-time v0.2.0
[INFO] [stderr]     Checking ActiveOberon2019 v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] warning: multiple variants are never constructed
[INFO] [stdout]    --> src/scanner.rs:46:5
[INFO] [stdout]     |
[INFO] [stdout]  21 | pub enum Symbols {
[INFO] [stdout]     |          ------- variants in this enum
[INFO] [stdout] ...
[INFO] [stdout]  46 |     Ignore(usize),
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout]  64 |     New(usize),
[INFO] [stdout]     |     ^^^
[INFO] [stdout] ...
[INFO] [stdout]  76 |     Any(usize),
[INFO] [stdout]     |     ^^^
[INFO] [stdout] ...
[INFO] [stdout] 133 |     GreatterGreaterQ(usize), // >>?
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 137 |     Number(usize, Box<String>),
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout] 138 |     String(usize, Box<String>),
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout] 139 |     Char(usize),
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `Symbols` has derived impls for the traits `Debug` and `Clone`, but these are intentionally ignored during dead code analysis
[INFO] [stdout]     = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:138:76
[INFO] [stdout]     |
[INFO] [stdout] 138 |                         return Ok(Rc::new(SyntaxNode::AddressOf(p.clone(), right.into())));
[INFO] [stdout]     |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 138 -                         return Ok(Rc::new(SyntaxNode::AddressOf(p.clone(), right.into())));
[INFO] [stdout] 138 +                         return Ok(Rc::new(SyntaxNode::AddressOf(p.clone(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 138 -                         return Ok(Rc::new(SyntaxNode::AddressOf(p.clone(), right.into())));
[INFO] [stdout] 138 +                         return Ok(Rc::new(SyntaxNode::AddressOf(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:151:74
[INFO] [stdout]     |
[INFO] [stdout] 151 |                         return Ok(Rc::new(SyntaxNode::AliasOf(p.clone(), right.into())));
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 151 -                         return Ok(Rc::new(SyntaxNode::AliasOf(p.clone(), right.into())));
[INFO] [stdout] 151 +                         return Ok(Rc::new(SyntaxNode::AliasOf(p.clone(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 151 -                         return Ok(Rc::new(SyntaxNode::AliasOf(p.clone(), right.into())));
[INFO] [stdout] 151 +                         return Ok(Rc::new(SyntaxNode::AliasOf(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:164:73
[INFO] [stdout]     |
[INFO] [stdout] 164 |                         return Ok(Rc::new(SyntaxNode::SizeOf(p.clone(), right.into())));
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 164 -                         return Ok(Rc::new(SyntaxNode::SizeOf(p.clone(), right.into())));
[INFO] [stdout] 164 +                         return Ok(Rc::new(SyntaxNode::SizeOf(p.clone(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 164 -                         return Ok(Rc::new(SyntaxNode::SizeOf(p.clone(), right.into())));
[INFO] [stdout] 164 +                         return Ok(Rc::new(SyntaxNode::SizeOf(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:212:86
[INFO] [stdout]     |
[INFO] [stdout] 212 |                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags.into())));
[INFO] [stdout]     |                                                                                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 212 -                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags.into())));
[INFO] [stdout] 212 +                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left, right.into(), flags.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 212 -                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags.into())));
[INFO] [stdout] 212 +                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into(), flags.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:212:99
[INFO] [stdout]     |
[INFO] [stdout] 212 |                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags.into())));
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 212 -                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags.into())));
[INFO] [stdout] 212 +                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right, flags.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 212 -                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags.into())));
[INFO] [stdout] 212 +                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right), flags.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:212:113
[INFO] [stdout]     |
[INFO] [stdout] 212 |                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags.into())));
[INFO] [stdout]     |                                                                                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 212 -                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags.into())));
[INFO] [stdout] 212 +                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 212 -                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags.into())));
[INFO] [stdout] 212 +                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), <Rc<SyntaxNode> as Into<_>>::into(flags))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:215:77
[INFO] [stdout]     |
[INFO] [stdout] 215 |                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 215 -                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), left.into(), right.into())));
[INFO] [stdout] 215 +                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 215 -                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), left.into(), right.into())));
[INFO] [stdout] 215 +                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:215:90
[INFO] [stdout]     |
[INFO] [stdout] 215 |                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 215 -                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), left.into(), right.into())));
[INFO] [stdout] 215 +                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 215 -                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), left.into(), right.into())));
[INFO] [stdout] 215 +                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:221:78
[INFO] [stdout]     |
[INFO] [stdout] 221 |                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), Rc::new(SyntaxNode::None), flags.into())));
[INFO] [stdout]     |                                                                              ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 221 -                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), Rc::new(SyntaxNode::None), flags.into())));
[INFO] [stdout] 221 +                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left, Rc::new(SyntaxNode::None), flags.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 221 -                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), Rc::new(SyntaxNode::None), flags.into())));
[INFO] [stdout] 221 +                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), Rc::new(SyntaxNode::None), flags.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:221:118
[INFO] [stdout]     |
[INFO] [stdout] 221 |                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), Rc::new(SyntaxNode::None), flags.into())));
[INFO] [stdout]     |                                                                                                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 221 -                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), Rc::new(SyntaxNode::None), flags.into())));
[INFO] [stdout] 221 +                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), Rc::new(SyntaxNode::None), flags)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 221 -                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), Rc::new(SyntaxNode::None), flags.into())));
[INFO] [stdout] 221 +                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), Rc::new(SyntaxNode::None), <Rc<SyntaxNode> as Into<_>>::into(flags))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:234:68
[INFO] [stdout]     |
[INFO] [stdout] 234 |                 return Ok(Rc::new(SyntaxNode::UnaryPlus(p.clone(), right.into())));
[INFO] [stdout]     |                                                                    ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 234 -                 return Ok(Rc::new(SyntaxNode::UnaryPlus(p.clone(), right.into())));
[INFO] [stdout] 234 +                 return Ok(Rc::new(SyntaxNode::UnaryPlus(p.clone(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 234 -                 return Ok(Rc::new(SyntaxNode::UnaryPlus(p.clone(), right.into())));
[INFO] [stdout] 234 +                 return Ok(Rc::new(SyntaxNode::UnaryPlus(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:239:69
[INFO] [stdout]     |
[INFO] [stdout] 239 |                 return Ok(Rc::new(SyntaxNode::UnaryMinus(p.clone(), right.into())));
[INFO] [stdout]     |                                                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 239 -                 return Ok(Rc::new(SyntaxNode::UnaryMinus(p.clone(), right.into())));
[INFO] [stdout] 239 +                 return Ok(Rc::new(SyntaxNode::UnaryMinus(p.clone(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 239 -                 return Ok(Rc::new(SyntaxNode::UnaryMinus(p.clone(), right.into())));
[INFO] [stdout] 239 +                 return Ok(Rc::new(SyntaxNode::UnaryMinus(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:244:67
[INFO] [stdout]     |
[INFO] [stdout] 244 |                 return Ok(Rc::new(SyntaxNode::UnaryNot(p.clone(), right.into())));
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 244 -                 return Ok(Rc::new(SyntaxNode::UnaryNot(p.clone(), right.into())));
[INFO] [stdout] 244 +                 return Ok(Rc::new(SyntaxNode::UnaryNot(p.clone(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 244 -                 return Ok(Rc::new(SyntaxNode::UnaryNot(p.clone(), right.into())));
[INFO] [stdout] 244 +                 return Ok(Rc::new(SyntaxNode::UnaryNot(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:257:63
[INFO] [stdout]     |
[INFO] [stdout] 257 |                     left = Rc::new(SyntaxNode::Mul(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                               ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 257 -                     left = Rc::new(SyntaxNode::Mul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 257 +                     left = Rc::new(SyntaxNode::Mul(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 257 -                     left = Rc::new(SyntaxNode::Mul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 257 +                     left = Rc::new(SyntaxNode::Mul(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:257:76
[INFO] [stdout]     |
[INFO] [stdout] 257 |                     left = Rc::new(SyntaxNode::Mul(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 257 -                     left = Rc::new(SyntaxNode::Mul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 257 +                     left = Rc::new(SyntaxNode::Mul(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 257 -                     left = Rc::new(SyntaxNode::Mul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 257 +                     left = Rc::new(SyntaxNode::Mul(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:262:65
[INFO] [stdout]     |
[INFO] [stdout] 262 |                     left = Rc::new(SyntaxNode::Slash(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 262 -                     left = Rc::new(SyntaxNode::Slash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 262 +                     left = Rc::new(SyntaxNode::Slash(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 262 -                     left = Rc::new(SyntaxNode::Slash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 262 +                     left = Rc::new(SyntaxNode::Slash(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:262:78
[INFO] [stdout]     |
[INFO] [stdout] 262 |                     left = Rc::new(SyntaxNode::Slash(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 262 -                     left = Rc::new(SyntaxNode::Slash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 262 +                     left = Rc::new(SyntaxNode::Slash(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 262 -                     left = Rc::new(SyntaxNode::Slash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 262 +                     left = Rc::new(SyntaxNode::Slash(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:267:63
[INFO] [stdout]     |
[INFO] [stdout] 267 |                     left = Rc::new(SyntaxNode::Div(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                               ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 267 -                     left = Rc::new(SyntaxNode::Div(p.clone(), left.into(), right.into()));
[INFO] [stdout] 267 +                     left = Rc::new(SyntaxNode::Div(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 267 -                     left = Rc::new(SyntaxNode::Div(p.clone(), left.into(), right.into()));
[INFO] [stdout] 267 +                     left = Rc::new(SyntaxNode::Div(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:267:76
[INFO] [stdout]     |
[INFO] [stdout] 267 |                     left = Rc::new(SyntaxNode::Div(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 267 -                     left = Rc::new(SyntaxNode::Div(p.clone(), left.into(), right.into()));
[INFO] [stdout] 267 +                     left = Rc::new(SyntaxNode::Div(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 267 -                     left = Rc::new(SyntaxNode::Div(p.clone(), left.into(), right.into()));
[INFO] [stdout] 267 +                     left = Rc::new(SyntaxNode::Div(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:272:63
[INFO] [stdout]     |
[INFO] [stdout] 272 |                     left = Rc::new(SyntaxNode::Mod(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                               ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 272 -                     left = Rc::new(SyntaxNode::Mod(p.clone(), left.into(), right.into()));
[INFO] [stdout] 272 +                     left = Rc::new(SyntaxNode::Mod(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 272 -                     left = Rc::new(SyntaxNode::Mod(p.clone(), left.into(), right.into()));
[INFO] [stdout] 272 +                     left = Rc::new(SyntaxNode::Mod(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:272:76
[INFO] [stdout]     |
[INFO] [stdout] 272 |                     left = Rc::new(SyntaxNode::Mod(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 272 -                     left = Rc::new(SyntaxNode::Mod(p.clone(), left.into(), right.into()));
[INFO] [stdout] 272 +                     left = Rc::new(SyntaxNode::Mod(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 272 -                     left = Rc::new(SyntaxNode::Mod(p.clone(), left.into(), right.into()));
[INFO] [stdout] 272 +                     left = Rc::new(SyntaxNode::Mod(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:277:63
[INFO] [stdout]     |
[INFO] [stdout] 277 |                     left = Rc::new(SyntaxNode::And(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                               ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 277 -                     left = Rc::new(SyntaxNode::And(p.clone(), left.into(), right.into()));
[INFO] [stdout] 277 +                     left = Rc::new(SyntaxNode::And(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 277 -                     left = Rc::new(SyntaxNode::And(p.clone(), left.into(), right.into()));
[INFO] [stdout] 277 +                     left = Rc::new(SyntaxNode::And(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:277:76
[INFO] [stdout]     |
[INFO] [stdout] 277 |                     left = Rc::new(SyntaxNode::And(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 277 -                     left = Rc::new(SyntaxNode::And(p.clone(), left.into(), right.into()));
[INFO] [stdout] 277 +                     left = Rc::new(SyntaxNode::And(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 277 -                     left = Rc::new(SyntaxNode::And(p.clone(), left.into(), right.into()));
[INFO] [stdout] 277 +                     left = Rc::new(SyntaxNode::And(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:282:66
[INFO] [stdout]     |
[INFO] [stdout] 282 |                     left = Rc::new(SyntaxNode::DotMul(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 282 -                     left = Rc::new(SyntaxNode::DotMul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 282 +                     left = Rc::new(SyntaxNode::DotMul(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 282 -                     left = Rc::new(SyntaxNode::DotMul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 282 +                     left = Rc::new(SyntaxNode::DotMul(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:282:79
[INFO] [stdout]     |
[INFO] [stdout] 282 |                     left = Rc::new(SyntaxNode::DotMul(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 282 -                     left = Rc::new(SyntaxNode::DotMul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 282 +                     left = Rc::new(SyntaxNode::DotMul(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 282 -                     left = Rc::new(SyntaxNode::DotMul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 282 +                     left = Rc::new(SyntaxNode::DotMul(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:287:68
[INFO] [stdout]     |
[INFO] [stdout] 287 |                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                    ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 287 +                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 287 -                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 287 +                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:287:81
[INFO] [stdout]     |
[INFO] [stdout] 287 |                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 287 +                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 287 -                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 287 +                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:292:69
[INFO] [stdout]     |
[INFO] [stdout] 292 |                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                     ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 292 -                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 292 +                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 292 -                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 292 +                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:292:82
[INFO] [stdout]     |
[INFO] [stdout] 292 |                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                                  ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 292 -                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 292 +                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 292 -                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 292 +                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:297:65
[INFO] [stdout]     |
[INFO] [stdout] 297 |                     left = Rc::new(SyntaxNode::Power(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 297 -                     left = Rc::new(SyntaxNode::Power(p.clone(), left.into(), right.into()));
[INFO] [stdout] 297 +                     left = Rc::new(SyntaxNode::Power(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 297 -                     left = Rc::new(SyntaxNode::Power(p.clone(), left.into(), right.into()));
[INFO] [stdout] 297 +                     left = Rc::new(SyntaxNode::Power(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:297:78
[INFO] [stdout]     |
[INFO] [stdout] 297 |                     left = Rc::new(SyntaxNode::Power(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 297 -                     left = Rc::new(SyntaxNode::Power(p.clone(), left.into(), right.into()));
[INFO] [stdout] 297 +                     left = Rc::new(SyntaxNode::Power(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 297 -                     left = Rc::new(SyntaxNode::Power(p.clone(), left.into(), right.into()));
[INFO] [stdout] 297 +                     left = Rc::new(SyntaxNode::Power(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:302:67
[INFO] [stdout]     |
[INFO] [stdout] 302 |                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 302 -                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 302 +                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 302 -                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 302 +                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:302:80
[INFO] [stdout]     |
[INFO] [stdout] 302 |                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 302 -                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 302 +                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 302 -                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 302 +                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:318:64
[INFO] [stdout]     |
[INFO] [stdout] 318 |                     left = Rc::new(SyntaxNode::Plus(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 318 -                     left = Rc::new(SyntaxNode::Plus(p.clone(), left.into(), right.into()));
[INFO] [stdout] 318 +                     left = Rc::new(SyntaxNode::Plus(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 318 -                     left = Rc::new(SyntaxNode::Plus(p.clone(), left.into(), right.into()));
[INFO] [stdout] 318 +                     left = Rc::new(SyntaxNode::Plus(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:318:77
[INFO] [stdout]     |
[INFO] [stdout] 318 |                     left = Rc::new(SyntaxNode::Plus(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 318 -                     left = Rc::new(SyntaxNode::Plus(p.clone(), left.into(), right.into()));
[INFO] [stdout] 318 +                     left = Rc::new(SyntaxNode::Plus(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 318 -                     left = Rc::new(SyntaxNode::Plus(p.clone(), left.into(), right.into()));
[INFO] [stdout] 318 +                     left = Rc::new(SyntaxNode::Plus(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:323:65
[INFO] [stdout]     |
[INFO] [stdout] 323 |                     left = Rc::new(SyntaxNode::Minus(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 323 -                     left = Rc::new(SyntaxNode::Minus(p.clone(), left.into(), right.into()));
[INFO] [stdout] 323 +                     left = Rc::new(SyntaxNode::Minus(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 323 -                     left = Rc::new(SyntaxNode::Minus(p.clone(), left.into(), right.into()));
[INFO] [stdout] 323 +                     left = Rc::new(SyntaxNode::Minus(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:323:78
[INFO] [stdout]     |
[INFO] [stdout] 323 |                     left = Rc::new(SyntaxNode::Minus(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 323 -                     left = Rc::new(SyntaxNode::Minus(p.clone(), left.into(), right.into()));
[INFO] [stdout] 323 +                     left = Rc::new(SyntaxNode::Minus(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 323 -                     left = Rc::new(SyntaxNode::Minus(p.clone(), left.into(), right.into()));
[INFO] [stdout] 323 +                     left = Rc::new(SyntaxNode::Minus(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:328:62
[INFO] [stdout]     |
[INFO] [stdout] 328 |                     left = Rc::new(SyntaxNode::Or(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                              ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 328 -                     left = Rc::new(SyntaxNode::Or(p.clone(), left.into(), right.into()));
[INFO] [stdout] 328 +                     left = Rc::new(SyntaxNode::Or(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 328 -                     left = Rc::new(SyntaxNode::Or(p.clone(), left.into(), right.into()));
[INFO] [stdout] 328 +                     left = Rc::new(SyntaxNode::Or(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:328:75
[INFO] [stdout]     |
[INFO] [stdout] 328 |                     left = Rc::new(SyntaxNode::Or(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 328 -                     left = Rc::new(SyntaxNode::Or(p.clone(), left.into(), right.into()));
[INFO] [stdout] 328 +                     left = Rc::new(SyntaxNode::Or(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 328 -                     left = Rc::new(SyntaxNode::Or(p.clone(), left.into(), right.into()));
[INFO] [stdout] 328 +                     left = Rc::new(SyntaxNode::Or(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:360:64
[INFO] [stdout]     |
[INFO] [stdout] 360 |                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout]     |                                                                ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 360 -                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 360 +                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left, right.into(), next.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 360 -                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 360 +                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into(), next.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:360:77
[INFO] [stdout]     |
[INFO] [stdout] 360 |                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 360 -                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 360 +                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right, next.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 360 -                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 360 +                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right), next.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:360:91
[INFO] [stdout]     |
[INFO] [stdout] 360 |                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout]     |                                                                                           ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 360 -                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 360 +                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 360 -                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 360 +                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), <Rc<SyntaxNode> as Into<_>>::into(next))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:380:72
[INFO] [stdout]     |
[INFO] [stdout] 380 |                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout]     |                                                                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 380 -                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 380 +                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left, right.into(), next.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 380 -                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 380 +                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into(), next.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:380:85
[INFO] [stdout]     |
[INFO] [stdout] 380 |                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 380 -                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 380 +                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right, next.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 380 -                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 380 +                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right), next.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:380:99
[INFO] [stdout]     |
[INFO] [stdout] 380 |                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 380 -                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 380 +                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 380 -                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 380 +                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), <Rc<SyntaxNode> as Into<_>>::into(next))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:383:35
[INFO] [stdout]     |
[INFO] [stdout] 383 |                         return Ok(left.into());
[INFO] [stdout]     |                                   ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 383 -                         return Ok(left.into());
[INFO] [stdout] 383 +                         return Ok(left);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 383 -                         return Ok(left.into());
[INFO] [stdout] 383 +                         return Ok(<Rc<SyntaxNode> as Into<_>>::into(left));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:396:64
[INFO] [stdout]     |
[INFO] [stdout] 396 |                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), left.into(), right.into())));
[INFO] [stdout] 396 +                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 396 -                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), left.into(), right.into())));
[INFO] [stdout] 396 +                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:396:77
[INFO] [stdout]     |
[INFO] [stdout] 396 |                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), left.into(), right.into())));
[INFO] [stdout] 396 +                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 396 -                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), left.into(), right.into())));
[INFO] [stdout] 396 +                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:401:66
[INFO] [stdout]     |
[INFO] [stdout] 401 |                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 401 +                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 401 -                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 401 +                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:401:79
[INFO] [stdout]     |
[INFO] [stdout] 401 |                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 401 +                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 401 -                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 401 +                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:406:63
[INFO] [stdout]     |
[INFO] [stdout] 406 |                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                               ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 406 -                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), left.into(), right.into())));
[INFO] [stdout] 406 +                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 406 -                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), left.into(), right.into())));
[INFO] [stdout] 406 +                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:406:76
[INFO] [stdout]     |
[INFO] [stdout] 406 |                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 406 -                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), left.into(), right.into())));
[INFO] [stdout] 406 +                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 406 -                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), left.into(), right.into())));
[INFO] [stdout] 406 +                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:411:68
[INFO] [stdout]     |
[INFO] [stdout] 411 |                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                    ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 411 -                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 411 +                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 411 -                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 411 +                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:411:81
[INFO] [stdout]     |
[INFO] [stdout] 411 |                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 411 -                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 411 +                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 411 -                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 411 +                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:416:66
[INFO] [stdout]     |
[INFO] [stdout] 416 |                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 416 -                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), left.into(), right.into())));
[INFO] [stdout] 416 +                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 -                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), left.into(), right.into())));
[INFO] [stdout] 416 +                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:416:79
[INFO] [stdout]     |
[INFO] [stdout] 416 |                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 416 -                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), left.into(), right.into())));
[INFO] [stdout] 416 +                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 -                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), left.into(), right.into())));
[INFO] [stdout] 416 +                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:421:71
[INFO] [stdout]     |
[INFO] [stdout] 421 |                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                       ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 421 -                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 421 +                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 421 -                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 421 +                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:421:84
[INFO] [stdout]     |
[INFO] [stdout] 421 |                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                    ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 421 -                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 421 +                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 421 -                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 421 +                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:426:61
[INFO] [stdout]     |
[INFO] [stdout] 426 |                 return Ok(Rc::new(SyntaxNode::In(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 426 -                 return Ok(Rc::new(SyntaxNode::In(p.clone(), left.into(), right.into())));
[INFO] [stdout] 426 +                 return Ok(Rc::new(SyntaxNode::In(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 426 -                 return Ok(Rc::new(SyntaxNode::In(p.clone(), left.into(), right.into())));
[INFO] [stdout] 426 +                 return Ok(Rc::new(SyntaxNode::In(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:426:74
[INFO] [stdout]     |
[INFO] [stdout] 426 |                 return Ok(Rc::new(SyntaxNode::In(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 426 -                 return Ok(Rc::new(SyntaxNode::In(p.clone(), left.into(), right.into())));
[INFO] [stdout] 426 +                 return Ok(Rc::new(SyntaxNode::In(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 426 -                 return Ok(Rc::new(SyntaxNode::In(p.clone(), left.into(), right.into())));
[INFO] [stdout] 426 +                 return Ok(Rc::new(SyntaxNode::In(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:431:61
[INFO] [stdout]     |
[INFO] [stdout] 431 |                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 431 -                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), left.into(), right.into())));
[INFO] [stdout] 431 +                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 431 -                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), left.into(), right.into())));
[INFO] [stdout] 431 +                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:431:74
[INFO] [stdout]     |
[INFO] [stdout] 431 |                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 431 -                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), left.into(), right.into())));
[INFO] [stdout] 431 +                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 431 -                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), left.into(), right.into())));
[INFO] [stdout] 431 +                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:436:67
[INFO] [stdout]     |
[INFO] [stdout] 436 |                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 436 +                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 436 -                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 436 +                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:436:80
[INFO] [stdout]     |
[INFO] [stdout] 436 |                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 436 +                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 436 -                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 436 +                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:441:69
[INFO] [stdout]     |
[INFO] [stdout] 441 |                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                     ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 441 -                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 441 +                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 441 -                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 441 +                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:441:82
[INFO] [stdout]     |
[INFO] [stdout] 441 |                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                  ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 441 -                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 441 +                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 441 -                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 441 +                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:446:66
[INFO] [stdout]     |
[INFO] [stdout] 446 |                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 446 -                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), left.into(), right.into())));
[INFO] [stdout] 446 +                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 446 -                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), left.into(), right.into())));
[INFO] [stdout] 446 +                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:446:79
[INFO] [stdout]     |
[INFO] [stdout] 446 |                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 446 -                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), left.into(), right.into())));
[INFO] [stdout] 446 +                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 446 -                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), left.into(), right.into())));
[INFO] [stdout] 446 +                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:451:71
[INFO] [stdout]     |
[INFO] [stdout] 451 |                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                       ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 451 -                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 451 +                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 451 -                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 451 +                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:451:84
[INFO] [stdout]     |
[INFO] [stdout] 451 |                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                    ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 451 -                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 451 +                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 451 -                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 451 +                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:456:69
[INFO] [stdout]     |
[INFO] [stdout] 456 |                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                     ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 456 -                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), left.into(), right.into())));
[INFO] [stdout] 456 +                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 456 -                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), left.into(), right.into())));
[INFO] [stdout] 456 +                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:456:82
[INFO] [stdout]     |
[INFO] [stdout] 456 |                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                  ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 456 -                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), left.into(), right.into())));
[INFO] [stdout] 456 +                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 456 -                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), left.into(), right.into())));
[INFO] [stdout] 456 +                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:461:74
[INFO] [stdout]     |
[INFO] [stdout] 461 |                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 461 -                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 461 +                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 461 -                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 461 +                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:461:87
[INFO] [stdout]     |
[INFO] [stdout] 461 |                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                       ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 461 -                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 461 +                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 461 -                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 461 +                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:466:83
[INFO] [stdout]     |
[INFO] [stdout] 466 |                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 466 -                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), left.into(), right.into())));
[INFO] [stdout] 466 +                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 466 -                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), left.into(), right.into())));
[INFO] [stdout] 466 +                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:466:96
[INFO] [stdout]     |
[INFO] [stdout] 466 |                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 466 -                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), left.into(), right.into())));
[INFO] [stdout] 466 +                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 466 -                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), left.into(), right.into())));
[INFO] [stdout] 466 +                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:471:89
[INFO] [stdout]     |
[INFO] [stdout] 471 |                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 471 -                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), left.into(), right.into())));
[INFO] [stdout] 471 +                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 471 -                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), left.into(), right.into())));
[INFO] [stdout] 471 +                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:471:102
[INFO] [stdout]     |
[INFO] [stdout] 471 |                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 471 -                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), left.into(), right.into())));
[INFO] [stdout] 471 +                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 471 -                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), left.into(), right.into())));
[INFO] [stdout] 471 +                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:476:68
[INFO] [stdout]     |
[INFO] [stdout] 476 |                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                    ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 476 -                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), left.into(), right.into())));
[INFO] [stdout] 476 +                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 476 -                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), left.into(), right.into())));
[INFO] [stdout] 476 +                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:476:81
[INFO] [stdout]     |
[INFO] [stdout] 476 |                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 476 -                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), left.into(), right.into())));
[INFO] [stdout] 476 +                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 476 -                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), left.into(), right.into())));
[INFO] [stdout] 476 +                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:481:74
[INFO] [stdout]     |
[INFO] [stdout] 481 |                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), left.into(), right.into())));
[INFO] [stdout] 481 +                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 481 -                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), left.into(), right.into())));
[INFO] [stdout] 481 +                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:481:87
[INFO] [stdout]     |
[INFO] [stdout] 481 |                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                       ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), left.into(), right.into())));
[INFO] [stdout] 481 +                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 481 -                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), left.into(), right.into())));
[INFO] [stdout] 481 +                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:527:78
[INFO] [stdout]     |
[INFO] [stdout] 527 | ...                   nodes.push(SyntaxNode::DesignatorCall(p.clone(), right.into()))
[INFO] [stdout]     |                                                                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 527 -                             nodes.push(SyntaxNode::DesignatorCall(p.clone(), right.into()))
[INFO] [stdout] 527 +                             nodes.push(SyntaxNode::DesignatorCall(p.clone(), right))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 527 -                             nodes.push(SyntaxNode::DesignatorCall(p.clone(), right.into()))
[INFO] [stdout] 527 +                             nodes.push(SyntaxNode::DesignatorCall(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(right)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:544:79
[INFO] [stdout]     |
[INFO] [stdout] 544 | ...                   nodes.push(SyntaxNode::DesignatorIndex(p.clone(), right.into()))
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 544 -                             nodes.push(SyntaxNode::DesignatorIndex(p.clone(), right.into()))
[INFO] [stdout] 544 +                             nodes.push(SyntaxNode::DesignatorIndex(p.clone(), right))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 544 -                             nodes.push(SyntaxNode::DesignatorIndex(p.clone(), right.into()))
[INFO] [stdout] 544 +                             nodes.push(SyntaxNode::DesignatorIndex(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(right)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:558:79
[INFO] [stdout]     |
[INFO] [stdout] 558 |         return Ok(Rc::new(SyntaxNode::DesignatorElements(pos.clone(), Rc::new(nodes.into()))));
[INFO] [stdout]     |                                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -         return Ok(Rc::new(SyntaxNode::DesignatorElements(pos.clone(), Rc::new(nodes.into()))));
[INFO] [stdout] 558 +         return Ok(Rc::new(SyntaxNode::DesignatorElements(pos.clone(), Rc::new(nodes))));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 558 -         return Ok(Rc::new(SyntaxNode::DesignatorElements(pos.clone(), Rc::new(nodes.into()))));
[INFO] [stdout] 558 +         return Ok(Rc::new(SyntaxNode::DesignatorElements(pos.clone(), Rc::new(<Vec<SyntaxNode> as Into<_>>::into(nodes)))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `ActiveOberon2019` (bin "ActiveOberon2019") due to 85 previous errors; 1 warning emitted
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] warning: multiple variants are never constructed
[INFO] [stdout]    --> src/scanner.rs:46:5
[INFO] [stdout]     |
[INFO] [stdout]  21 | pub enum Symbols {
[INFO] [stdout]     |          ------- variants in this enum
[INFO] [stdout] ...
[INFO] [stdout]  46 |     Ignore(usize),
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout]  64 |     New(usize),
[INFO] [stdout]     |     ^^^
[INFO] [stdout] ...
[INFO] [stdout]  76 |     Any(usize),
[INFO] [stdout]     |     ^^^
[INFO] [stdout] ...
[INFO] [stdout] 133 |     GreatterGreaterQ(usize), // >>?
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 137 |     Number(usize, Box<String>),
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout] 138 |     String(usize, Box<String>),
[INFO] [stdout]     |     ^^^^^^
[INFO] [stdout] 139 |     Char(usize),
[INFO] [stdout]     |     ^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `Symbols` has derived impls for the traits `Debug` and `Clone`, but these are intentionally ignored during dead code analysis
[INFO] [stdout]     = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:138:76
[INFO] [stdout]     |
[INFO] [stdout] 138 |                         return Ok(Rc::new(SyntaxNode::AddressOf(p.clone(), right.into())));
[INFO] [stdout]     |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 138 -                         return Ok(Rc::new(SyntaxNode::AddressOf(p.clone(), right.into())));
[INFO] [stdout] 138 +                         return Ok(Rc::new(SyntaxNode::AddressOf(p.clone(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 138 -                         return Ok(Rc::new(SyntaxNode::AddressOf(p.clone(), right.into())));
[INFO] [stdout] 138 +                         return Ok(Rc::new(SyntaxNode::AddressOf(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:151:74
[INFO] [stdout]     |
[INFO] [stdout] 151 |                         return Ok(Rc::new(SyntaxNode::AliasOf(p.clone(), right.into())));
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 151 -                         return Ok(Rc::new(SyntaxNode::AliasOf(p.clone(), right.into())));
[INFO] [stdout] 151 +                         return Ok(Rc::new(SyntaxNode::AliasOf(p.clone(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 151 -                         return Ok(Rc::new(SyntaxNode::AliasOf(p.clone(), right.into())));
[INFO] [stdout] 151 +                         return Ok(Rc::new(SyntaxNode::AliasOf(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:164:73
[INFO] [stdout]     |
[INFO] [stdout] 164 |                         return Ok(Rc::new(SyntaxNode::SizeOf(p.clone(), right.into())));
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 164 -                         return Ok(Rc::new(SyntaxNode::SizeOf(p.clone(), right.into())));
[INFO] [stdout] 164 +                         return Ok(Rc::new(SyntaxNode::SizeOf(p.clone(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 164 -                         return Ok(Rc::new(SyntaxNode::SizeOf(p.clone(), right.into())));
[INFO] [stdout] 164 +                         return Ok(Rc::new(SyntaxNode::SizeOf(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:212:86
[INFO] [stdout]     |
[INFO] [stdout] 212 |                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags.into())));
[INFO] [stdout]     |                                                                                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 212 -                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags.into())));
[INFO] [stdout] 212 +                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left, right.into(), flags.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 212 -                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags.into())));
[INFO] [stdout] 212 +                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into(), flags.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:212:99
[INFO] [stdout]     |
[INFO] [stdout] 212 |                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags.into())));
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 212 -                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags.into())));
[INFO] [stdout] 212 +                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right, flags.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 212 -                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags.into())));
[INFO] [stdout] 212 +                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right), flags.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:212:113
[INFO] [stdout]     |
[INFO] [stdout] 212 |                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags.into())));
[INFO] [stdout]     |                                                                                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 212 -                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags.into())));
[INFO] [stdout] 212 +                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 212 -                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), flags.into())));
[INFO] [stdout] 212 +                         return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), right.into(), <Rc<SyntaxNode> as Into<_>>::into(flags))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:215:77
[INFO] [stdout]     |
[INFO] [stdout] 215 |                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 215 -                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), left.into(), right.into())));
[INFO] [stdout] 215 +                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 215 -                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), left.into(), right.into())));
[INFO] [stdout] 215 +                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:215:90
[INFO] [stdout]     |
[INFO] [stdout] 215 |                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 215 -                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), left.into(), right.into())));
[INFO] [stdout] 215 +                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 215 -                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), left.into(), right.into())));
[INFO] [stdout] 215 +                         return Ok(Rc::new(SyntaxNode::Designator(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:221:78
[INFO] [stdout]     |
[INFO] [stdout] 221 |                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), Rc::new(SyntaxNode::None), flags.into())));
[INFO] [stdout]     |                                                                              ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 221 -                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), Rc::new(SyntaxNode::None), flags.into())));
[INFO] [stdout] 221 +                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left, Rc::new(SyntaxNode::None), flags.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 221 -                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), Rc::new(SyntaxNode::None), flags.into())));
[INFO] [stdout] 221 +                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), Rc::new(SyntaxNode::None), flags.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:221:118
[INFO] [stdout]     |
[INFO] [stdout] 221 |                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), Rc::new(SyntaxNode::None), flags.into())));
[INFO] [stdout]     |                                                                                                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 221 -                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), Rc::new(SyntaxNode::None), flags.into())));
[INFO] [stdout] 221 +                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), Rc::new(SyntaxNode::None), flags)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 221 -                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), Rc::new(SyntaxNode::None), flags.into())));
[INFO] [stdout] 221 +                 return Ok(Rc::new(SyntaxNode::DesignatorWithFlags(p.clone(), left.into(), Rc::new(SyntaxNode::None), <Rc<SyntaxNode> as Into<_>>::into(flags))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:234:68
[INFO] [stdout]     |
[INFO] [stdout] 234 |                 return Ok(Rc::new(SyntaxNode::UnaryPlus(p.clone(), right.into())));
[INFO] [stdout]     |                                                                    ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 234 -                 return Ok(Rc::new(SyntaxNode::UnaryPlus(p.clone(), right.into())));
[INFO] [stdout] 234 +                 return Ok(Rc::new(SyntaxNode::UnaryPlus(p.clone(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 234 -                 return Ok(Rc::new(SyntaxNode::UnaryPlus(p.clone(), right.into())));
[INFO] [stdout] 234 +                 return Ok(Rc::new(SyntaxNode::UnaryPlus(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:239:69
[INFO] [stdout]     |
[INFO] [stdout] 239 |                 return Ok(Rc::new(SyntaxNode::UnaryMinus(p.clone(), right.into())));
[INFO] [stdout]     |                                                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 239 -                 return Ok(Rc::new(SyntaxNode::UnaryMinus(p.clone(), right.into())));
[INFO] [stdout] 239 +                 return Ok(Rc::new(SyntaxNode::UnaryMinus(p.clone(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 239 -                 return Ok(Rc::new(SyntaxNode::UnaryMinus(p.clone(), right.into())));
[INFO] [stdout] 239 +                 return Ok(Rc::new(SyntaxNode::UnaryMinus(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:244:67
[INFO] [stdout]     |
[INFO] [stdout] 244 |                 return Ok(Rc::new(SyntaxNode::UnaryNot(p.clone(), right.into())));
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 244 -                 return Ok(Rc::new(SyntaxNode::UnaryNot(p.clone(), right.into())));
[INFO] [stdout] 244 +                 return Ok(Rc::new(SyntaxNode::UnaryNot(p.clone(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 244 -                 return Ok(Rc::new(SyntaxNode::UnaryNot(p.clone(), right.into())));
[INFO] [stdout] 244 +                 return Ok(Rc::new(SyntaxNode::UnaryNot(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:257:63
[INFO] [stdout]     |
[INFO] [stdout] 257 |                     left = Rc::new(SyntaxNode::Mul(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                               ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 257 -                     left = Rc::new(SyntaxNode::Mul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 257 +                     left = Rc::new(SyntaxNode::Mul(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 257 -                     left = Rc::new(SyntaxNode::Mul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 257 +                     left = Rc::new(SyntaxNode::Mul(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:257:76
[INFO] [stdout]     |
[INFO] [stdout] 257 |                     left = Rc::new(SyntaxNode::Mul(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 257 -                     left = Rc::new(SyntaxNode::Mul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 257 +                     left = Rc::new(SyntaxNode::Mul(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 257 -                     left = Rc::new(SyntaxNode::Mul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 257 +                     left = Rc::new(SyntaxNode::Mul(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:262:65
[INFO] [stdout]     |
[INFO] [stdout] 262 |                     left = Rc::new(SyntaxNode::Slash(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 262 -                     left = Rc::new(SyntaxNode::Slash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 262 +                     left = Rc::new(SyntaxNode::Slash(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 262 -                     left = Rc::new(SyntaxNode::Slash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 262 +                     left = Rc::new(SyntaxNode::Slash(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:262:78
[INFO] [stdout]     |
[INFO] [stdout] 262 |                     left = Rc::new(SyntaxNode::Slash(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 262 -                     left = Rc::new(SyntaxNode::Slash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 262 +                     left = Rc::new(SyntaxNode::Slash(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 262 -                     left = Rc::new(SyntaxNode::Slash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 262 +                     left = Rc::new(SyntaxNode::Slash(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:267:63
[INFO] [stdout]     |
[INFO] [stdout] 267 |                     left = Rc::new(SyntaxNode::Div(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                               ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 267 -                     left = Rc::new(SyntaxNode::Div(p.clone(), left.into(), right.into()));
[INFO] [stdout] 267 +                     left = Rc::new(SyntaxNode::Div(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 267 -                     left = Rc::new(SyntaxNode::Div(p.clone(), left.into(), right.into()));
[INFO] [stdout] 267 +                     left = Rc::new(SyntaxNode::Div(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:267:76
[INFO] [stdout]     |
[INFO] [stdout] 267 |                     left = Rc::new(SyntaxNode::Div(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 267 -                     left = Rc::new(SyntaxNode::Div(p.clone(), left.into(), right.into()));
[INFO] [stdout] 267 +                     left = Rc::new(SyntaxNode::Div(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 267 -                     left = Rc::new(SyntaxNode::Div(p.clone(), left.into(), right.into()));
[INFO] [stdout] 267 +                     left = Rc::new(SyntaxNode::Div(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:272:63
[INFO] [stdout]     |
[INFO] [stdout] 272 |                     left = Rc::new(SyntaxNode::Mod(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                               ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 272 -                     left = Rc::new(SyntaxNode::Mod(p.clone(), left.into(), right.into()));
[INFO] [stdout] 272 +                     left = Rc::new(SyntaxNode::Mod(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 272 -                     left = Rc::new(SyntaxNode::Mod(p.clone(), left.into(), right.into()));
[INFO] [stdout] 272 +                     left = Rc::new(SyntaxNode::Mod(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:272:76
[INFO] [stdout]     |
[INFO] [stdout] 272 |                     left = Rc::new(SyntaxNode::Mod(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 272 -                     left = Rc::new(SyntaxNode::Mod(p.clone(), left.into(), right.into()));
[INFO] [stdout] 272 +                     left = Rc::new(SyntaxNode::Mod(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 272 -                     left = Rc::new(SyntaxNode::Mod(p.clone(), left.into(), right.into()));
[INFO] [stdout] 272 +                     left = Rc::new(SyntaxNode::Mod(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:277:63
[INFO] [stdout]     |
[INFO] [stdout] 277 |                     left = Rc::new(SyntaxNode::And(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                               ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 277 -                     left = Rc::new(SyntaxNode::And(p.clone(), left.into(), right.into()));
[INFO] [stdout] 277 +                     left = Rc::new(SyntaxNode::And(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 277 -                     left = Rc::new(SyntaxNode::And(p.clone(), left.into(), right.into()));
[INFO] [stdout] 277 +                     left = Rc::new(SyntaxNode::And(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:277:76
[INFO] [stdout]     |
[INFO] [stdout] 277 |                     left = Rc::new(SyntaxNode::And(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 277 -                     left = Rc::new(SyntaxNode::And(p.clone(), left.into(), right.into()));
[INFO] [stdout] 277 +                     left = Rc::new(SyntaxNode::And(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 277 -                     left = Rc::new(SyntaxNode::And(p.clone(), left.into(), right.into()));
[INFO] [stdout] 277 +                     left = Rc::new(SyntaxNode::And(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:282:66
[INFO] [stdout]     |
[INFO] [stdout] 282 |                     left = Rc::new(SyntaxNode::DotMul(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 282 -                     left = Rc::new(SyntaxNode::DotMul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 282 +                     left = Rc::new(SyntaxNode::DotMul(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 282 -                     left = Rc::new(SyntaxNode::DotMul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 282 +                     left = Rc::new(SyntaxNode::DotMul(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:282:79
[INFO] [stdout]     |
[INFO] [stdout] 282 |                     left = Rc::new(SyntaxNode::DotMul(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 282 -                     left = Rc::new(SyntaxNode::DotMul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 282 +                     left = Rc::new(SyntaxNode::DotMul(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 282 -                     left = Rc::new(SyntaxNode::DotMul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 282 +                     left = Rc::new(SyntaxNode::DotMul(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:287:68
[INFO] [stdout]     |
[INFO] [stdout] 287 |                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                    ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 287 +                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 287 -                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 287 +                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:287:81
[INFO] [stdout]     |
[INFO] [stdout] 287 |                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 287 +                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 287 -                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 287 +                     left = Rc::new(SyntaxNode::DotSlash(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:292:69
[INFO] [stdout]     |
[INFO] [stdout] 292 |                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                     ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 292 -                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 292 +                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 292 -                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 292 +                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:292:82
[INFO] [stdout]     |
[INFO] [stdout] 292 |                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                                  ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 292 -                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 292 +                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 292 -                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), left.into(), right.into()));
[INFO] [stdout] 292 +                     left = Rc::new(SyntaxNode::BackSlash(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:297:65
[INFO] [stdout]     |
[INFO] [stdout] 297 |                     left = Rc::new(SyntaxNode::Power(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 297 -                     left = Rc::new(SyntaxNode::Power(p.clone(), left.into(), right.into()));
[INFO] [stdout] 297 +                     left = Rc::new(SyntaxNode::Power(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 297 -                     left = Rc::new(SyntaxNode::Power(p.clone(), left.into(), right.into()));
[INFO] [stdout] 297 +                     left = Rc::new(SyntaxNode::Power(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:297:78
[INFO] [stdout]     |
[INFO] [stdout] 297 |                     left = Rc::new(SyntaxNode::Power(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 297 -                     left = Rc::new(SyntaxNode::Power(p.clone(), left.into(), right.into()));
[INFO] [stdout] 297 +                     left = Rc::new(SyntaxNode::Power(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 297 -                     left = Rc::new(SyntaxNode::Power(p.clone(), left.into(), right.into()));
[INFO] [stdout] 297 +                     left = Rc::new(SyntaxNode::Power(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:302:67
[INFO] [stdout]     |
[INFO] [stdout] 302 |                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 302 -                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 302 +                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 302 -                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 302 +                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:302:80
[INFO] [stdout]     |
[INFO] [stdout] 302 |                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 302 -                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 302 +                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 302 -                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), left.into(), right.into()));
[INFO] [stdout] 302 +                     left = Rc::new(SyntaxNode::PlusMul(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:318:64
[INFO] [stdout]     |
[INFO] [stdout] 318 |                     left = Rc::new(SyntaxNode::Plus(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 318 -                     left = Rc::new(SyntaxNode::Plus(p.clone(), left.into(), right.into()));
[INFO] [stdout] 318 +                     left = Rc::new(SyntaxNode::Plus(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 318 -                     left = Rc::new(SyntaxNode::Plus(p.clone(), left.into(), right.into()));
[INFO] [stdout] 318 +                     left = Rc::new(SyntaxNode::Plus(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:318:77
[INFO] [stdout]     |
[INFO] [stdout] 318 |                     left = Rc::new(SyntaxNode::Plus(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 318 -                     left = Rc::new(SyntaxNode::Plus(p.clone(), left.into(), right.into()));
[INFO] [stdout] 318 +                     left = Rc::new(SyntaxNode::Plus(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 318 -                     left = Rc::new(SyntaxNode::Plus(p.clone(), left.into(), right.into()));
[INFO] [stdout] 318 +                     left = Rc::new(SyntaxNode::Plus(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:323:65
[INFO] [stdout]     |
[INFO] [stdout] 323 |                     left = Rc::new(SyntaxNode::Minus(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 323 -                     left = Rc::new(SyntaxNode::Minus(p.clone(), left.into(), right.into()));
[INFO] [stdout] 323 +                     left = Rc::new(SyntaxNode::Minus(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 323 -                     left = Rc::new(SyntaxNode::Minus(p.clone(), left.into(), right.into()));
[INFO] [stdout] 323 +                     left = Rc::new(SyntaxNode::Minus(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:323:78
[INFO] [stdout]     |
[INFO] [stdout] 323 |                     left = Rc::new(SyntaxNode::Minus(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                              ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 323 -                     left = Rc::new(SyntaxNode::Minus(p.clone(), left.into(), right.into()));
[INFO] [stdout] 323 +                     left = Rc::new(SyntaxNode::Minus(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 323 -                     left = Rc::new(SyntaxNode::Minus(p.clone(), left.into(), right.into()));
[INFO] [stdout] 323 +                     left = Rc::new(SyntaxNode::Minus(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:328:62
[INFO] [stdout]     |
[INFO] [stdout] 328 |                     left = Rc::new(SyntaxNode::Or(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                              ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 328 -                     left = Rc::new(SyntaxNode::Or(p.clone(), left.into(), right.into()));
[INFO] [stdout] 328 +                     left = Rc::new(SyntaxNode::Or(p.clone(), left, right.into()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 328 -                     left = Rc::new(SyntaxNode::Or(p.clone(), left.into(), right.into()));
[INFO] [stdout] 328 +                     left = Rc::new(SyntaxNode::Or(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:328:75
[INFO] [stdout]     |
[INFO] [stdout] 328 |                     left = Rc::new(SyntaxNode::Or(p.clone(), left.into(), right.into()));
[INFO] [stdout]     |                                                                           ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 328 -                     left = Rc::new(SyntaxNode::Or(p.clone(), left.into(), right.into()));
[INFO] [stdout] 328 +                     left = Rc::new(SyntaxNode::Or(p.clone(), left.into(), right));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 328 -                     left = Rc::new(SyntaxNode::Or(p.clone(), left.into(), right.into()));
[INFO] [stdout] 328 +                     left = Rc::new(SyntaxNode::Or(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:360:64
[INFO] [stdout]     |
[INFO] [stdout] 360 |                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout]     |                                                                ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 360 -                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 360 +                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left, right.into(), next.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 360 -                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 360 +                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into(), next.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:360:77
[INFO] [stdout]     |
[INFO] [stdout] 360 |                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 360 -                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 360 +                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right, next.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 360 -                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 360 +                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right), next.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:360:91
[INFO] [stdout]     |
[INFO] [stdout] 360 |                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout]     |                                                                                           ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 360 -                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 360 +                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 360 -                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 360 +                 return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), <Rc<SyntaxNode> as Into<_>>::into(next))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:380:72
[INFO] [stdout]     |
[INFO] [stdout] 380 |                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout]     |                                                                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 380 -                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 380 +                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left, right.into(), next.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 380 -                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 380 +                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into(), next.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:380:85
[INFO] [stdout]     |
[INFO] [stdout] 380 |                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 380 -                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 380 +                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right, next.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 380 -                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 380 +                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right), next.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:380:99
[INFO] [stdout]     |
[INFO] [stdout] 380 |                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout]     |                                                                                                   ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 380 -                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 380 +                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 380 -                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), next.into())));
[INFO] [stdout] 380 +                         return Ok(Rc::new(SyntaxNode::Range(p.clone(), left.into(), right.into(), <Rc<SyntaxNode> as Into<_>>::into(next))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:383:35
[INFO] [stdout]     |
[INFO] [stdout] 383 |                         return Ok(left.into());
[INFO] [stdout]     |                                   ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 383 -                         return Ok(left.into());
[INFO] [stdout] 383 +                         return Ok(left);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 383 -                         return Ok(left.into());
[INFO] [stdout] 383 +                         return Ok(<Rc<SyntaxNode> as Into<_>>::into(left));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:396:64
[INFO] [stdout]     |
[INFO] [stdout] 396 |                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), left.into(), right.into())));
[INFO] [stdout] 396 +                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 396 -                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), left.into(), right.into())));
[INFO] [stdout] 396 +                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:396:77
[INFO] [stdout]     |
[INFO] [stdout] 396 |                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), left.into(), right.into())));
[INFO] [stdout] 396 +                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 396 -                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), left.into(), right.into())));
[INFO] [stdout] 396 +                 return Ok(Rc::new(SyntaxNode::Equal(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:401:66
[INFO] [stdout]     |
[INFO] [stdout] 401 |                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 401 +                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 401 -                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 401 +                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:401:79
[INFO] [stdout]     |
[INFO] [stdout] 401 |                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 401 +                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 401 -                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 401 +                 return Ok(Rc::new(SyntaxNode::UnEqual(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:406:63
[INFO] [stdout]     |
[INFO] [stdout] 406 |                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                               ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 406 -                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), left.into(), right.into())));
[INFO] [stdout] 406 +                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 406 -                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), left.into(), right.into())));
[INFO] [stdout] 406 +                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:406:76
[INFO] [stdout]     |
[INFO] [stdout] 406 |                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 406 -                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), left.into(), right.into())));
[INFO] [stdout] 406 +                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 406 -                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), left.into(), right.into())));
[INFO] [stdout] 406 +                 return Ok(Rc::new(SyntaxNode::Less(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:411:68
[INFO] [stdout]     |
[INFO] [stdout] 411 |                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                    ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 411 -                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 411 +                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 411 -                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 411 +                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:411:81
[INFO] [stdout]     |
[INFO] [stdout] 411 |                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 411 -                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 411 +                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 411 -                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 411 +                 return Ok(Rc::new(SyntaxNode::LessEqual(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:416:66
[INFO] [stdout]     |
[INFO] [stdout] 416 |                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 416 -                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), left.into(), right.into())));
[INFO] [stdout] 416 +                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 -                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), left.into(), right.into())));
[INFO] [stdout] 416 +                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:416:79
[INFO] [stdout]     |
[INFO] [stdout] 416 |                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 416 -                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), left.into(), right.into())));
[INFO] [stdout] 416 +                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 -                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), left.into(), right.into())));
[INFO] [stdout] 416 +                 return Ok(Rc::new(SyntaxNode::Greater(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:421:71
[INFO] [stdout]     |
[INFO] [stdout] 421 |                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                       ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 421 -                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 421 +                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 421 -                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 421 +                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:421:84
[INFO] [stdout]     |
[INFO] [stdout] 421 |                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                    ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 421 -                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 421 +                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 421 -                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 421 +                 return Ok(Rc::new(SyntaxNode::GreaterEqual(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:426:61
[INFO] [stdout]     |
[INFO] [stdout] 426 |                 return Ok(Rc::new(SyntaxNode::In(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 426 -                 return Ok(Rc::new(SyntaxNode::In(p.clone(), left.into(), right.into())));
[INFO] [stdout] 426 +                 return Ok(Rc::new(SyntaxNode::In(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 426 -                 return Ok(Rc::new(SyntaxNode::In(p.clone(), left.into(), right.into())));
[INFO] [stdout] 426 +                 return Ok(Rc::new(SyntaxNode::In(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:426:74
[INFO] [stdout]     |
[INFO] [stdout] 426 |                 return Ok(Rc::new(SyntaxNode::In(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 426 -                 return Ok(Rc::new(SyntaxNode::In(p.clone(), left.into(), right.into())));
[INFO] [stdout] 426 +                 return Ok(Rc::new(SyntaxNode::In(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 426 -                 return Ok(Rc::new(SyntaxNode::In(p.clone(), left.into(), right.into())));
[INFO] [stdout] 426 +                 return Ok(Rc::new(SyntaxNode::In(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:431:61
[INFO] [stdout]     |
[INFO] [stdout] 431 |                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 431 -                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), left.into(), right.into())));
[INFO] [stdout] 431 +                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 431 -                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), left.into(), right.into())));
[INFO] [stdout] 431 +                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:431:74
[INFO] [stdout]     |
[INFO] [stdout] 431 |                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 431 -                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), left.into(), right.into())));
[INFO] [stdout] 431 +                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 431 -                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), left.into(), right.into())));
[INFO] [stdout] 431 +                 return Ok(Rc::new(SyntaxNode::Is(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:436:67
[INFO] [stdout]     |
[INFO] [stdout] 436 |                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 436 +                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 436 -                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 436 +                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:436:80
[INFO] [stdout]     |
[INFO] [stdout] 436 |                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 436 +                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 436 -                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 436 +                 return Ok(Rc::new(SyntaxNode::DotEqual(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:441:69
[INFO] [stdout]     |
[INFO] [stdout] 441 |                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                     ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 441 -                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 441 +                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 441 -                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 441 +                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:441:82
[INFO] [stdout]     |
[INFO] [stdout] 441 |                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                  ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 441 -                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 441 +                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 441 -                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 441 +                 return Ok(Rc::new(SyntaxNode::DotUnEqual(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:446:66
[INFO] [stdout]     |
[INFO] [stdout] 446 |                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                  ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 446 -                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), left.into(), right.into())));
[INFO] [stdout] 446 +                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 446 -                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), left.into(), right.into())));
[INFO] [stdout] 446 +                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:446:79
[INFO] [stdout]     |
[INFO] [stdout] 446 |                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 446 -                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), left.into(), right.into())));
[INFO] [stdout] 446 +                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 446 -                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), left.into(), right.into())));
[INFO] [stdout] 446 +                 return Ok(Rc::new(SyntaxNode::DotLess(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:451:71
[INFO] [stdout]     |
[INFO] [stdout] 451 |                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                       ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 451 -                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 451 +                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 451 -                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 451 +                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:451:84
[INFO] [stdout]     |
[INFO] [stdout] 451 |                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                    ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 451 -                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 451 +                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 451 -                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 451 +                 return Ok(Rc::new(SyntaxNode::DotLessEqual(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:456:69
[INFO] [stdout]     |
[INFO] [stdout] 456 |                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                     ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 456 -                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), left.into(), right.into())));
[INFO] [stdout] 456 +                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 456 -                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), left.into(), right.into())));
[INFO] [stdout] 456 +                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:456:82
[INFO] [stdout]     |
[INFO] [stdout] 456 |                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                  ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 456 -                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), left.into(), right.into())));
[INFO] [stdout] 456 +                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 456 -                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), left.into(), right.into())));
[INFO] [stdout] 456 +                 return Ok(Rc::new(SyntaxNode::DotGreater(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:461:74
[INFO] [stdout]     |
[INFO] [stdout] 461 |                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 461 -                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 461 +                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 461 -                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 461 +                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:461:87
[INFO] [stdout]     |
[INFO] [stdout] 461 |                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                       ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 461 -                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 461 +                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 461 -                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), left.into(), right.into())));
[INFO] [stdout] 461 +                 return Ok(Rc::new(SyntaxNode::DotGreaterEqual(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:466:83
[INFO] [stdout]     |
[INFO] [stdout] 466 |                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 466 -                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), left.into(), right.into())));
[INFO] [stdout] 466 +                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 466 -                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), left.into(), right.into())));
[INFO] [stdout] 466 +                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:466:96
[INFO] [stdout]     |
[INFO] [stdout] 466 |                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                                ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 466 -                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), left.into(), right.into())));
[INFO] [stdout] 466 +                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 466 -                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), left.into(), right.into())));
[INFO] [stdout] 466 +                 return Ok(Rc::new(SyntaxNode::QuestionMarkQuestionMark(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:471:89
[INFO] [stdout]     |
[INFO] [stdout] 471 |                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                         ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 471 -                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), left.into(), right.into())));
[INFO] [stdout] 471 +                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 471 -                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), left.into(), right.into())));
[INFO] [stdout] 471 +                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:471:102
[INFO] [stdout]     |
[INFO] [stdout] 471 |                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 471 -                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), left.into(), right.into())));
[INFO] [stdout] 471 +                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 471 -                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), left.into(), right.into())));
[INFO] [stdout] 471 +                 return Ok(Rc::new(SyntaxNode::ExclamationMarkExclamationMark(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:476:68
[INFO] [stdout]     |
[INFO] [stdout] 476 |                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                    ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 476 -                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), left.into(), right.into())));
[INFO] [stdout] 476 +                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 476 -                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), left.into(), right.into())));
[INFO] [stdout] 476 +                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:476:81
[INFO] [stdout]     |
[INFO] [stdout] 476 |                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 476 -                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), left.into(), right.into())));
[INFO] [stdout] 476 +                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 476 -                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), left.into(), right.into())));
[INFO] [stdout] 476 +                 return Ok(Rc::new(SyntaxNode::LessLessQ(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:481:74
[INFO] [stdout]     |
[INFO] [stdout] 481 |                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), left.into(), right.into())));
[INFO] [stdout] 481 +                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), left, right.into())));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 481 -                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), left.into(), right.into())));
[INFO] [stdout] 481 +                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(left), right.into())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:481:87
[INFO] [stdout]     |
[INFO] [stdout] 481 |                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), left.into(), right.into())));
[INFO] [stdout]     |                                                                                       ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), left.into(), right.into())));
[INFO] [stdout] 481 +                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), left.into(), right)));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 481 -                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), left.into(), right.into())));
[INFO] [stdout] 481 +                 return Ok(Rc::new(SyntaxNode::GreaterGreaterQ(p.clone(), left.into(), <Rc<SyntaxNode> as Into<_>>::into(right))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:527:78
[INFO] [stdout]     |
[INFO] [stdout] 527 | ...                   nodes.push(SyntaxNode::DesignatorCall(p.clone(), right.into()))
[INFO] [stdout]     |                                                                        ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 527 -                             nodes.push(SyntaxNode::DesignatorCall(p.clone(), right.into()))
[INFO] [stdout] 527 +                             nodes.push(SyntaxNode::DesignatorCall(p.clone(), right))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 527 -                             nodes.push(SyntaxNode::DesignatorCall(p.clone(), right.into()))
[INFO] [stdout] 527 +                             nodes.push(SyntaxNode::DesignatorCall(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(right)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:544:79
[INFO] [stdout]     |
[INFO] [stdout] 544 | ...                   nodes.push(SyntaxNode::DesignatorIndex(p.clone(), right.into()))
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 544 -                             nodes.push(SyntaxNode::DesignatorIndex(p.clone(), right.into()))
[INFO] [stdout] 544 +                             nodes.push(SyntaxNode::DesignatorIndex(p.clone(), right))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 544 -                             nodes.push(SyntaxNode::DesignatorIndex(p.clone(), right.into()))
[INFO] [stdout] 544 +                             nodes.push(SyntaxNode::DesignatorIndex(p.clone(), <Rc<SyntaxNode> as Into<_>>::into(right)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<SyntaxNode>`
[INFO] [stdout]    --> src/parser.rs:558:79
[INFO] [stdout]     |
[INFO] [stdout] 558 |         return Ok(Rc::new(SyntaxNode::DesignatorElements(pos.clone(), Rc::new(nodes.into()))));
[INFO] [stdout]     |                                                                               ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -         return Ok(Rc::new(SyntaxNode::DesignatorElements(pos.clone(), Rc::new(nodes.into()))));
[INFO] [stdout] 558 +         return Ok(Rc::new(SyntaxNode::DesignatorElements(pos.clone(), Rc::new(nodes))));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 558 -         return Ok(Rc::new(SyntaxNode::DesignatorElements(pos.clone(), Rc::new(nodes.into()))));
[INFO] [stdout] 558 +         return Ok(Rc::new(SyntaxNode::DesignatorElements(pos.clone(), Rc::new(<Vec<SyntaxNode> as Into<_>>::into(nodes)))));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `ActiveOberon2019` (bin "ActiveOberon2019" test) due to 85 previous errors; 1 warning emitted
[INFO] running `Command { std: "docker" "inspect" "bb9743a8e582d6bbfdc2660c80031d2c7de412d6f6f787c28eb68e47af537477", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "bb9743a8e582d6bbfdc2660c80031d2c7de412d6f6f787c28eb68e47af537477", kill_on_drop: false }`
[INFO] [stdout] bb9743a8e582d6bbfdc2660c80031d2c7de412d6f6f787c28eb68e47af537477
