[INFO] fetching crate starling 4.0.0...
[INFO] checking starling-4.0.0 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] extracting crate starling 4.0.0 into /workspace/builds/worker-5-tc2/source
[INFO] started tweaking crates.io crate starling 4.0.0
[INFO] finished tweaking crates.io crate starling 4.0.0
[INFO] tweaked toml for crates.io crate starling 4.0.0 written to /workspace/builds/worker-5-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate starling 4.0.0 on toolchain a5689b034ad287112f709693384a37f1377eb9cc
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate starling 4.0.0 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-5-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 5a093af5301c96573567170fa0fb31794b97d31ff0b8972ed4ce714fe4d55e00
[INFO] running `Command { std: "docker" "start" "5a093af5301c96573567170fa0fb31794b97d31ff0b8972ed4ce714fe4d55e00", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "5a093af5301c96573567170fa0fb31794b97d31ff0b8972ed4ce714fe4d55e00", 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" "5a093af5301c96573567170fa0fb31794b97d31ff0b8972ed4ce714fe4d55e00" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "5a093af5301c96573567170fa0fb31794b97d31ff0b8972ed4ce714fe4d55e00", 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" "5a093af5301c96573567170fa0fb31794b97d31ff0b8972ed4ce714fe4d55e00" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling libc v0.2.126
[INFO] [stderr]    Compiling serde v1.0.138
[INFO] [stderr]    Compiling crossbeam-utils v0.8.10
[INFO] [stderr]    Compiling semver v1.0.12
[INFO] [stderr]    Compiling memoffset v0.6.5
[INFO] [stderr]     Checking once_cell v1.12.0
[INFO] [stderr]    Compiling crossbeam-epoch v0.9.9
[INFO] [stderr]    Compiling proc-macro2 v1.0.40
[INFO] [stderr]    Compiling memchr v2.5.0
[INFO] [stderr]    Compiling rayon-core v1.9.3
[INFO] [stderr]    Compiling quote v1.0.20
[INFO] [stderr]    Compiling unicode-ident v1.0.1
[INFO] [stderr]    Compiling num-traits v0.2.15
[INFO] [stderr]     Checking ryu v1.0.10
[INFO] [stderr]     Checking either v1.7.0
[INFO] [stderr]    Compiling syn v1.0.98
[INFO] [stderr]    Compiling rustc_version v0.4.0
[INFO] [stderr]    Compiling serde_json v1.0.82
[INFO] [stderr]     Checking crossbeam-channel v0.5.5
[INFO] [stderr]     Checking getrandom v0.2.7
[INFO] [stderr]     Checking num_cpus v1.13.1
[INFO] [stderr]    Compiling rayon v1.5.3
[INFO] [stderr]     Checking crossbeam-deque v0.8.1
[INFO] [stderr]    Compiling cast v0.2.7
[INFO] [stderr]     Checking plotters-backend v0.3.2
[INFO] [stderr]     Checking itoa v1.0.2
[INFO] [stderr]     Checking regex-automata v0.1.10
[INFO] [stderr]     Checking unicode-width v0.1.9
[INFO] [stderr]    Compiling serde_derive v1.0.138
[INFO] [stderr]     Checking textwrap v0.11.0
[INFO] [stderr]     Checking plotters-svg v0.3.1
[INFO] [stderr]     Checking rand_core v0.6.3
[INFO] [stderr]     Checking csv-core v0.1.10
[INFO] [stderr]     Checking itertools v0.10.3
[INFO] [stderr]     Checking itoa v0.4.8
[INFO] [stderr]    Compiling starling v4.0.0 (/opt/rustwide/workdir)
[INFO] [stderr]     Checking regex-syntax v0.6.26
[INFO] [stderr]     Checking ppv-lite86 v0.2.16
[INFO] [stderr]     Checking half v1.8.2
[INFO] [stderr]     Checking walkdir v2.3.2
[INFO] [stderr]     Checking clap v2.34.0
[INFO] [stderr]     Checking plotters v0.3.1
[INFO] [stderr]     Checking rand_chacha v0.3.1
[INFO] [stderr]     Checking atty v0.2.14
[INFO] [stderr]     Checking rand v0.8.5
[INFO] [stderr]     Checking regex v1.5.6
[INFO] [stderr]     Checking criterion-plot v0.4.4
[INFO] [stderr]     Checking bstr v0.2.17
[INFO] [stderr]     Checking serde_cbor v0.11.2
[INFO] [stderr]     Checking csv v1.1.6
[INFO] [stderr]     Checking tinytemplate v1.2.1
[INFO] [stderr]     Checking criterion v0.3.5
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]  --> examples/main.rs:7:15
[INFO] [stdout]   |
[INFO] [stdout] 7 |     let key = [0x00; 32].into();
[INFO] [stdout]   |               ^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 7 -     let key = [0x00; 32].into();
[INFO] [stdout] 7 +     let key = [0x00; 32];
[INFO] [stdout]   |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]   |
[INFO] [stdout] 7 -     let key = [0x00; 32].into();
[INFO] [stdout] 7 +     let key = <[u8; 32] as Into<_>>::into([0x00; 32]);
[INFO] [stdout]   |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `starling` (example "main") due to 1 previous error
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> benches/merkle_bit_benches.rs:140:19
[INFO] [stdout]     |
[INFO] [stdout] 140 |         keys.push(key_value.into());
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 140 -         keys.push(key_value.into());
[INFO] [stdout] 140 +         keys.push(key_value);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 140 -         keys.push(key_value.into());
[INFO] [stdout] 140 +         keys.push(<[u8; 32] as Into<_>>::into(key_value));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> benches/big_benches.rs:143:19
[INFO] [stdout]     |
[INFO] [stdout] 143 |         keys.push(key_value.into());
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 143 -         keys.push(key_value.into());
[INFO] [stdout] 143 +         keys.push(key_value);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 143 -         keys.push(key_value.into());
[INFO] [stdout] 143 +         keys.push(<[u8; 32] as Into<_>>::into(key_value));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `starling` (bench "merkle_bit_benches") due to 1 previous error
[INFO] [stderr] error: could not compile `starling` (bench "big_benches") due to 1 previous error
[INFO] [stdout] warning: unused variable: `res`
[INFO] [stdout]     --> src/merkle_bit.rs:1081:14
[INFO] [stdout]      |
[INFO] [stdout] 1081 |         for &res in result.0 {
[INFO] [stdout]      |              ^^^ help: if this is intentional, prefix it with an underscore: `_res`
[INFO] [stdout]      |
[INFO] [stdout]      = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `res`
[INFO] [stdout]     --> src/merkle_bit.rs:1085:14
[INFO] [stdout]      |
[INFO] [stdout] 1085 |         for &res in result.1 {
[INFO] [stdout]      |              ^^^ help: if this is intentional, prefix it with an underscore: `_res`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `res`
[INFO] [stdout]     --> src/merkle_bit.rs:1111:14
[INFO] [stdout]      |
[INFO] [stdout] 1111 |         for &res in result.0 {
[INFO] [stdout]      |              ^^^ help: if this is intentional, prefix it with an underscore: `_res`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused variable: `res`
[INFO] [stdout]     --> src/merkle_bit.rs:1115:14
[INFO] [stdout]      |
[INFO] [stdout] 1115 |         for &res in result.1 {
[INFO] [stdout]      |              ^^^ help: if this is intentional, prefix it with an underscore: `_res`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> src/merkle_bit.rs:935:38
[INFO] [stdout]     |
[INFO] [stdout] 935 |             let branch = choose_zero(key.into(), i)?;
[INFO] [stdout]     |                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 935 -             let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 935 +             let branch = choose_zero(key, i)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 935 -             let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 935 +             let branch = choose_zero(<[u8; 32] as Into<_>>::into(key), i)?;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> src/merkle_bit.rs:947:42
[INFO] [stdout]     |
[INFO] [stdout] 947 |                 let branch = choose_zero(key.into(), i)?;
[INFO] [stdout]     |                                          ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 947 -                 let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 947 +                 let branch = choose_zero(key, i)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 947 -                 let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 947 +                 let branch = choose_zero(<[u8; 32] as Into<_>>::into(key), i)?;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> src/merkle_bit.rs:955:38
[INFO] [stdout]     |
[INFO] [stdout] 955 |             let branch = choose_zero(key.into(), i)?;
[INFO] [stdout]     |                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 955 -             let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 955 +             let branch = choose_zero(key, i)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 955 -             let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 955 +             let branch = choose_zero(<[u8; 32] as Into<_>>::into(key), i)?;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> src/merkle_bit.rs:968:42
[INFO] [stdout]     |
[INFO] [stdout] 968 |                 let branch = choose_zero(key.into(), i)?;
[INFO] [stdout]     |                                          ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 968 -                 let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 968 +                 let branch = choose_zero(key, i)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 968 -                 let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 968 +                 let branch = choose_zero(<[u8; 32] as Into<_>>::into(key), i)?;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> src/merkle_bit.rs:976:38
[INFO] [stdout]     |
[INFO] [stdout] 976 |             let branch = choose_zero(key.into(), i)?;
[INFO] [stdout]     |                                      ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 976 -             let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 976 +             let branch = choose_zero(key, i)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 976 -             let branch = choose_zero(key.into(), i)?;
[INFO] [stdout] 976 +             let branch = choose_zero(<[u8; 32] as Into<_>>::into(key), i)?;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `starling` (lib test) due to 5 previous errors; 4 warnings emitted
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:192:23
[INFO] [stdout]     |
[INFO] [stdout] 192 |             keys.push([i << 5u8; KEY_LEN].into());
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 192 -             keys.push([i << 5u8; KEY_LEN].into());
[INFO] [stdout] 192 +             keys.push([i << 5u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 192 -             keys.push([i << 5u8; KEY_LEN].into());
[INFO] [stdout] 192 +             keys.push(<[u8; 32] as Into<_>>::into([i << 5u8; KEY_LEN]));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:214:23
[INFO] [stdout]     |
[INFO] [stdout] 214 |             keys.push([i << 5u8; KEY_LEN].into());
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 214 -             keys.push([i << 5u8; KEY_LEN].into());
[INFO] [stdout] 214 +             keys.push([i << 5u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 214 -             keys.push([i << 5u8; KEY_LEN].into());
[INFO] [stdout] 214 +             keys.push(<[u8; 32] as Into<_>>::into([i << 5u8; KEY_LEN]));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:237:23
[INFO] [stdout]     |
[INFO] [stdout] 237 |             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 237 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 237 +             keys.push([i as u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 237 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 237 +             keys.push(<[u8; 32] as Into<_>>::into([i as u8; KEY_LEN]));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:261:23
[INFO] [stdout]     |
[INFO] [stdout] 261 |             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 261 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 261 +             keys.push([i as u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 261 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 261 +             keys.push(<[u8; 32] as Into<_>>::into([i as u8; KEY_LEN]));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:285:23
[INFO] [stdout]     |
[INFO] [stdout] 285 |             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 285 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 285 +             keys.push([i as u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 285 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 285 +             keys.push(<[u8; 32] as Into<_>>::into([i as u8; KEY_LEN]));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:309:23
[INFO] [stdout]     |
[INFO] [stdout] 309 |             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 309 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 309 +             keys.push([i as u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 309 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 309 +             keys.push(<[u8; 32] as Into<_>>::into([i as u8; KEY_LEN]));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:332:23
[INFO] [stdout]     |
[INFO] [stdout] 332 |             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 332 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 332 +             keys.push([i as u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 332 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 332 +             keys.push(<[u8; 32] as Into<_>>::into([i as u8; KEY_LEN]));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:364:23
[INFO] [stdout]     |
[INFO] [stdout] 364 |             keys.push(key.into());
[INFO] [stdout]     |                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 364 -             keys.push(key.into());
[INFO] [stdout] 364 +             keys.push(key);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 364 -             keys.push(key.into());
[INFO] [stdout] 364 +             keys.push(<[u8; 32] as Into<_>>::into(key));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:394:23
[INFO] [stdout]     |
[INFO] [stdout] 394 |             keys.push(key.into());
[INFO] [stdout]     |                       ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 394 -             keys.push(key.into());
[INFO] [stdout] 394 +             keys.push(key);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 394 -             keys.push(key.into());
[INFO] [stdout] 394 +             keys.push(<[u8; 32] as Into<_>>::into(key));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:421:25
[INFO] [stdout]     |
[INFO] [stdout] 421 |         let pop_key_d = [0x60u8; KEY_LEN].into(); // 0110_0000   96 (Dec)
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -         let pop_key_d = [0x60u8; KEY_LEN].into(); // 0110_0000   96 (Dec)
[INFO] [stdout] 421 +         let pop_key_d = [0x60u8; KEY_LEN]; // 0110_0000   96 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 421 -         let pop_key_d = [0x60u8; KEY_LEN].into(); // 0110_0000   96 (Dec)
[INFO] [stdout] 421 +         let pop_key_d = <[u8; 32] as Into<_>>::into([0x60u8; KEY_LEN]); // 0110_0000   96 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:422:25
[INFO] [stdout]     |
[INFO] [stdout] 422 |         let pop_key_e = [0x68u8; KEY_LEN].into(); // 0110_1000  104 (Dec)
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 422 -         let pop_key_e = [0x68u8; KEY_LEN].into(); // 0110_1000  104 (Dec)
[INFO] [stdout] 422 +         let pop_key_e = [0x68u8; KEY_LEN]; // 0110_1000  104 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 422 -         let pop_key_e = [0x68u8; KEY_LEN].into(); // 0110_1000  104 (Dec)
[INFO] [stdout] 422 +         let pop_key_e = <[u8; 32] as Into<_>>::into([0x68u8; KEY_LEN]); // 0110_1000  104 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:423:25
[INFO] [stdout]     |
[INFO] [stdout] 423 |         let pop_key_i = [0x80u8; KEY_LEN].into(); // 1000_0000  128 (Dec)
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 423 -         let pop_key_i = [0x80u8; KEY_LEN].into(); // 1000_0000  128 (Dec)
[INFO] [stdout] 423 +         let pop_key_i = [0x80u8; KEY_LEN]; // 1000_0000  128 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 423 -         let pop_key_i = [0x80u8; KEY_LEN].into(); // 1000_0000  128 (Dec)
[INFO] [stdout] 423 +         let pop_key_i = <[u8; 32] as Into<_>>::into([0x80u8; KEY_LEN]); // 1000_0000  128 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:424:25
[INFO] [stdout]     |
[INFO] [stdout] 424 |         let pop_key_o = [0xF0u8; KEY_LEN].into(); // 1111_0000  240 (Dec)
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 424 -         let pop_key_o = [0xF0u8; KEY_LEN].into(); // 1111_0000  240 (Dec)
[INFO] [stdout] 424 +         let pop_key_o = [0xF0u8; KEY_LEN]; // 1111_0000  240 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 424 -         let pop_key_o = [0xF0u8; KEY_LEN].into(); // 1111_0000  240 (Dec)
[INFO] [stdout] 424 +         let pop_key_o = <[u8; 32] as Into<_>>::into([0xF0u8; KEY_LEN]); // 1111_0000  240 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:443:21
[INFO] [stdout]     |
[INFO] [stdout] 443 |         let key_a = [0x00u8; KEY_LEN].into(); // 0000_0000     0 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 443 -         let key_a = [0x00u8; KEY_LEN].into(); // 0000_0000     0 (Dec)
[INFO] [stdout] 443 +         let key_a = [0x00u8; KEY_LEN]; // 0000_0000     0 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 443 -         let key_a = [0x00u8; KEY_LEN].into(); // 0000_0000     0 (Dec)
[INFO] [stdout] 443 +         let key_a = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]); // 0000_0000     0 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:444:21
[INFO] [stdout]     |
[INFO] [stdout] 444 |         let key_b = [0x40u8; KEY_LEN].into(); // 0100_0000    64 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 444 -         let key_b = [0x40u8; KEY_LEN].into(); // 0100_0000    64 (Dec)
[INFO] [stdout] 444 +         let key_b = [0x40u8; KEY_LEN]; // 0100_0000    64 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 444 -         let key_b = [0x40u8; KEY_LEN].into(); // 0100_0000    64 (Dec)
[INFO] [stdout] 444 +         let key_b = <[u8; 32] as Into<_>>::into([0x40u8; KEY_LEN]); // 0100_0000    64 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:445:21
[INFO] [stdout]     |
[INFO] [stdout] 445 |         let key_c = [0x41u8; KEY_LEN].into(); // 0100_0001    65 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 445 -         let key_c = [0x41u8; KEY_LEN].into(); // 0100_0001    65 (Dec)
[INFO] [stdout] 445 +         let key_c = [0x41u8; KEY_LEN]; // 0100_0001    65 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 -         let key_c = [0x41u8; KEY_LEN].into(); // 0100_0001    65 (Dec)
[INFO] [stdout] 445 +         let key_c = <[u8; 32] as Into<_>>::into([0x41u8; KEY_LEN]); // 0100_0001    65 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:446:21
[INFO] [stdout]     |
[INFO] [stdout] 446 |         let key_f = [0x70u8; KEY_LEN].into(); // 0111_0000   112 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -         let key_f = [0x70u8; KEY_LEN].into(); // 0111_0000   112 (Dec)
[INFO] [stdout] 446 +         let key_f = [0x70u8; KEY_LEN]; // 0111_0000   112 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 446 -         let key_f = [0x70u8; KEY_LEN].into(); // 0111_0000   112 (Dec)
[INFO] [stdout] 446 +         let key_f = <[u8; 32] as Into<_>>::into([0x70u8; KEY_LEN]); // 0111_0000   112 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:447:21
[INFO] [stdout]     |
[INFO] [stdout] 447 |         let key_g = [0x71u8; KEY_LEN].into(); // 0111_0001   113 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 447 -         let key_g = [0x71u8; KEY_LEN].into(); // 0111_0001   113 (Dec)
[INFO] [stdout] 447 +         let key_g = [0x71u8; KEY_LEN]; // 0111_0001   113 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 447 -         let key_g = [0x71u8; KEY_LEN].into(); // 0111_0001   113 (Dec)
[INFO] [stdout] 447 +         let key_g = <[u8; 32] as Into<_>>::into([0x71u8; KEY_LEN]); // 0111_0001   113 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:448:21
[INFO] [stdout]     |
[INFO] [stdout] 448 |         let key_h = [0x72u8; KEY_LEN].into(); // 0111_0010   114 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 448 -         let key_h = [0x72u8; KEY_LEN].into(); // 0111_0010   114 (Dec)
[INFO] [stdout] 448 +         let key_h = [0x72u8; KEY_LEN]; // 0111_0010   114 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 448 -         let key_h = [0x72u8; KEY_LEN].into(); // 0111_0010   114 (Dec)
[INFO] [stdout] 448 +         let key_h = <[u8; 32] as Into<_>>::into([0x72u8; KEY_LEN]); // 0111_0010   114 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:449:21
[INFO] [stdout]     |
[INFO] [stdout] 449 |         let key_j = [0xC0u8; KEY_LEN].into(); // 1100_0000   192 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 449 -         let key_j = [0xC0u8; KEY_LEN].into(); // 1100_0000   192 (Dec)
[INFO] [stdout] 449 +         let key_j = [0xC0u8; KEY_LEN]; // 1100_0000   192 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 449 -         let key_j = [0xC0u8; KEY_LEN].into(); // 1100_0000   192 (Dec)
[INFO] [stdout] 449 +         let key_j = <[u8; 32] as Into<_>>::into([0xC0u8; KEY_LEN]); // 1100_0000   192 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:450:21
[INFO] [stdout]     |
[INFO] [stdout] 450 |         let key_k = [0xC1u8; KEY_LEN].into(); // 1100_0001   193 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 450 -         let key_k = [0xC1u8; KEY_LEN].into(); // 1100_0001   193 (Dec)
[INFO] [stdout] 450 +         let key_k = [0xC1u8; KEY_LEN]; // 1100_0001   193 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 450 -         let key_k = [0xC1u8; KEY_LEN].into(); // 1100_0001   193 (Dec)
[INFO] [stdout] 450 +         let key_k = <[u8; 32] as Into<_>>::into([0xC1u8; KEY_LEN]); // 1100_0001   193 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:451:21
[INFO] [stdout]     |
[INFO] [stdout] 451 |         let key_l = [0xE0u8; KEY_LEN].into(); // 1110_0000   224 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects 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 -         let key_l = [0xE0u8; KEY_LEN].into(); // 1110_0000   224 (Dec)
[INFO] [stdout] 451 +         let key_l = [0xE0u8; KEY_LEN]; // 1110_0000   224 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 451 -         let key_l = [0xE0u8; KEY_LEN].into(); // 1110_0000   224 (Dec)
[INFO] [stdout] 451 +         let key_l = <[u8; 32] as Into<_>>::into([0xE0u8; KEY_LEN]); // 1110_0000   224 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:452:21
[INFO] [stdout]     |
[INFO] [stdout] 452 |         let key_m = [0xE1u8; KEY_LEN].into(); // 1110_0001   225 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 452 -         let key_m = [0xE1u8; KEY_LEN].into(); // 1110_0001   225 (Dec)
[INFO] [stdout] 452 +         let key_m = [0xE1u8; KEY_LEN]; // 1110_0001   225 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 452 -         let key_m = [0xE1u8; KEY_LEN].into(); // 1110_0001   225 (Dec)
[INFO] [stdout] 452 +         let key_m = <[u8; 32] as Into<_>>::into([0xE1u8; KEY_LEN]); // 1110_0001   225 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:453:21
[INFO] [stdout]     |
[INFO] [stdout] 453 |         let key_n = [0xE2u8; KEY_LEN].into(); // 1110_0010   226 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 453 -         let key_n = [0xE2u8; KEY_LEN].into(); // 1110_0010   226 (Dec)
[INFO] [stdout] 453 +         let key_n = [0xE2u8; KEY_LEN]; // 1110_0010   226 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 453 -         let key_n = [0xE2u8; KEY_LEN].into(); // 1110_0010   226 (Dec)
[INFO] [stdout] 453 +         let key_n = <[u8; 32] as Into<_>>::into([0xE2u8; KEY_LEN]); // 1110_0010   226 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:454:21
[INFO] [stdout]     |
[INFO] [stdout] 454 |         let key_p = [0xF8u8; KEY_LEN].into(); // 1111_1000   248 (Dec)
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 454 -         let key_p = [0xF8u8; KEY_LEN].into(); // 1111_1000   248 (Dec)
[INFO] [stdout] 454 +         let key_p = [0xF8u8; KEY_LEN]; // 1111_1000   248 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 454 -         let key_p = [0xF8u8; KEY_LEN].into(); // 1111_1000   248 (Dec)
[INFO] [stdout] 454 +         let key_p = <[u8; 32] as Into<_>>::into([0xF8u8; KEY_LEN]); // 1111_1000   248 (Dec)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:493:27
[INFO] [stdout]     |
[INFO] [stdout] 493 |         let initial_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 493 -         let initial_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 493 +         let initial_key = [0x00u8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 493 -         let initial_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 493 +         let initial_key = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:498:23
[INFO] [stdout]     |
[INFO] [stdout] 498 |             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 498 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 498 +             keys.push([i as u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 498 -             keys.push([i as u8; KEY_LEN].into());
[INFO] [stdout] 498 +             keys.push(<[u8; 32] as Into<_>>::into([i as u8; KEY_LEN]));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:523:29
[INFO] [stdout]     |
[INFO] [stdout] 523 |         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x01u8; KEY_LEN].into()];
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 523 -         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x01u8; KEY_LEN].into()];
[INFO] [stdout] 523 +         let mut keys = vec![[0x00u8; KEY_LEN], [0x01u8; KEY_LEN].into()];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 523 -         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x01u8; KEY_LEN].into()];
[INFO] [stdout] 523 +         let mut keys = vec![<[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]), [0x01u8; KEY_LEN].into()];
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:523:55
[INFO] [stdout]     |
[INFO] [stdout] 523 |         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x01u8; KEY_LEN].into()];
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 523 -         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x01u8; KEY_LEN].into()];
[INFO] [stdout] 523 +         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x01u8; KEY_LEN]];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 523 -         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x01u8; KEY_LEN].into()];
[INFO] [stdout] 523 +         let mut keys = vec![[0x00u8; KEY_LEN].into(), <[u8; 32] as Into<_>>::into([0x01u8; KEY_LEN])];
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:542:29
[INFO] [stdout]     |
[INFO] [stdout] 542 |         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x80u8; KEY_LEN].into()];
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 542 -         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x80u8; KEY_LEN].into()];
[INFO] [stdout] 542 +         let mut keys = vec![[0x00u8; KEY_LEN], [0x80u8; KEY_LEN].into()];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 542 -         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x80u8; KEY_LEN].into()];
[INFO] [stdout] 542 +         let mut keys = vec![<[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]), [0x80u8; KEY_LEN].into()];
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:542:55
[INFO] [stdout]     |
[INFO] [stdout] 542 |         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x80u8; KEY_LEN].into()];
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 542 -         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x80u8; KEY_LEN].into()];
[INFO] [stdout] 542 +         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x80u8; KEY_LEN]];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 542 -         let mut keys = vec![[0x00u8; KEY_LEN].into(), [0x80u8; KEY_LEN].into()];
[INFO] [stdout] 542 +         let mut keys = vec![[0x00u8; KEY_LEN].into(), <[u8; 32] as Into<_>>::into([0x80u8; KEY_LEN])];
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:560:19
[INFO] [stdout]     |
[INFO] [stdout] 560 |         let key = [0xAAu8; KEY_LEN].into();
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 560 -         let key = [0xAAu8; KEY_LEN].into();
[INFO] [stdout] 560 +         let key = [0xAAu8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 560 -         let key = [0xAAu8; KEY_LEN].into();
[INFO] [stdout] 560 +         let key = <[u8; 32] as Into<_>>::into([0xAAu8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:577:13
[INFO] [stdout]     |
[INFO] [stdout] 577 |             [0xAAu8; KEY_LEN].into(), // 1010_1010
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 577 -             [0xAAu8; KEY_LEN].into(), // 1010_1010
[INFO] [stdout] 577 +             [0xAAu8; KEY_LEN], // 1010_1010
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 577 -             [0xAAu8; KEY_LEN].into(), // 1010_1010
[INFO] [stdout] 577 +             <[u8; 32] as Into<_>>::into([0xAAu8; KEY_LEN]), // 1010_1010
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:578:13
[INFO] [stdout]     |
[INFO] [stdout] 578 |             [0xBBu8; KEY_LEN].into(), // 1011_1011
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 578 -             [0xBBu8; KEY_LEN].into(), // 1011_1011
[INFO] [stdout] 578 +             [0xBBu8; KEY_LEN], // 1011_1011
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 578 -             [0xBBu8; KEY_LEN].into(), // 1011_1011
[INFO] [stdout] 578 +             <[u8; 32] as Into<_>>::into([0xBBu8; KEY_LEN]), // 1011_1011
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:579:13
[INFO] [stdout]     |
[INFO] [stdout] 579 |             [0xCCu8; KEY_LEN].into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 579 -             [0xCCu8; KEY_LEN].into(),
[INFO] [stdout] 579 +             [0xCCu8; KEY_LEN],
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 579 -             [0xCCu8; KEY_LEN].into(),
[INFO] [stdout] 579 +             <[u8; 32] as Into<_>>::into([0xCCu8; KEY_LEN]),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:724:25
[INFO] [stdout]     |
[INFO] [stdout] 724 |         let first_key = [0xAAu8; KEY_LEN].into();
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 724 -         let first_key = [0xAAu8; KEY_LEN].into();
[INFO] [stdout] 724 +         let first_key = [0xAAu8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 724 -         let first_key = [0xAAu8; KEY_LEN].into();
[INFO] [stdout] 724 +         let first_key = <[u8; 32] as Into<_>>::into([0xAAu8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:727:26
[INFO] [stdout]     |
[INFO] [stdout] 727 |         let second_key = [0xCCu8; KEY_LEN].into();
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 727 -         let second_key = [0xCCu8; KEY_LEN].into();
[INFO] [stdout] 727 +         let second_key = [0xCCu8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 727 -         let second_key = [0xCCu8; KEY_LEN].into();
[INFO] [stdout] 727 +         let second_key = <[u8; 32] as Into<_>>::into([0xCCu8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:819:19
[INFO] [stdout]     |
[INFO] [stdout] 819 |         let key = [0xAAu8; KEY_LEN].into();
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 819 -         let key = [0xAAu8; KEY_LEN].into();
[INFO] [stdout] 819 +         let key = [0xAAu8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 819 -         let key = [0xAAu8; KEY_LEN].into();
[INFO] [stdout] 819 +         let key = <[u8; 32] as Into<_>>::into([0xAAu8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:883:33
[INFO] [stdout]     |
[INFO] [stdout] 883 |         let missing_root_hash = [0x00u8; KEY_LEN].into();
[INFO] [stdout]     |                                 ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 883 -         let missing_root_hash = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 883 +         let missing_root_hash = [0x00u8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 883 -         let missing_root_hash = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 883 +         let missing_root_hash = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:894:19
[INFO] [stdout]     |
[INFO] [stdout] 894 |         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 894 -         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 894 +         let key = [0x00u8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 894 -         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 894 +         let key = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:951:25
[INFO] [stdout]     |
[INFO] [stdout] 951 |         let first_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 951 -         let first_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 951 +         let first_key = [0x00u8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 951 -         let first_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 951 +         let first_key = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:957:26
[INFO] [stdout]     |
[INFO] [stdout] 957 |         let second_key = [0x02u8; KEY_LEN].into();
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 957 -         let second_key = [0x02u8; KEY_LEN].into();
[INFO] [stdout] 957 +         let second_key = [0x02u8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 957 -         let second_key = [0x02u8; KEY_LEN].into();
[INFO] [stdout] 957 +         let second_key = <[u8; 32] as Into<_>>::into([0x02u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:979:25
[INFO] [stdout]     |
[INFO] [stdout] 979 |         let first_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 979 -         let first_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 979 +         let first_key = [0x00u8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 979 -         let first_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 979 +         let first_key = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:980:26
[INFO] [stdout]     |
[INFO] [stdout] 980 |         let second_key = [0x01u8; KEY_LEN].into();
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 980 -         let second_key = [0x01u8; KEY_LEN].into();
[INFO] [stdout] 980 +         let second_key = [0x01u8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 980 -         let second_key = [0x01u8; KEY_LEN].into();
[INFO] [stdout] 980 +         let second_key = <[u8; 32] as Into<_>>::into([0x01u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:981:25
[INFO] [stdout]     |
[INFO] [stdout] 981 |         let third_key = [0x02u8; KEY_LEN].into();
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 981 -         let third_key = [0x02u8; KEY_LEN].into();
[INFO] [stdout] 981 +         let third_key = [0x02u8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 981 -         let third_key = [0x02u8; KEY_LEN].into();
[INFO] [stdout] 981 +         let third_key = <[u8; 32] as Into<_>>::into([0x02u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]    --> tests/merkle_bit.rs:982:26
[INFO] [stdout]     |
[INFO] [stdout] 982 |         let fourth_key = [0x03u8; KEY_LEN].into();
[INFO] [stdout]     |                          ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 982 -         let fourth_key = [0x03u8; KEY_LEN].into();
[INFO] [stdout] 982 +         let fourth_key = [0x03u8; KEY_LEN];
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 982 -         let fourth_key = [0x03u8; KEY_LEN].into();
[INFO] [stdout] 982 +         let fourth_key = <[u8; 32] as Into<_>>::into([0x03u8; KEY_LEN]);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1079:13
[INFO] [stdout]      |
[INFO] [stdout] 1079 |             [0x00u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1079 -             [0x00u8; KEY_LEN].into(),
[INFO] [stdout] 1079 +             [0x00u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1079 -             [0x00u8; KEY_LEN].into(),
[INFO] [stdout] 1079 +             <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1080:13
[INFO] [stdout]      |
[INFO] [stdout] 1080 |             [0x01u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1080 -             [0x01u8; KEY_LEN].into(),
[INFO] [stdout] 1080 +             [0x01u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1080 -             [0x01u8; KEY_LEN].into(),
[INFO] [stdout] 1080 +             <[u8; 32] as Into<_>>::into([0x01u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1081:13
[INFO] [stdout]      |
[INFO] [stdout] 1081 |             [0x02u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1081 -             [0x02u8; KEY_LEN].into(),
[INFO] [stdout] 1081 +             [0x02u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1081 -             [0x02u8; KEY_LEN].into(),
[INFO] [stdout] 1081 +             <[u8; 32] as Into<_>>::into([0x02u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1082:13
[INFO] [stdout]      |
[INFO] [stdout] 1082 |             [0x10u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1082 -             [0x10u8; KEY_LEN].into(),
[INFO] [stdout] 1082 +             [0x10u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1082 -             [0x10u8; KEY_LEN].into(),
[INFO] [stdout] 1082 +             <[u8; 32] as Into<_>>::into([0x10u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1083:13
[INFO] [stdout]      |
[INFO] [stdout] 1083 |             [0x20u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1083 -             [0x20u8; KEY_LEN].into(),
[INFO] [stdout] 1083 +             [0x20u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1083 -             [0x20u8; KEY_LEN].into(),
[INFO] [stdout] 1083 +             <[u8; 32] as Into<_>>::into([0x20u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1112:13
[INFO] [stdout]      |
[INFO] [stdout] 1112 |             [0x10u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1112 -             [0x10u8; KEY_LEN].into(),
[INFO] [stdout] 1112 +             [0x10u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1112 -             [0x10u8; KEY_LEN].into(),
[INFO] [stdout] 1112 +             <[u8; 32] as Into<_>>::into([0x10u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1113:13
[INFO] [stdout]      |
[INFO] [stdout] 1113 |             [0x11u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1113 -             [0x11u8; KEY_LEN].into(),
[INFO] [stdout] 1113 +             [0x11u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1113 -             [0x11u8; KEY_LEN].into(),
[INFO] [stdout] 1113 +             <[u8; 32] as Into<_>>::into([0x11u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1114:13
[INFO] [stdout]      |
[INFO] [stdout] 1114 |             [0x00u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1114 -             [0x00u8; KEY_LEN].into(),
[INFO] [stdout] 1114 +             [0x00u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1114 -             [0x00u8; KEY_LEN].into(),
[INFO] [stdout] 1114 +             <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1115:13
[INFO] [stdout]      |
[INFO] [stdout] 1115 |             [0x01u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1115 -             [0x01u8; KEY_LEN].into(),
[INFO] [stdout] 1115 +             [0x01u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1115 -             [0x01u8; KEY_LEN].into(),
[INFO] [stdout] 1115 +             <[u8; 32] as Into<_>>::into([0x01u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1116:13
[INFO] [stdout]      |
[INFO] [stdout] 1116 |             [0x02u8; KEY_LEN].into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1116 -             [0x02u8; KEY_LEN].into(),
[INFO] [stdout] 1116 +             [0x02u8; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1116 -             [0x02u8; KEY_LEN].into(),
[INFO] [stdout] 1116 +             <[u8; 32] as Into<_>>::into([0x02u8; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1169:19
[INFO] [stdout]      |
[INFO] [stdout] 1169 |         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout]      |                   ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1169 -         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 1169 +         let key = [0x00u8; KEY_LEN];
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1169 -         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 1169 +         let key = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1189:19
[INFO] [stdout]      |
[INFO] [stdout] 1189 |         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout]      |                   ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1189 -         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 1189 +         let key = [0x00u8; KEY_LEN];
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1189 -         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 1189 +         let key = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1207:19
[INFO] [stdout]      |
[INFO] [stdout] 1207 |         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout]      |                   ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1207 -         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 1207 +         let key = [0x00u8; KEY_LEN];
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1207 -         let key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 1207 +         let key = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1213:45
[INFO] [stdout]      |
[INFO] [stdout] 1213 |         match Tree::verify_inclusion_proof(&[01u8; KEY_LEN].into(), key, &data, &inclusion_proof) {
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1213 -         match Tree::verify_inclusion_proof(&[01u8; KEY_LEN].into(), key, &data, &inclusion_proof) {
[INFO] [stdout] 1213 +         match Tree::verify_inclusion_proof(&[01u8; KEY_LEN], key, &data, &inclusion_proof) {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1213 -         match Tree::verify_inclusion_proof(&[01u8; KEY_LEN].into(), key, &data, &inclusion_proof) {
[INFO] [stdout] 1213 +         match Tree::verify_inclusion_proof(&<[u8; 32] as Into<_>>::into([01u8; KEY_LEN]), key, &data, &inclusion_proof) {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1288:18
[INFO] [stdout]      |
[INFO] [stdout] 1288 |                 &[0x03; KEY_LEN].into(),
[INFO] [stdout]      |                  ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1288 -                 &[0x03; KEY_LEN].into(),
[INFO] [stdout] 1288 +                 &[0x03; KEY_LEN],
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1288 -                 &[0x03; KEY_LEN].into(),
[INFO] [stdout] 1288 +                 &<[u8; 32] as Into<_>>::into([0x03; KEY_LEN]),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1305:19
[INFO] [stdout]      |
[INFO] [stdout] 1305 |         let key = [0x96u8; KEY_LEN].into();
[INFO] [stdout]      |                   ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1305 -         let key = [0x96u8; KEY_LEN].into();
[INFO] [stdout] 1305 +         let key = [0x96u8; KEY_LEN];
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1305 -         let key = [0x96u8; KEY_LEN].into();
[INFO] [stdout] 1305 +         let key = <[u8; 32] as Into<_>>::into([0x96u8; KEY_LEN]);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1348:19
[INFO] [stdout]      |
[INFO] [stdout] 1348 |         let key = [0x78u8; KEY_LEN].into();
[INFO] [stdout]      |                   ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1348 -         let key = [0x78u8; KEY_LEN].into();
[INFO] [stdout] 1348 +         let key = [0x78u8; KEY_LEN];
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1348 -         let key = [0x78u8; KEY_LEN].into();
[INFO] [stdout] 1348 +         let key = <[u8; 32] as Into<_>>::into([0x78u8; KEY_LEN]);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1377:24
[INFO] [stdout]      |
[INFO] [stdout] 1377 |         let test_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout]      |                        ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1377 -         let test_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 1377 +         let test_key = [0x00u8; KEY_LEN];
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1377 -         let test_key = [0x00u8; KEY_LEN].into();
[INFO] [stdout] 1377 +         let test_key = <[u8; 32] as Into<_>>::into([0x00u8; KEY_LEN]);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `[u8; 32]`
[INFO] [stdout]     --> tests/merkle_bit.rs:1552:23
[INFO] [stdout]      |
[INFO] [stdout] 1552 |             keys.push(key_value.into());
[INFO] [stdout]      |                       ^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1552 -             keys.push(key_value.into());
[INFO] [stdout] 1552 +             keys.push(key_value);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1552 -             keys.push(key_value.into());
[INFO] [stdout] 1552 +             keys.push(<[u8; 32] as Into<_>>::into(key_value));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `starling` (test "merkle_bit") due to 65 previous errors
[INFO] running `Command { std: "docker" "inspect" "5a093af5301c96573567170fa0fb31794b97d31ff0b8972ed4ce714fe4d55e00", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "5a093af5301c96573567170fa0fb31794b97d31ff0b8972ed4ce714fe4d55e00", kill_on_drop: false }`
[INFO] [stdout] 5a093af5301c96573567170fa0fb31794b97d31ff0b8972ed4ce714fe4d55e00
